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.

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

Paper

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

The paper is loaded when this pane is shown.

The authors' code

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

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

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
At the source: github.com/Suni-Jose/Autism-detection-using-MRI

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.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
[2] 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
[3] doi:10.1038/s41398-026-04081-8 [code]
Functional system-specific brain aging across the Alzheimer's disease continuum.
Journal: Translational psychiatry
In common: imbalanced-learn, Keras, TensorFlow, 6 other tools, structural MRI / diffusion, clinical / translational
[4] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: imbalanced-learn, XGBoost, TensorFlow, 6 other tools
[5] doi:10.1371/journal.pcbi.1014615 [code]
Toward reliable machine learning models for neural circuit inference: A diagnostic study of CNNs on spike trains.
Journal: PLoS computational biology
In common: XGBoost, Keras, TensorFlow, 6 other tools
[6] doi:10.1038/s41598-026-64405-y [code]
Evaluating clinical and neuroimaging predictors for cognitive-behavioral therapy outcome in obsessive-compulsive disorder.
Journal: Scientific reports
In common: imbalanced-learn, XGBoost, seaborn, 5 other tools, structural MRI / diffusion, clinical / translational
[7] doi:10.1371/journal.pgen.1012242 [code]
Wiz regulates clustered protocadherin genes by restricting CTCF/cohesin loop extrusion in a genomic-distance biased manner.
Journal: PLoS genetics
In common: XGBoost, Keras, TensorFlow, 6 other tools
[8] doi:10.3389/fpsyg.2026.1774068 [code]
Analysis of cognitive mechanisms in phoneme perception and pronunciation errors among Korean language learners.
Journal: Frontiers in psychology
In common: XGBoost, Keras, TensorFlow, 6 other tools
[9] doi:10.1038/s41598-026-48613-0 [code]
An snRNA-seq aging clock for the fruit fly head sheds light on sex-biased aging.
Journal: Scientific reports
In common: XGBoost, Keras, TensorFlow, 6 other tools
[10] doi:10.1016/j.nicl.2026.104012 [code]
Structural-functional multilayer brain network properties and outcome of combined repetitive transcranial magnetic stimulation and psychotherapy for obsessive-compulsive disorder.
Journal: NeuroImage. Clinical
In common: imbalanced-learn, XGBoost, seaborn, 5 other tools, structural MRI / diffusion

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.