OSCR

Autism spectrum disorder identification using machine learning models on MRI data.

Code ↔ Paper

11 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.

One block of code here has a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.

The 11 matches
  1. [1] § Results and discussion ↔ notebooks/Cross_validation_Sun_MRI .ipynb, lines 592 to 679 · score 0.75 · fold Cross Validation, ROC AUC, ensemble model, voting, proxy, Stratified · Report a mismatch
  2. [2] § Results and discussion ↔ notebooks/Suni_Final_MRI.ipynb, lines 1298 to 1391 · score 0.74 · fold Cross Validation, ROC AUC, ensemble model, voting, proxy, Stratified · Report a mismatch
  3. [3] § Materials and, ethods › Data sources ↔ datasets/preprocessed_datasets/preprocessed_pipeline.py, lines 23 to 26 · score 0.73 · anat_qap.csv, dti_qap.csv, functional_qap.csv, pipeline, preprocessed · block oscr:b:K4S7G2XBZ132Q-O · Report a mismatch
  4. [4] § Materials and, ethods › Data sources ↔ datasets/preprocessed_datasets/preprocessed_pipeline.py, lines 23 to 26 · score 0.70 · anat_qap.csv, dti_qap.csv, functional_qap.csv, preprocessing · block oscr:b:K4S7G2XBZ132Q-O · Report a mismatch
  5. [5] § Model Training and validation › Deep learning architectures: 1D-CNN and ResNet ↔ notebooks/Cross_validation_Sun_MRI .ipynb, lines 194 to 312 · score 0.66 · ResNet, blocks, binary, layers, shortcut, Adam · Report a mismatch
  6. [6] § Model Training and validation › Deep learning architectures: 1D-CNN and ResNet ↔ notebooks/Suni_Final_MRI.ipynb, lines 185 to 311 · score 0.64 · ResNet, blocks, binary, layers, shortcut, Adam · Report a mismatch
  7. [7] § Materials and, ethods › Feature engineering ↔ notebooks/Suni_Final_MRI.ipynb, lines 1298 to 1391 · score 0.60 · Feature engineering, crucial, integrity, FD, technical, MIS · Report a mismatch
  8. [8] § Model Training and validation › Model validation ↔ notebooks/Cross_validation_Sun_MRI .ipynb, lines 592 to 679 · score 0.58 · fold Cross Validation, Stratified, ensemble, split, preprocessed, KNN · Report a mismatch
  9. [9] § Model Training and validation › Support Vector Machines (SVM) ↔ notebooks/Cross_validation_Sun_MRI .ipynb, lines 315 to 430 · score 0.58 · GridSearchCV, SVM model, RBF, gamma, kernel, probabilities · Report a mismatch
  10. [10] § Model Training and validation › Deep learning architectures: 1D-CNN and ResNet ↔ notebooks/Cross_validation_Sun_MRI .ipynb, lines 130 to 191 · score 0.55 · dropout, ReLU, activation, softmax, filters, dense · Report a mismatch
  11. [11] § Model Training and validation › Deep learning architectures: 1D-CNN and ResNet ↔ notebooks/Suni_Final_MRI.ipynb, lines 122 to 141 · score 0.54 · dropout, ReLU, activation, softmax, filters, dense · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 679 lines · 25 KB · MIT · 5 matches

  1. # %%
  2. import pandas as pd
  3. from google.colab import drive
  4. drive.mount('/content/drive')
  5. # %%
  6. from google.colab import drive
  7. drive.mount('/content/drive')
  8. # %%
  9. !pip install imbalanced-learn scikit-learn tensorflow matplotlib seaborn
  10. # %%
  11. import pandas as pd
  12. import numpy as np
  13. import pandas as pd
  14. import matplotlib.pyplot as plt
  15. import seaborn as sns
  16. from sklearn.ensemble import RandomForestClassifier
  17. from sklearn.decomposition import PCA
  18. from sklearn.cluster import DBSCAN
  19. from sklearn.model_selection import train_test_split
  20. from sklearn.metrics import accuracy_score, classification_report, f1_score, precision_score, recall_score, roc_curve, auc, confusion_matrix
  21. from scipy.cluster.hierarchy import linkage, dendrogram
  22. from tensorflow.keras.models import Sequential
  23. from tensorflow.keras.layers import Conv1D, MaxPooling1D, Flatten, Dense, Dropout
  24. from tensorflow.keras.optimizers import Adam
  25. from tensorflow.keras.utils import to_categorical
  26. from imblearn.over_sampling import SMOTE
  27. # %%
  28. # Load the dataset
  29. df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/preprocessed_features.csv')
  30. if "Sub_ID" in df.columns:
  31. df.drop(columns=["Sub_ID"], inplace=True)
  32. # %%
  33. # Compute new features
  34. df["SNR_Difference"] = df["SNR_anat"] - df["SNR_dti"]
  35. df["FSVI"] = df[["DVARS", "DVARS_func"]].mean(axis=1)
  36. df["MIS"] = df[["PercentFD_greater_than_0.20", "PercentFD_greater_than_0.20_func"]].sum(axis=1)
  37. df.fillna(df.median(), inplace=True)
  38. # Correlation matrix
  39. numeric_df = df.select_dtypes(include=['number'])
  40. plt.figure(figsize=(12, 8))
  41. sns.heatmap(numeric_df.corr(), annot=True, fmt=".2f", cmap="coolwarm", linewidths=0.5)
  42. plt.title("Correlation Matrix of MRI Features")
  43. plt.show()
  44. features = numeric_df.columns.tolist()
  45. X_features = df[features]
  46. threshold = df["FSVI"].median()
  47. df["Refined_Diagnosis"] = np.where(df["FSVI"] > threshold, "ASD-like", "Control-like")
  48. y_labels = df["Refined_Diagnosis"].map({"Control-like": 0, "ASD-like": 1})
  49. X_train, X_test, y_train, y_test = train_test_split(X_features, y_labels, test_size=0.2, random_state=42, stratify=y_labels)
  50. smote = SMOTE(random_state=42)
  51. X_train_res, y_train_res = smote.fit_resample(X_train, y_train)
  52. # %%
  53. # Random Forest
  54. rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
  55. rf_model.fit(X_train_res, y_train_res)
  56. rf_pred = rf_model.predict(X_test)
  57. print("Random Forest Accuracy:", accuracy_score(y_test, rf_pred))
  58. print("Random Forest Precision:", precision_score(y_test, rf_pred))
  59. print("Random Forest Recall:", recall_score(y_test, rf_pred))
  60. print("Random Forest F1 Score:", f1_score(y_test, rf_pred))
  61. print("Random Forest Classification Report:\n", classification_report(y_test, rf_pred))
  62. # Confusion Matrix for Random Forest
  63. conf_matrix_rf = confusion_matrix(y_test, rf_pred)
  64. plt.figure(figsize=(6, 4))
  65. sns.heatmap(conf_matrix_rf, annot=True, fmt='d', cmap='Blues', xticklabels=["Control-like", "ASD-like"], yticklabels=["Control-like", "ASD-like"])
  66. plt.title('Random Forest Confusion Matrix')
  67. plt.ylabel('True Label')
  68. plt.xlabel('Predicted Label')
  69. plt.show()
  70. # ROC Curve for Random Forest
  71. rf_pred_prob = rf_model.predict_proba(X_test)[:, 1]
  72. fpr_rf, tpr_rf, _ = roc_curve(y_test, rf_pred_prob)
  73. roc_auc_rf = auc(fpr_rf, tpr_rf)
  74. plt.figure(figsize=(6, 4))
  75. plt.plot(fpr_rf, tpr_rf, color='darkorange', lw=2, label='ROC Curve (AUC = {:.2f})'.format(roc_auc_rf))
  76. plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
  77. plt.title('Random Forest ROC Curve')
  78. plt.xlabel('False Positive Rate')
  79. plt.ylabel('True Positive Rate')
  80. plt.legend(loc="lower right")
  81. plt.show()
  82. # %%
  83. # PCA Visualization
  84. pca = PCA(n_components=2)
  85. X_pca = pca.fit_transform(X_features)
  86. df["PCA1"], df["PCA2"] = X_pca[:, 0], X_pca[:, 1]
  87. # Hierarchical Clustering
  88. plt.figure(figsize=(12, 6))
  89. linkage_matrix = linkage(X_pca, method='ward')
  90. dendrogram(linkage_matrix, labels=df["Refined_Diagnosis"].values, leaf_rotation=90, leaf_font_size=8)
  91. plt.title("Hierarchical Clustering Dendrogram")
  92. plt.xlabel("Subjects")
  93. plt.ylabel("Distance")
  94. plt.show()
  95. # DBSCAN Clustering
  96. dbscan = DBSCAN(eps=0.5, min_samples=5)
  97. df["DBSCAN_Cluster"] = dbscan.fit_predict(X_pca)
  98. plt.figure(figsize=(10, 6))
  99. sns.scatterplot(x=df["PCA1"], y=df["PCA2"], hue=df["DBSCAN_Cluster"], palette="viridis", alpha=0.7)
  100. plt.title("DBSCAN Clustering on MRI Data")
  101. plt.xlabel("Principal Component 1")
  102. plt.ylabel("Principal Component 2")
  103. plt.legend(title="Cluster ID")
  104. plt.show()
  105. # %%
  106. # CNN Model
  107. X_train_cnn_res = X_train_res.values.reshape(X_train_res.shape[0], X_train_res.shape[1], 1)
  108. X_test_cnn = X_test.values.reshape(X_test.shape[0], X_test.shape[1], 1)
  109. y_train_cnn_res = to_categorical(y_train_res, num_classes=2)
  110. y_test_cnn = to_categorical(y_test, num_classes=2)
  111. cnn_model = Sequential()
  112. cnn_model.add(Conv1D(filters=64, kernel_size=3, activation='relu', input_shape=(X_train.shape[1], 1)))
  113. cnn_model.add(MaxPooling1D(pool_size=2))
  114. cnn_model.add(Conv1D(filters=128, kernel_size=3, activation='relu'))
  115. cnn_model.add(MaxPooling1D(pool_size=2))
  116. cnn_model.add(Flatten())
  117. cnn_model.add(Dense(128, activation='relu'))
  118. cnn_model.add(Dropout(0.5))
  119. cnn_model.add(Dense(2, activation='softmax'))
  120. cnn_model.compile(optimizer=Adam(learning_rate=0.001), loss='categorical_crossentropy', metrics=['accuracy'])
  121. history = cnn_model.fit(X_train_cnn_res, y_train_cnn_res, epochs=20, batch_size=32, validation_split=0.2, verbose=1)
  122. # CNN Evaluation
  123. cnn_pred_prob = cnn_model.predict(X_test_cnn)
  124. cnn_pred = np.argmax(cnn_pred_prob, axis=1)
  125. y_test_labels = np.argmax(y_test_cnn, axis=1)
  126. print("CNN Accuracy:", accuracy_score(y_test_labels, cnn_pred))
  127. print("CNN Precision:", precision_score(y_test_labels, cnn_pred))
  128. print("CNN Recall:", recall_score(y_test_labels, cnn_pred))
  129. print("CNN F1 Score:", f1_score(y_test_labels, cnn_pred))
  130. print("CNN Classification Report:\n", classification_report(y_test_labels, cnn_pred))
  131. # Confusion Matrix for CNN
  132. conf_matrix_cnn = confusion_matrix(y_test_labels, cnn_pred)
  133. plt.figure(figsize=(6, 4))
  134. sns.heatmap(conf_matrix_cnn, annot=True, fmt='d', cmap='Blues', xticklabels=["Control-like", "ASD-like"], yticklabels=["Control-like", "ASD-like"])
  135. plt.title('CNN Confusion Matrix')
  136. plt.ylabel('True Label')
  137. plt.xlabel('Predicted Label')
  138. plt.show()
  139. # ROC Curve for CNN
  140. fpr_cnn, tpr_cnn, _ = roc_curve(y_test_labels, cnn_pred_prob[:, 1])
  141. roc_auc_cnn = auc(fpr_cnn, tpr_cnn)
  142. plt.figure(figsize=(6, 4))
  143. plt.plot(fpr_cnn, tpr_cnn, color='darkorange', lw=2, label='ROC Curve (AUC = {:.2f})'.format(roc_auc_cnn))
  144. plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
  145. plt.title('CNN ROC Curve')
  146. plt.xlabel('False Positive Rate')
  147. plt.ylabel('True Positive Rate')
  148. plt.legend(loc="lower right")
  149. plt.show()
  150. # Outlier Analysis
  151. outliers_df = df[df["DBSCAN_Cluster"] == -1]
  152. df = df[df["DBSCAN_Cluster"] != -1]
  153. outlier_stats = outliers_df[features].mean()
  154. non_outlier_stats = df[features].mean()
  155. outlier_deviation = ((outlier_stats - non_outlier_stats) / non_outlier_stats) * 100
  156. print("Top Outlier Deviations:\n", outlier_deviation.sort_values(ascending=False).head(10))
  157. # %%
  158. #resnet
  159. import numpy as np
  160. import pandas as pd
  161. import matplotlib.pyplot as plt
  162. import seaborn as sns
  163. from sklearn.model_selection import train_test_split
  164. from sklearn.metrics import accuracy_score, classification_report, f1_score, precision_score, recall_score, roc_curve, auc, confusion_matrix
  165. from tensorflow.keras.models import Model
  166. from tensorflow.keras.layers import Input, Conv1D, BatchNormalization, Activation, Add, GlobalAveragePooling1D, Dense
  167. from tensorflow.keras.utils import to_categorical
  168. from tensorflow.keras.optimizers import Adam
  169. from imblearn.over_sampling import SMOTE
  170. # Load the dataset
  171. df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/preprocessed_features.csv')
  172. # Drop Sub_ID if present
  173. if "Sub_ID" in df.columns:
  174. df.drop(columns=["Sub_ID"], inplace=True)
  175. # Compute new features
  176. df["SNR_Difference"] = df["SNR_anat"] - df["SNR_dti"]
  177. df["FSVI"] = df[["DVARS", "DVARS_func"]].mean(axis=1)
  178. df["MIS"] = df[["PercentFD_greater_than_0.20", "PercentFD_greater_than_0.20_func"]].sum(axis=1)
  179. # Handle missing values
  180. df.fillna(df.median(), inplace=True)
  181. # Define features and target
  182. numeric_df = df.select_dtypes(include=['number'])
  183. features = numeric_df.columns.tolist()
  184. X_features = df[features]
  185. # Define binary target (ASD-like and Control-like)
  186. threshold = df["FSVI"].median()
  187. df["Refined_Diagnosis"] = np.where(df["FSVI"] > threshold, "ASD-like", "Control-like")
  188. y_labels = df["Refined_Diagnosis"].map({"Control-like": 0, "ASD-like": 1})
  189. # Train-test split
  190. X_train, X_test, y_train, y_test = train_test_split(X_features, y_labels, test_size=0.2, random_state=42, stratify=y_labels)
  191. # Apply SMOTE for class imbalance
  192. smote = SMOTE(random_state=42)
  193. X_train_res, y_train_res = smote.fit_resample(X_train, y_train)
  194. # Reshape data for 1D ResNet (samples, time_steps, features)
  195. X_train_res = X_train_res.values.reshape(X_train_res.shape[0], X_train_res.shape[1], 1)
  196. X_test = X_test.values.reshape(X_test.shape[0], X_test.shape[1], 1)
  197. # One-hot encode labels
  198. y_train_res_cat = to_categorical(y_train_res, num_classes=2)
  199. y_test_cat = to_categorical(y_test, num_classes=2)
  200. # Define a simple 1D ResNet block
  201. def resnet_block(input_layer, filters, kernel_size=3):
  202. x = Conv1D(filters, kernel_size, padding="same")(input_layer)
  203. x = BatchNormalization()(x)
  204. x = Activation("relu")(x)
  205. x = Conv1D(filters, kernel_size, padding="same")(x)
  206. x = BatchNormalization()(x)
  207. # Skip connection
  208. shortcut = Conv1D(filters, 1, padding="same")(input_layer)
  209. x = Add()([x, shortcut])
  210. x = Activation("relu")(x)
  211. return x
  212. # Build the 1D ResNet model
  213. input_layer = Input(shape=(X_train_res.shape[1], 1))
  214. x = resnet_block(input_layer, 64)
  215. x = resnet_block(x, 128)
  216. x = resnet_block(x, 256)
  217. x = GlobalAveragePooling1D()(x)
  218. x = Dense(128, activation="relu")(x)
  219. x = Dense(2, activation="softmax")(x)
  220. resnet_model = Model(inputs=input_layer, outputs=x)
  221. # Compile the model
  222. resnet_model.compile(optimizer=Adam(learning_rate=0.001), loss='categorical_crossentropy', metrics=['accuracy'])
  223. # Train the model
  224. history = resnet_model.fit(X_train_res, y_train_res_cat, epochs=30, batch_size=32, validation_split=0.2, verbose=1)
  225. # Predict on test set
  226. y_pred_prob = resnet_model.predict(X_test)
  227. y_pred = np.argmax(y_pred_prob, axis=1)
  228. # Evaluate performance
  229. print("ResNet Accuracy:", accuracy_score(y_test, y_pred))
  230. print("ResNet Precision:", precision_score(y_test, y_pred))
  231. print("ResNet Recall:", recall_score(y_test, y_pred))
  232. print("ResNet F1 Score:", f1_score(y_test, y_pred))
  233. print("ResNet Classification Report:\n", classification_report(y_test, y_pred))
  234. # Plot confusion matrix
  235. conf_matrix = confusion_matrix(y_test, y_pred)
  236. plt.figure(figsize=(6, 4))
  237. sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues', xticklabels=["Control-like", "ASD-like"], yticklabels=["Control-like", "ASD-like"])
  238. plt.title('ResNet Confusion Matrix')
  239. plt.ylabel('True Label')
  240. plt.xlabel('Predicted Label')
  241. plt.show()
  242. # ROC Curve
  243. fpr, tpr, _ = roc_curve(y_test, y_pred_prob[:, 1])
  244. roc_auc = auc(fpr, tpr)
  245. plt.figure(figsize=(6, 4))
  246. plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC Curve (AUC = {:.2f})'.format(roc_auc))
  247. plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
  248. plt.xlabel('False Positive Rate')
  249. plt.ylabel('True Positive Rate')
  250. plt.title('ResNet ROC Curve')
  251. plt.legend(loc="lower right")
  252. plt.show()
  253. # %%
  254. import numpy as np
  255. import pandas as pd
  256. import matplotlib.pyplot as plt
  257. import seaborn as sns
  258. from sklearn.ensemble import RandomForestClassifier
  259. from sklearn.decomposition import PCA
  260. from sklearn.cluster import DBSCAN
  261. from sklearn.svm import SVC
  262. from sklearn.neighbors import KNeighborsClassifier
  263. from xgboost import XGBClassifier
  264. from sklearn.model_selection import train_test_split, GridSearchCV
  265. from sklearn.metrics import accuracy_score, classification_report, f1_score, precision_score, recall_score, roc_curve, auc, confusion_matrix
  266. from scipy.cluster.hierarchy import linkage, dendrogram
  267. # Load the dataset
  268. df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/preprocessed_features.csv')
  269. # Ensure Sub_ID is removed if necessary
  270. if "Sub_ID" in df.columns:
  271. df.drop(columns=["Sub_ID"], inplace=True)
  272. # Compute new features
  273. df["SNR_Difference"] = df["SNR_anat"] - df["SNR_dti"]
  274. df["FSVI"] = df[["DVARS", "DVARS_func"]].mean(axis=1)
  275. df["MIS"] = df[["PercentFD_greater_than_0.20", "PercentFD_greater_than_0.20_func"]].sum(axis=1)
  276. # Handle missing values
  277. df.fillna(df.median(), inplace=True)
  278. # Define features for model training
  279. numeric_df = df.select_dtypes(include=['number'])
  280. features = numeric_df.columns.tolist()
  281. X_features = df[features]
  282. # Define target labels
  283. threshold = df["FSVI"].median()
  284. df["Refined_Diagnosis"] = np.where(df["FSVI"] > threshold, "ASD-like", "Control-like")
  285. y_labels = df["Refined_Diagnosis"].map({"Control-like": 0, "ASD-like": 1})
  286. # Train-test split
  287. X_train, X_test, y_train, y_test = train_test_split(X_features, y_labels, test_size=0.2, random_state=42)
  288. # Train models
  289. rf = RandomForestClassifier(n_estimators=100, max_depth=10, min_samples_split=5, random_state=42)
  290. rf.fit(X_train, y_train)
  291. param_grid = {'C': [0.1, 1, 10], 'gamma': ['scale', 'auto', 0.01, 0.1, 1], 'kernel': ['rbf']}
  292. grid_search = GridSearchCV(SVC(probability=True), param_grid, cv=5, scoring='accuracy')
  293. grid_search.fit(X_train, y_train)
  294. svm_model = grid_search.best_estimator_
  295. knn_model = KNeighborsClassifier(n_neighbors=5)
  296. knn_model.fit(X_train, y_train)
  297. xgb_model = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
  298. xgb_model.fit(X_train, y_train)
  299. # Predictions
  300. svm_pred, knn_pred, xgb_pred = svm_model.predict(X_test), knn_model.predict(X_test), xgb_model.predict(X_test)
  301. svm_probs = svm_model.predict_proba(X_test)[:, 1]
  302. knn_probs = knn_model.predict_proba(X_test)[:, 1]
  303. xgb_probs = xgb_model.predict_proba(X_test)[:, 1]
  304. # Compute evaluation metrics
  305. def evaluate_model(name, y_test, y_pred):
  306. print(f"{name} Accuracy:", accuracy_score(y_test, y_pred))
  307. print(f"{name} Precision:", precision_score(y_test, y_pred))
  308. print(f"{name} Recall:", recall_score(y_test, y_pred))
  309. print(f"{name} F1 Score:", f1_score(y_test, y_pred))
  310. print(f"{name} Classification Report:\n", classification_report(y_test, y_pred))
  311. evaluate_model("SVM", y_test, svm_pred)
  312. evaluate_model("KNN", y_test, knn_pred)
  313. evaluate_model("XGBoost", y_test, xgb_pred)
  314. # AUC-ROC Plots
  315. fpr_svm, tpr_svm, _ = roc_curve(y_test, svm_probs)
  316. roc_auc_svm = auc(fpr_svm, tpr_svm)
  317. fpr_knn, tpr_knn, _ = roc_curve(y_test, knn_probs)
  318. roc_auc_knn = auc(fpr_knn, tpr_knn)
  319. fpr_xgb, tpr_xgb, _ = roc_curve(y_test, xgb_probs)
  320. roc_auc_xgb = auc(fpr_xgb, tpr_xgb)
  321. plt.figure(figsize=(10, 6))
  322. plt.plot(fpr_svm, tpr_svm, color='blue', label=f'SVM (AUC = {roc_auc_svm:.2f})')
  323. plt.plot(fpr_knn, tpr_knn, color='red', label=f'KNN (AUC = {roc_auc_knn:.2f})')
  324. plt.plot(fpr_xgb, tpr_xgb, color='green', label=f'XGBoost (AUC = {roc_auc_xgb:.2f})')
  325. plt.plot([0, 1], [0, 1], color='gray', linestyle='--')
  326. plt.xlabel("False Positive Rate")
  327. plt.ylabel("True Positive Rate")
  328. plt.title("ROC Curve")
  329. plt.legend()
  330. plt.show()
  331. # Confusion Matrices
  332. plt.figure(figsize=(18, 5))
  333. plt.subplot(1, 3, 1)
  334. sns.heatmap(confusion_matrix(y_test, svm_pred), annot=True, fmt='d', cmap='Blues')
  335. plt.title("SVM Confusion Matrix")
  336. plt.xlabel("Predicted")
  337. plt.ylabel("Actual")
  338. plt.subplot(1, 3, 2)
  339. sns.heatmap(confusion_matrix(y_test, knn_pred), annot=True, fmt='d', cmap='Reds')
  340. plt.title("KNN Confusion Matrix")
  341. plt.xlabel("Predicted")
  342. plt.ylabel("Actual")
  343. plt.subplot(1, 3, 3)
  344. sns.heatmap(confusion_matrix(y_test, xgb_pred), annot=True, fmt='d', cmap='Greens')
  345. plt.title("XGBoost Confusion Matrix")
  346. plt.xlabel("Predicted")
  347. plt.ylabel("Actual")
  348. plt.show()
  349. # %%
  350. #ENSEMBLE - MAJORITY
  351. import numpy as np
  352. import pandas as pd
  353. import matplotlib.pyplot as plt
  354. import seaborn as sns
  355. from sklearn.decomposition import PCA
  356. from sklearn.cluster import DBSCAN
  357. from sklearn.svm import SVC
  358. from sklearn.neighbors import KNeighborsClassifier
  359. from xgboost import XGBClassifier
  360. from sklearn.model_selection import train_test_split, GridSearchCV
  361. from sklearn.metrics import accuracy_score, classification_report, f1_score, precision_score, recall_score, roc_curve, auc, confusion_matrix
  362. from scipy.cluster.hierarchy import linkage, dendrogram
  363. # Load the dataset
  364. df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/preprocessed_features.csv')
  365. # Ensure Sub_ID is removed if necessary
  366. if "Sub_ID" in df.columns:
  367. df.drop(columns=["Sub_ID"], inplace=True)
  368. # Compute new features
  369. df["SNR_Difference"] = df["SNR_anat"] - df["SNR_dti"]
  370. df["FSVI"] = df[["DVARS", "DVARS_func"]].mean(axis=1)
  371. df["MIS"] = df[["PercentFD_greater_than_0.20", "PercentFD_greater_than_0.20_func"]].sum(axis=1)
  372. # Handle missing values
  373. df.fillna(df.median(), inplace=True)
  374. # Define features for model training
  375. numeric_df = df.select_dtypes(include=['number'])
  376. features = numeric_df.columns.tolist()
  377. X_features = df[features]
  378. # Define target labels
  379. threshold = df["FSVI"].median()
  380. df["Refined_Diagnosis"] = np.where(df["FSVI"] > threshold, "ASD-like", "Control-like")
  381. y_labels = df["Refined_Diagnosis"].map({"Control-like": 0, "ASD-like": 1})
  382. # Train-test split
  383. X_train, X_test, y_train, y_test = train_test_split(X_features, y_labels, test_size=0.2, random_state=42)
  384. # Apply DBSCAN for outlier detection
  385. dbscan = DBSCAN(eps=0.5, min_samples=5)
  386. df['DBSCAN_Cluster'] = dbscan.fit_predict(X_features)
  387. # Identify outliers (DBSCAN assigns label -1 to outliers)
  388. outliers_df = df[df["DBSCAN_Cluster"] == -1]
  389. non_outliers_df = df[df["DBSCAN_Cluster"] != -1]
  390. # Visualize outliers
  391. plt.figure(figsize=(10, 6))
  392. sns.scatterplot(x=non_outliers_df['FSVI'], y=non_outliers_df['DVARS'], color='blue', label='Non-Outliers')
  393. sns.scatterplot(x=outliers_df['FSVI'], y=outliers_df['DVARS'], color='red', label='Outliers')
  394. plt.xlabel("FSVI")
  395. plt.ylabel("DVARS")
  396. plt.title("Outlier Detection using DBSCAN")
  397. plt.legend()
  398. plt.show()
  399. # Optionally, remove outliers
  400. df_cleaned = non_outliers_df.drop(columns=['DBSCAN_Cluster'])
  401. # Define features for model training again (after removing outliers if necessary)
  402. X_features_cleaned = df_cleaned[features]
  403. # Re-split the cleaned data
  404. X_train_cleaned, X_test_cleaned, y_train_cleaned, y_test_cleaned = train_test_split(X_features_cleaned, y_labels.loc[df_cleaned.index], test_size=0.2, random_state=42)
  405. # Train models
  406. param_grid = {'C': [0.1, 1, 10], 'gamma': ['scale', 'auto', 0.01, 0.1, 1], 'kernel': ['rbf']}
  407. grid_search = GridSearchCV(SVC(probability=True), param_grid, cv=5, scoring='accuracy')
  408. grid_search.fit(X_train_cleaned, y_train_cleaned)
  409. svm_model = grid_search.best_estimator_
  410. knn_model = KNeighborsClassifier(n_neighbors=5)
  411. knn_model.fit(X_train_cleaned, y_train_cleaned)
  412. xgb_model = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
  413. xgb_model.fit(X_train_cleaned, y_train_cleaned)
  414. # Predictions
  415. svm_pred, knn_pred, xgb_pred = svm_model.predict(X_test_cleaned), knn_model.predict(X_test_cleaned), xgb_model.predict(X_test_cleaned)
  416. svm_probs = svm_model.predict_proba(X_test_cleaned)[:, 1]
  417. knn_probs = knn_model.predict_proba(X_test_cleaned)[:, 1]
  418. xgb_probs = xgb_model.predict_proba(X_test_cleaned)[:, 1]
  419. # Compute overall evaluation metrics
  420. def evaluate_models(y_test, preds):
  421. overall_accuracy = np.mean([accuracy_score(y_test, pred) for pred in preds])
  422. overall_precision = np.mean([precision_score(y_test, pred) for pred in preds])
  423. overall_recall = np.mean([recall_score(y_test, pred) for pred in preds])
  424. overall_f1 = np.mean([f1_score(y_test, pred) for pred in preds])
  425. print("Overall Model Evaluation:")
  426. print(f"Accuracy: {overall_accuracy:.4f}")
  427. print(f"Precision: {overall_precision:.4f}")
  428. print(f"Recall: {overall_recall:.4f}")
  429. print(f"F1 Score: {overall_f1:.4f}")
  430. evaluate_models(y_test_cleaned, [svm_pred, knn_pred, xgb_pred])
  431. # AUC-ROC Curve
  432. fpr_svm, tpr_svm, _ = roc_curve(y_test_cleaned, svm_probs)
  433. fpr_knn, tpr_knn, _ = roc_curve(y_test_cleaned, knn_probs)
  434. fpr_xgb, tpr_xgb, _ = roc_curve(y_test_cleaned, xgb_probs)
  435. plt.figure(figsize=(10, 6))
  436. plt.plot(fpr_svm, tpr_svm, color='blue', label=f'SVM (AUC = {auc(fpr_svm, tpr_svm):.2f})')
  437. plt.plot(fpr_knn, tpr_knn, color='red', label=f'KNN (AUC = {auc(fpr_knn, tpr_knn):.2f})')
  438. plt.plot(fpr_xgb, tpr_xgb, color='green', label=f'XGBoost (AUC = {auc(fpr_xgb, tpr_xgb):.2f})')
  439. plt.plot([0, 1], [0, 1], color='gray', linestyle='--')
  440. plt.xlabel("False Positive Rate")
  441. plt.ylabel("True Positive Rate")
  442. plt.title("ROC Curve")
  443. plt.legend()
  444. plt.show()
  445. # Confusion Matrix for Combined Model Predictions
  446. final_preds = (svm_pred + knn_pred + xgb_pred) >= 2 # Majority Voting
  447. conf_matrix = confusion_matrix(y_test_cleaned, final_preds)
  448. plt.figure(figsize=(6, 6))
  449. sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues')
  450. plt.title("Overall Confusion Matrix")
  451. plt.xlabel("Predicted")
  452. plt.ylabel("Actual")
  453. plt.show()
  454. # Correlation Heatmap
  455. plt.figure(figsize=(12, 8))
  456. correlation_matrix = df_cleaned.corr(numeric_only=True)
  457. sns.heatmap(correlation_matrix, annot=True, fmt=".2f", cmap='coolwarm', linewidths=0.5)
  458. plt.title("Correlation Matrix - Cleaned Data")
  459. plt.show()
  460. # PCA Visualization
  461. pca = PCA(n_components=2)
  462. X_pca = pca.fit_transform(X_features_cleaned)
  463. plt.figure(figsize=(10, 6))
  464. scatter = plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_labels.loc[df_cleaned.index], cmap='viridis', edgecolor='k', alpha=0.8)
  465. plt.colorbar(scatter, label="Diagnosis (0 = Control, 1 = ASD-like)")
  466. plt.xlabel("Principal Component 1")
  467. plt.ylabel("Principal Component 2")
  468. plt.title("PCA Visualization of Data")
  469. plt.show()
  470. # Hierarchical Clustering Dendrogram
  471. plt.figure(figsize=(12, 6))
  472. linkage_matrix = linkage(X_features_cleaned, method='ward')
  473. dendrogram(linkage_matrix, leaf_rotation=90, leaf_font_size=8)
  474. plt.title("Hierarchical Clustering Dendrogram")
  475. plt.xlabel("Sample Index")
  476. plt.ylabel("Distance")
  477. plt.show()
  478. # %%
  479. import pandas as pd
  480. import numpy as np
  481. from sklearn.model_selection import StratifiedKFold, cross_validate
  482. from sklearn.svm import SVC
  483. from sklearn.neighbors import KNeighborsClassifier
  484. from xgboost import XGBClassifier
  485. from sklearn.ensemble import VotingClassifier
  486. from sklearn.cluster import DBSCAN
  487. from sklearn.metrics import make_scorer, accuracy_score, precision_score, recall_score, f1_score
  488. # 1. Load the Dataset
  489. # Replace 'preprocessed_features.csv' with your actual file path
  490. df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/preprocessed_features.csv')
  491. # 2. Preprocessing & Feature Engineering
  492. if "Sub_ID" in df.columns:
  493. df.drop(columns=["Sub_ID"], inplace=True)
  494. # Create engineered metrics
  495. df["SNR_Difference"] = df["SNR_anat"] - df["SNR_dti"]
  496. df["FSVI"] = df[["DVARS", "DVARS_func"]].mean(axis=1)
  497. df["MIS"] = df[["PercentFD_greater_than_0.20", "PercentFD_greater_than_0.20_func"]].sum(axis=1)
  498. # Handle missing values
  499. df.fillna(df.median(numeric_only=True), inplace=True)
  500. # Select numeric features for the model
  501. numeric_df = df.select_dtypes(include=['number'])
  502. features = numeric_df.columns.tolist()
  503. X_all = df[features]
  504. # Define Target (Using the FSVI median threshold proxy)
  505. threshold = df["FSVI"].median()
  506. df["Target"] = np.where(df["FSVI"] > threshold, 1, 0)
  507. y_all = df["Target"]
  508. # 3. Outlier Removal (DBSCAN)
  509. dbscan = DBSCAN(eps=0.5, min_samples=5)
  510. df['DBSCAN_Cluster'] = dbscan.fit_predict(X_all)
  511. df_cleaned = df[df["DBSCAN_Cluster"] != -1].copy()
  512. X = df_cleaned[features]
  513. y = y_all.loc[df_cleaned.index]
  514. # 4. Define the Ensemble Models
  515. # Parameters aligned with the optimal settings found in your notebook
  516. svm_clf = SVC(C=10, kernel='rbf', gamma='scale', probability=True, random_state=42)
  517. knn_clf = KNeighborsClassifier(n_neighbors=5)
  518. xgb_clf = XGBClassifier(
  519. n_estimators=100,
  520. learning_rate=0.1,
  521. max_depth=3,
  522. use_label_encoder=False,
  523. eval_metric='logloss',
  524. random_state=42
  525. )
  526. # Create the Majority Voting Ensemble
  527. voting_clf = VotingClassifier(
  528. estimators=[('svm', svm_clf), ('knn', knn_clf), ('xgb', xgb_clf)],
  529. voting='hard'
  530. )
  531. # 5. Stratified 10-Fold Cross-Validation Setup
  532. skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
  533. # Define metrics to track
  534. scoring = ['accuracy', 'precision', 'recall', 'f1']
  535. # Run Cross-Validation
  536. print("Running Stratified 10-Fold Cross-Validation...")
  537. cv_results = cross_validate(voting_clf, X, y, cv=skf, scoring=scoring)
  538. # Calculate AUC separately using a Soft Voting version (required for probability-based metrics)
  539. voting_clf_soft = VotingClassifier(
  540. estimators=[('svm', svm_clf), ('knn', knn_clf), ('xgb', xgb_clf)],
  541. voting='soft'
  542. )
  543. cv_auc = cross_validate(voting_clf_soft, X, y, cv=skf, scoring='roc_auc')
  544. # 6. Output Final Results for the Paper
  545. print("\n--- Final Model Performance (Mean ± SD) ---")
  546. print(f"Accuracy: {np.mean(cv_results['test_accuracy'])*100:.2f}% (±{np.std(cv_results['test_accuracy'])*100:.2f}%)")
  547. print(f"Precision: {np.mean(cv_results['test_precision'])*100:.2f}% (±{np.std(cv_results['test_precision'])*100:.2f}%)")
  548. print(f"Recall: {np.mean(cv_results['test_recall'])*100:.2f}% (±{np.std(cv_results['test_recall'])*100:.2f}%)")
  549. print(f"F1-Score: {np.mean(cv_results['test_f1'])*100:.2f}% (±{np.std(cv_results['test_f1'])*100:.2f}%)")
  550. print(f"ROC AUC: {np.mean(cv_auc['test_score']):.4f} (±{np.std(cv_auc['test_score']):.4f})")

Cross_validation_Sun_MRI .ipynb at commit 54dc118, under MIT · at the source

Overview

Authors: Milner Paul V1,2, Caren Babu3, Suni Jose4, Shuma Adhikari1, Loitongbam Surajkumar Singh5, Jijo Francis6, Adarsh V Parekkattil7
  1. Department of Electrical Engineering, National Institute of Technology Manipur (NITM), Manipur, India
  2. Department of Electrical and Electronics Engineering, Christ College of Engineering, Thrissur, Kerala 680125 India
  3. Department of Electronics and Communication Engineering, Christ College of Engineering, Thrissur, Kerala 680125 India
  4. Department of Computer Science and Engineering, Christ College of Engineering, Thrissur, Kerala 680125 India
  5. Department of Electronics and Communication Engineering, National Institute of Technology Manipur (NITM), Manipur, India
  6. Department of Zoology, Christ College (Autonomous), 680125 Irinjalakuda, India
  7. Department of Electronics and Communication, Indian Institute of Technology Roorkee (IITR), Roorkee, India
Journal: Scientific reports, volume 16, issue 1, article 24650
Dates: received 8 July 2025; accepted 22 May 2026; published online 29 May 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41598-026-55163-y · PMID 42215668 · PMCID PMC13454262 · OpenAlex W7162797121
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: structural MRI / diffusion (modality), human (organism), autism (population), clinical / translational (subfield)
Methods: Smoothing, state filtering, decompositions, Machine learning, Connectivity, fMRI & imaging
Keywords: Autism spectrum disorder, Early detection, Machine learning, Magnetic resonance imaging, Convolutional neural network (CNN), Biomarkers, Computational biology and bioinformatics, Engineering, Neuroscience
MeSH: Autism Spectrum Disorder*, Machine Learning*, Magnetic Resonance Imaging*, Classification Algorithms, Clustering Algorithms, Convolutional Neural Networks, Humans (* major topic)
Topic: Autism Spectrum Disorder Research (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 28 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.

Repositories

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

Zenodo 20196663

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (3 files), scikit-learn (3 files), imbalanced-learn (2 files), Keras (2 files), Matplotlib (2 files), NumPy (2 files), SciPy (2 files), seaborn (2 files), TensorFlow (2 files), XGBoost (2 files)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
4 files

Suni-Jose/Autism-detection-using-MRI

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 54dc118e83fcc35ac87cb578020720a448c48a2c, 15 May 2026
Languages: Jupyter (2), Python (1)
Size: 10 files, 3 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, 2 notebooks
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (3 files), scikit-learn (3 files), imbalanced-learn (2 files), Keras (2 files), Matplotlib (2 files), NumPy (2 files), SciPy (2 files), seaborn (2 files), TensorFlow (2 files), XGBoost (2 files)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
5 files

Code availability statement

The paper has a code 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-55163-y.

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 6 scripts, each with its path and the digest of its content;
  • 11 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

Datasets cited

Data availability statement

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

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41598-026-55163-y.

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, 7 authors, 9 keywords, 7 MeSH terms, 9 references.

Cite

This paper

V, M. P., Babu, C., Jose, S., Adhikari, S., Singh, L. S., Francis, J., & Parekkattil, A. V. (2026). Autism spectrum disorder identification using machine learning models on MRI data. Scientific reports, 16(1), 24650. https://doi.org/10.1038/s41598-026-55163-y

BibTeX

@article{v2026autism,
author = {V, Milner Paul and Babu, Caren and Jose, Suni and Adhikari, Shuma and Singh, Loitongbam Surajkumar and Francis, Jijo and Parekkattil, Adarsh V},
title = {{Autism spectrum disorder identification using machine learning models on MRI data}},
journal = {Scientific reports},
year = {2026},
month = may,
volume = {16},
number = {1},
pages = {24650},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-55163-y},
url = {https://doi.org/10.1038/s41598-026-55163-y},
pmid = {42215668},
pmcid = {PMC13454262}
}

RIS

TY - JOUR
AU - V, Milner Paul
AU - Babu, Caren
AU - Jose, Suni
AU - Adhikari, Shuma
AU - Singh, Loitongbam Surajkumar
AU - Francis, Jijo
AU - Parekkattil, Adarsh V
TI - Autism spectrum disorder identification using machine learning models on MRI data
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/05/29
VL - 16
IS - 1
SP - 24650
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-55163-y
UR - https://doi.org/10.1038/s41598-026-55163-y
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-55163-y",
"type": "article-journal",
"title": "Autism spectrum disorder identification using machine learning models on MRI data",
"container-title": "Scientific reports",
"author": [
{
"family": "V",
"given": "Milner Paul"
},
{
"family": "Babu",
"given": "Caren"
},
{
"family": "Jose",
"given": "Suni"
},
{
"family": "Adhikari",
"given": "Shuma"
},
{
"family": "Singh",
"given": "Loitongbam Surajkumar"
},
{
"family": "Francis",
"given": "Jijo"
},
{
"family": "Parekkattil",
"given": "Adarsh V"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "24650",
"DOI": "10.1038/s41598-026-55163-y",
"PMID": "42215668",
"PMCID": "PMC13454262",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-55163-y",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
29
]
]
}
}

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.heliyon.2024.e36728 [code]
Prediction of future dementia among patients with mild cognitive impairment (MCI) by integrating multimodal clinical data.
Journal: Heliyon
In common: imbalanced-learn, XGBoost, Keras, 7 other tools, structural MRI / diffusion, clinical / translational
[2] doi:10.1007/s41666-025-00209-5 [code]
A Hybrid Bidirectional Deep Learning Model Using HRV for Prediction of ICU Mortality Risk in TBI Patients.
Journal: Journal of healthcare informatics research
In common: imbalanced-learn, XGBoost, Keras, 7 other tools, clinical / translational
[3] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: imbalanced-learn, XGBoost, Keras, 7 other tools
[4] doi:10.3390/s26175327 [code]
Subject Identity Confounds qEEG Emotion Recognition on DEAP and DREAMER.
Journal: Sensors (Basel, Switzerland)
In common: imbalanced-learn, XGBoost, Keras, 7 other tools
[5] doi:10.1038/s41467-025-57027-x [code]
Topological identification and interpretation for single-cell epigenetic regulation elucidation in multi-tasks using scAGDE.
Journal: Nature communications
In common: imbalanced-learn, XGBoost, Keras, 7 other tools
[6] doi:10.1007/s00401-023-02561-5 [code]
Ganglioglioma with adverse clinical outcome and atypical histopathological features were defined by alterations in PTPN11/KRAS/NF1 and other RAS-/MAP-Kinase pathway genes.
Journal: Acta neuropathologica
In common: imbalanced-learn, XGBoost, Keras, 7 other tools
[7] doi:10.1038/s41380-022-01918-8 [code]
Predicting childhood and adolescent attention-deficit/hyperactivity disorder onset: a nationwide deep learning approach.
Journal: Molecular psychiatry
In common: imbalanced-learn, XGBoost, Keras, 7 other tools
[8] doi:10.1007/s00401-021-02386-0 [code]
DNA methylation-based classification of malformations of cortical development in the human brain.
Journal: Acta neuropathologica
In common: imbalanced-learn, XGBoost, Keras, 7 other tools
[9] doi:10.1002/jcv2.12042 [code]
Ensemble classification of autism spectrum disorder using structural magnetic resonance imaging features.
Journal: JCPP advances
In common: XGBoost, Keras, TensorFlow, 5 other tools, autism, structural MRI / diffusion, clinical / translational, 1 reference
[10] doi:10.3390/diagnostics15162060 [code]
A Feature-Augmented Explainable Artificial Intelligence Model for Diagnosing Alzheimer's Disease from Multimodal Clinical and Neuroimaging Data.
Journal: Diagnostics (Basel, Switzerland)
In common: imbalanced-learn, XGBoost, Keras, 6 other tools, structural MRI / diffusion, clinical / translational

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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1038/s41598-026-55163-y.svg)](https://openscicode.org/badge/doi/10.1038/s41598-026-55163-y)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1038/s41598-026-55163-y.svg
   :target: https://openscicode.org/badge/doi/10.1038/s41598-026-55163-y
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s41598-026-55163-y"><img src="https://openscicode.org/badge/doi/10.1038/s41598-026-55163-y.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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