An EEG-Based Edge-AI Framework for Alzheimer's and Creutzfeldt-Jakob Disease Classification.

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] § 2. Materials and Methods › 2.3. Experimental Setup ↔ EEG/sourcecodes/EEG_fair_nael.py, lines 16–67 · score 0.84 · d_model, encoder layers, CNN feature extractor, Transformer encoder, ELU, max
[2] § 2. Materials and Methods › 2.2. Proposed Hybrid EEG Decoder System › 2.2.1. Custom 1D-CNN Feature Extractor ↔ EEG/sourcecodes/EEG_fair_nael.py, lines 16–67 · score 0.72 · CNN feature extractor, Transformer encoder, Linear, ELU, max, permuted
[3] § 2. Materials and Methods › 2.1. EEG Signal Preprocessing and Dataset Construction ↔ EEG/sourcecodes/EEG_fair_nael.py, lines 472–511 · score 0.53 · random seed, CV, CNTRL, epoch, CJD, LOSO

Paper

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

The paper is loaded when this pane is shown.

The paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 512 lines · 17 KB · no license · 3 matches

import os
import json
import csv
import numpy as np
from tqdm import tqdm
from sklearn.metrics import confusion_matrix, accuracy_score, classification_report
from sklearn.model_selection import StratifiedKFold
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, Dataset
import datetime
# Hybrid Model for NAEL Project to decode the ALzheimer's disease from CJD and CNTRL.
class CNNTransformerEEG(nn.Module):
def __init__(self, n_channels=19, n_times=1280, n_classes=3,
cnn_out_channels=64, n_heads=2, n_layers=2):
super().__init__()
# ---- Simple CNN feature extractor (NO padding) ----
self.cnn = nn.Sequential(
nn.Conv1d(
in_channels=n_channels,
out_channels=cnn_out_channels,
kernel_size=25,
padding=0
),
nn.BatchNorm1d(cnn_out_channels),
nn.ELU(),
nn.MaxPool1d(kernel_size=4),
nn.Conv1d(
in_channels=cnn_out_channels,
out_channels=cnn_out_channels,
kernel_size=15,
padding=0
),
nn.BatchNorm1d(cnn_out_channels),
nn.ELU(),
nn.MaxPool1d(kernel_size=4),
)
# ---- Transformer encoder ----
encoder_layer = nn.TransformerEncoderLayer(
d_model=cnn_out_channels,
nhead=n_heads,
batch_first=True
)
self.transformer = nn.TransformerEncoder(
encoder_layer, num_layers=n_layers
)
# ---- Classifier ----
self.classifier = nn.Linear(cnn_out_channels, n_classes)
def forward(self, x):
# x: (B, 19, 1280)
feats = self.cnn(x) # (B, C, T')
feats = feats.permute(0, 2, 1) # (B, T', C)
feats = self.transformer(feats) # (B, T', C)
pooled = feats.mean(dim=1) # (B, C)
out = self.classifier(pooled) # (B, 3)
return out
### LOAD AND CLEAN DATA AND SAVE IT TO FOLLOWING FORMAT.
#
# Load cleaned .npz EEG files, split into 5-second epochs.
# CLEANED AND PROCESSED DATA SHOULD BE:
# data_list: list of np.arrays (n_epochs, n_channels, epoch_samples)
# labels_list: list of np.arrays (n_epochs,)
# subject_ids: list of subject identifiers
### LOSO split
def loso_split(data_list, labels_list, subject_ids):
"""
Generator for Leave-One-Subject-Out (LOSO) splits.
Yields (X_train, y_train, X_test, y_test, subject_id)
"""
n_subjects = len(subject_ids)
for i in range(n_subjects):
X_test = data_list[i]
y_test = labels_list[i]
X_train = np.concatenate([data_list[j] for j in range(n_subjects) if j != i], axis=0)
y_train = np.concatenate([labels_list[j] for j in range(n_subjects) if j != i], axis=0)
print("subject in the training and testing", )
yield X_train, y_train, X_test, y_test, subject_ids[i]
def save_onnx_model(model, n_channels, n_times, filename):
model.eval()
dummy_input = torch.randn(1, n_channels, n_times)
torch.onnx.export(
model,
dummy_input,
filename,
input_names=["input"],
output_names=["output"],
dynamic_axes={"input":{0:"batch"}, "output":{0:"batch"}},
)
print(f"Saved ONNX model: {filename}")
# ------- Small dataset wrapper for DataLoader ----------
class ADDatasetTorch(Dataset):
"""
Torch Dataset wrapper for (n_epochs, n_channels, n_times) arrays.
Returns (x, y) where x: float32 (n_channels, n_times)
"""
def __init__(self, X, y):
self.X = X.astype(np.float32)
self.y = y.astype(np.int64)
def __len__(self):
return self.X.shape[0]
def __getitem__(self, idx):
x = self.X[idx]
y = int(self.y[idx])
# models can accept (B, C, T) or (B, 1, C, T) - handled by model forward
return torch.from_numpy(x), torch.tensor(y, dtype=torch.long)
def loso_train_and_eval(
data_list, labels_list, subject_ids,
make_model_fn,
out_dir,
batch_size,
n_epochs,
lr,
weight_decay,
device,
k_folds_train
):
import os, json, csv, time, datetime
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import (
accuracy_score,
confusion_matrix,
classification_report,
balanced_accuracy_score,
precision_recall_fscore_support,
roc_auc_score
)
from sklearn.preprocessing import label_binarize
per_subject_metrics = []
# ---------- Global aggregators ----------
all_confusion_matrices = []
all_subject_accs = []
all_subject_bal_accs = []
all_subject_f1s = []
all_subject_prec = []
all_subject_recall = []
all_subject_auc = []
all_inference_times = []
# Create global label list for confusion matrix ordering
label_set = sorted(list({lab for labs in labels_list for lab in labs.tolist()})) \
if isinstance(labels_list[0], np.ndarray) else [0, 1, 2]
labels_for_cm = label_set
for X_train_all, y_train_all, X_test, y_test, subject_id in loso_split(
data_list, labels_list, subject_ids):
print("\n==========================")
print("Held-out test subject:", subject_id)
print("==========================")
# ensure numpy arrays
X_train_all = np.asarray(X_train_all)
y_train_all = np.asarray(y_train_all)
X_test = np.asarray(X_test)
y_test = np.asarray(y_test)
n_channels = X_train_all.shape[1]
n_times = X_train_all.shape[2]
print(f"Total training samples {len(X_train_all)} and test samples {len(X_test)}")
# ---------- K-Fold on training set ----------
skf = StratifiedKFold(
n_splits=k_folds_train,
shuffle=True,
random_state=RANDOM_SEED
)
best_val_acc_overall = -np.inf
best_model_state_overall = None
early_stop_patience = 5
early_stop_min_delta = 1e-4
for fold_idx, (tr_idx, val_idx) in enumerate(
skf.split(X_train_all, y_train_all), start=1):
print(f"\n--- Train CV fold {fold_idx}/{k_folds_train} ---")
X_tr, y_tr = X_train_all[tr_idx], y_train_all[tr_idx]
X_val, y_val = X_train_all[val_idx], y_train_all[val_idx]
train_loader = DataLoader(
ADDatasetTorch(X_tr, y_tr),
batch_size=batch_size,
shuffle=True
)
val_loader = DataLoader(
ADDatasetTorch(X_val, y_val),
batch_size=batch_size,
shuffle=False
)
# instantiate model fresh
model = make_model_fn.to(device)
opt = torch.optim.Adam(
model.parameters(),
lr=lr,
weight_decay=weight_decay
)
criterion = nn.CrossEntropyLoss()
best_val_acc_fold = -np.inf
best_state_fold = None
epochs_no_improve = 0
for epoch in range(1, n_epochs + 1):
# ---- Training ----
model.train()
for xb, yb in train_loader:
xb, yb = xb.to(device), yb.to(device)
opt.zero_grad()
loss = criterion(model(xb), yb)
loss.backward()
opt.step()
# ---- Validation ----
model.eval()
preds, gts = [], []
with torch.no_grad():
for xb, yb in val_loader:
xb = xb.to(device)
out = model(xb)
preds.append(out.argmax(1).cpu().numpy())
gts.append(yb.numpy())
preds = np.concatenate(preds)
gts = np.concatenate(gts)
val_acc = accuracy_score(gts, preds)
print(f"[Fold {fold_idx} | Epoch {epoch}] Val Acc: {val_acc:.4f}")
if val_acc > best_val_acc_fold + early_stop_min_delta:
best_val_acc_fold = val_acc
best_state_fold = {
k: v.cpu().clone()
for k, v in model.state_dict().items()
}
epochs_no_improve = 0
else:
epochs_no_improve += 1
if epochs_no_improve >= early_stop_patience:
print(f"[Fold {fold_idx}] Early stopping triggered")
break
if best_val_acc_fold > best_val_acc_overall:
best_val_acc_overall = best_val_acc_fold
best_model_state_overall = best_state_fold
del model, opt
torch.cuda.empty_cache()
# ---------- Final model for held-out subject ----------
model_final = CNNTransformerEEG(
n_channels=n_channels,
n_times=n_times,
n_classes=N_CLASSES
).to(device)
if best_model_state_overall is not None:
model_final.load_state_dict(best_model_state_overall)
model_final.eval()
# ---------- Save per-subject directory ----------
subj_dir = os.path.join(out_dir, f"subject_{subject_id}")
os.makedirs(subj_dir, exist_ok=True)
# ---- TorchScript (for Edge-AI) ----
script_path = os.path.join(subj_dir, f"scripted_best_model_{subject_id}.pt")
scripted_model = torch.jit.script(model_final)
scripted_model.save(script_path)
print("Saved scripted model:", script_path)
# ---- ONNX export (optional Edge runtime) ----
try:
dummy = torch.randn(1, n_channels, n_times).to(device)
onnx_path = os.path.join(subj_dir, f"best_model_subject_{subject_id}.onnx")
torch.onnx.export(
model_final,
dummy,
onnx_path,
input_names=["input"],
output_names=["output"],
dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}},
opset_version=11
)
print("Saved ONNX model:", onnx_path)
except Exception as e:
print("ONNX export failed:", e)
# ---------- Evaluate on held-out subject ----------
test_loader = DataLoader(
ADDatasetTorch(X_test, y_test),
batch_size=batch_size,
shuffle=False
)
preds, gts, probs_list = [], [], []
start_time = time.time()
with torch.no_grad():
for xb, yb in test_loader:
xb = xb.to(device)
out = model_final(xb)
prob = torch.softmax(out, dim=1).cpu().numpy() # probabilities
pred = out.argmax(1).cpu().numpy()
preds.append(pred)
gts.append(yb.numpy())
probs_list.append(prob)
inference_time = time.time() - start_time
preds = np.concatenate(preds)
gts = np.concatenate(gts)
probs = np.concatenate(probs_list)
acc = accuracy_score(gts, preds)
bal_acc = balanced_accuracy_score(gts, preds)
precision, recall, f1, _ = precision_recall_fscore_support(
gts, preds, average="macro", zero_division=0
)
cm = confusion_matrix(gts, preds, labels=labels_for_cm)
avg_inf_time = inference_time / len(gts)
# ---------- Compute per-subject ROC-AUC ----------
y_true_bin = label_binarize(gts, classes=labels_for_cm)
try:
subject_auc = roc_auc_score(y_true_bin, probs, average="macro", multi_class="ovr")
except ValueError:
subject_auc = float("nan")
print(f"Subject {subject_id} macro ROC-AUC: {subject_auc:.4f}")
# ---- Save test input & labels for Edge-AI testing ----
np.save(os.path.join(subj_dir, f"test_input_subject_{subject_id}.npy"),
X_test.astype(np.float32))
np.save(os.path.join(subj_dir, f"test_labels_subject_{subject_id}.npy"),
y_test.astype(np.int64))
# ---------- Collect metrics ----------
per_subject_metrics.append({
"subject_id": subject_id,
"n_test_epochs": int(len(gts)),
"test_acc": acc,
"balanced_acc": bal_acc,
"macro_f1": f1,
"precision": precision,
"recall": recall,
"roc_auc": subject_auc,
"confusion_matrix": cm.tolist(),
"inference_time_sec": inference_time,
"avg_time_per_epoch_sec": avg_inf_time
})
all_confusion_matrices.append(cm)
all_subject_accs.append(acc)
all_subject_bal_accs.append(bal_acc)
all_subject_f1s.append(f1)
all_subject_prec.append(precision)
all_subject_recall.append(recall)
all_subject_auc.append(subject_auc)
all_inference_times.append(avg_inf_time)
del model_final
torch.cuda.empty_cache()
# ---------- Aggregated results ----------
agg_cm = np.sum(np.stack(all_confusion_matrices), axis=0)
mean_acc = float(np.mean(all_subject_accs))
std_acc = float(np.std(all_subject_accs))
mean_prec = float(np.mean(all_subject_prec))
std_prec = float(np.std(all_subject_prec))
mean_recall = float(np.mean(all_subject_recall))
std_recall = float(np.std(all_subject_recall))
ci95 = float(1.96 * std_acc / np.sqrt(len(all_subject_accs)))
results = {
"per_subject": per_subject_metrics,
"aggregate": {
"mean_accuracy": mean_acc,
"std_accuracy": std_acc,
"mean_prec": mean_prec,
"std_prec": std_prec,
"mean_recall": mean_recall,
"std_recall": std_recall,
"ci95_accuracy": ci95,
"mean_balanced_accuracy": float(np.mean(all_subject_bal_accs)),
"mean_macro_f1": float(np.mean(all_subject_f1s)),
"mean_macro_roc_auc": float(np.nanmean(all_subject_auc)),
"aggregated_confusion_matrix": agg_cm.tolist(),
"mean_inference_time_sec": float(np.mean(all_inference_times))
}
}
os.makedirs(out_dir, exist_ok=True)
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
# ---- Save JSON ----
json_path = os.path.join(out_dir, f"loso_results_{timestamp}.json")
with open(json_path, "w") as f:
json.dump(results, f, indent=2)
print("Saved JSON results:", json_path)
# ---- Save CSV summary ----
csv_path = os.path.join(out_dir, f"loso_summary_{timestamp}.csv")
with open(csv_path, "w", newline="") as f:
writer = csv.writer(f)
writer.writerow([
"subject_id",
"n_test_epochs",
"test_acc",
"balanced_acc",
"macro_f1",
"precision",
"recall",
"roc_auc",
"avg_time_per_epoch_sec"
])
for r in per_subject_metrics:
writer.writerow([
r["subject_id"],
r["n_test_epochs"],
r["test_acc"],
r["balanced_acc"],
r["macro_f1"],
r["precision"],
r["recall"],
r["roc_auc"],
r["avg_time_per_epoch_sec"]
])
print("Saved CSV summary:", csv_path)
return per_subject_metrics
# ---------- To Run the models ----------
if __name__ == "__main__":
ROOT_DIR = "/home/.../EEG_AD_CUT/working/cleaned_filtered/" # folder with AD/, CJD/, CNTRL/ subfolders containing .npz
MODEL_NAME = "hybrid"
OUT_DIR = "hybrid_loso_results"
BATCH_SIZE = 64
LR = 1e-3
WEIGHT_DECAY = 1e-4
N_EPOCHS = 30
K_FOLDS_TRAIN = 5 # k-fold CV on training set to choose best fold model
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
SFREQ = 256
EPOCH_LEN_S = 5
N_CLASSES = 3 # AD, CJD, CNTRL
RANDOM_SEED = 2025
# -----------------------------------
np.random.seed(RANDOM_SEED)
torch.manual_seed(RANDOM_SEED)
os.makedirs(OUT_DIR, exist_ok=True)
# load data using your provided loader
#data_list, labels_list, subject_ids = YOUR DATA CLEANING FUNCTION TO CALL
# Sanity check
print("Loaded subjects:", subject_ids)
print([d.shape for d in data_list])
# CNN + DNN WITH TRANSFORMEER
model = CNNTransformerEEG(n_channels=19, n_times=1280, n_classes=3) # CALL PROPOSED HYBRID MODEL
# tHIS WILL CREATE AND SAVE THE LOSO RESULTS AT YOUR CREATED DIRECTORY
results = loso_train_and_eval(data_list, labels_list, subject_ids, model,
out_dir=OUT_DIR, batch_size=BATCH_SIZE, n_epochs=N_EPOCHS,
lr=LR, weight_decay=WEIGHT_DECAY, device=DEVICE, k_folds_train=K_FOLDS_TRAIN)
print("LOSO finished. Summary per-subject saved to disk.")

EEG_fair_nael.py at commit 4d0647a, no license · at the source

Overview

Authors: Muhammad Suffian¹, Cosimo Ieracitano², Nadia Mammone¹, Angelo Pascarella^3,4, Edoardo Ferlazzo^3,4, Francesco Carlo Morabito¹

ORCID iDs: Muhammad Suffian, Nadia Mammone, Angelo Pascarella, Francesco Carlo Morabito

Institutions: University of Reggio Calabria (Italy); University of Naples Federico II (Italy); Magna Graecia University (Italy); Azienda ospedaliera "Bianchi-Melacrino-Morelli" (Italy)

Journal: Sensors (Basel, Switzerland), volume 26, issue 10, article 3274

Dates: received 16 April 2026; accepted 19 May 2026; published online 21 May 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.3390/s26103274 · PMID 42198082 · PMCID PMC13211057 · OpenAlex W7161953903

Open access: gold, a free copy (OpenAlex)

Status: code verified

Categories: EEG (modality), human (organism), other condition (population), Alzheimer's / dementia (population)

Methods: Spectral & time-frequency, Preprocessing, Connectivity, Smoothing, state filtering, decompositions, Machine learning

Keywords: Alzheimer’s disease (AD), Creutzfeldt–Jakob disease (CJD), electroencephalography (EEG), brain-computer interface, convolutional neural networks, transformers, edge-AI, green AI

MeSH: Alzheimer Disease*, Artificial Intelligence*, Creutzfeldt-Jakob Syndrome*, Electroencephalography*, Algorithms, Convolutional Neural Networks, Deep Learning, Female, Humans, Neural Networks, Computer, Signal Processing, Computer-Assisted (* major topic)

Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex

Funding: Future Artificial Intelligence Research—FAIR-PE0000013 project CUP (C33C23001040005); European Union under “NextGenerationEU”; Italian Ministry of University and Research (MUR); ”Italia Domani National Recovery and Resilience Plan (PNRR)”; Italian ministry of Health (T3-AN-15, CUP C33C22000390006, CUP MASTER H53C22000640006); NEXTGENERATIONEU (NGEU) and funded by the Ministry of University and Research (MUR), National Recovery and Resilience Plan (NRRP) (PE0000006, DN. 1553 11.10.2022)

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

Abstract

Electroencephalography (EEG) has emerged as a promising non-invasive tool for the diagnosis of neurodegenerative disorders, and artificial intelligence (AI) has shown significant potential in this domain, as demonstrated by recent studies. However, strong inter-subject variability remains a major challenge, limiting the ability of AI-based models to learn disease-specific features that generalize across individuals, thereby hindering the development of clinically deployable subject-independent systems. In this work, we propose a cross-subject, AI-based EEG classification framework to distinguish between Alzheimer’s disease (AD), Creutzfeldt–Jakob disease (CJD), and healthy control subjects using clinical EEG data collected from a local hospital. A lightweight hybrid deep learning model is developed, combining a two-layer one-dimensional convolutional neural network with a two-layer Transformer encoder to capture both local temporal patterns and long-range dependencies in EEG signals. The proposed model achieves an average classification accuracy of 97%, representing a 3% improvement over a baseline model evaluated on a cohort of 36 subjects. To assess deployment feasibility in real-time clinical settings, the trained model is implemented and evaluated on an edge-AI platform (NVIDIA Jetson AGX Orin), demonstrating energy efficiency for the inference with a compact model footprint. These results indicate that the proposed approach provides an accurate, efficient, and practically deployable solution for subject-independent EEG-based classification of neurological disorders.

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

Repository

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

ai-lab-unirc/fair-nael-database

License: none: the authors keep all their rights

State: the link answers, verified on 27 September 2026

Evidence: files inventoried

Commit: 4d0647a7ab6317d58c318a932924bfdeeada9fec, 31 March 2026

Languages: Python (3)

Size: 6 files, 3 scripts

Software Heritage: not archived

Found in: the text, “1. Introduction”

Holds: README

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

Tools: NumPy (3 files), NiBabel (1 file), pydicom (1 file), PyTorch (1 file), scikit-learn (1 file)

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

27 September 2026: the link answers

4 files

EEG/sourcecodes/EEG_fair_nael.py, Python, 512 lines, 3 matches
TAC/sourcecodes/raw_to_dicom.py, Python, 124 lines
TAC/sourcecodes/raw_to_nifti.py, Python, 66 lines
README.md, Text, 88 lines

At the source: github.com/AI-Lab-UniRC/FAIR-NAEL-Database/tree/main/EEG

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.

Data Availability Statement

The analyzed dataset is available at the following link: https://github.com/AI-Lab-UniRC/FAIR-NAEL-Database (accessed on 7 April 2026).

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 8 keywords, 11 MeSH terms, 6 funders, 19 references.

Cite

This paper

Suffian, M., Ieracitano, C., Mammone, N., Pascarella, A., Ferlazzo, E., & Morabito, F. C. (2026). An EEG-Based Edge-AI Framework for Alzheimer's and Creutzfeldt-Jakob Disease Classification. Sensors (Basel, Switzerland), 26(10), 3274. https://doi.org/10.3390/s26103274

BibTeX

@article{suffian2026eeg, author = {Suffian, Muhammad and Ieracitano, Cosimo and Mammone, Nadia and Pascarella, Angelo and Ferlazzo, Edoardo and Morabito, Francesco Carlo}, title = {{An EEG-Based Edge-AI Framework for Alzheimer's and Creutzfeldt-Jakob Disease Classification}}, journal = {Sensors (Basel, Switzerland)}, year = {2026}, month = may, volume = {26}, number = {10}, pages = {3274}, publisher = {Multidisciplinary Digital Publishing Institute (MDPI)}, issn = {1424-8220}, doi = {10.3390/s26103274}, url = {https://doi.org/10.3390/s26103274}, pmid = {42198082}, pmcid = {PMC13211057} }

RIS

TY - JOUR AU - Suffian, Muhammad AU - Ieracitano, Cosimo AU - Mammone, Nadia AU - Pascarella, Angelo AU - Ferlazzo, Edoardo AU - Morabito, Francesco Carlo TI - An EEG-Based Edge-AI Framework for Alzheimer's and Creutzfeldt-Jakob Disease Classification T2 - Sensors (Basel, Switzerland) J2 - Sensors (Basel) PY - 2026 DA - 2026/05/21 VL - 26 IS - 10 SP - 3274 SN - 1424-8220 PB - Multidisciplinary Digital Publishing Institute (MDPI) DO - 10.3390/s26103274 UR - https://doi.org/10.3390/s26103274 LA - en ER -

CSL-JSON

{ "id": "10.3390/s26103274", "type": "article-journal", "title": "An EEG-Based Edge-AI Framework for Alzheimer's and Creutzfeldt-Jakob Disease Classification", "container-title": "Sensors (Basel, Switzerland)", "author": [ { "family": "Suffian", "given": "Muhammad" }, { "family": "Ieracitano", "given": "Cosimo" }, { "family": "Mammone", "given": "Nadia" }, { "family": "Pascarella", "given": "Angelo" }, { "family": "Ferlazzo", "given": "Edoardo" }, { "family": "Morabito", "given": "Francesco Carlo" } ], "container-title-short": "Sensors (Basel)", "volume": "26", "issue": "10", "page": "3274", "DOI": "10.3390/s26103274", "PMID": "42198082", "PMCID": "PMC13211057", "ISSN": "1424-8220", "publisher": "Multidisciplinary Digital Publishing Institute (MDPI)", "URL": "https://doi.org/10.3390/s26103274", "language": "en", "issued": { "date-parts": [ [ 2026, 5, 21 ] ] } }

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/s41746-026-02778-0 [code]: Trust-gated synthetic EEG augmentation reduces performance drops when generalizing to new patients.
Journal: NPJ digital medicine
In common: PyTorch, scikit-learn, NumPy, EEG, 3 references
[2] doi:10.3389/fnins.2026.1874302 [code]: Architecture-data matching for EEG-EMG decoding: compact deep models match classical spectral decoders on the WAY-EEG-GAL grasp-and-lift dataset.
Journal: Frontiers in neuroscience
In common: PyTorch, scikit-learn, NumPy, EEG, 3 references
[3] doi:10.1186/s13244-026-02296-3 [code]: A pre-trained foundation model framework for multiplanar MRI classification of extramural vascular invasion and mesorectal fascia invasion in rectal cancer.
Journal: Insights into imaging
In common: pydicom, NiBabel, PyTorch, 2 other tools, other condition
[4] 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: pydicom, NiBabel, PyTorch, 2 other tools
[5] doi:10.3389/frai.2026.1771088 [code]: Few-shot deployment of pretrained MRI transformers in brain imaging tasks.
Journal: Frontiers in artificial intelligence
In common: pydicom, NiBabel, PyTorch, 2 other tools
[6] doi:10.3390/biomimetics11060377: PG-MCTFormer: A Prior-Guided Multi-Scale Convolutional Transformer for Interpretable Motor Imagery EEG Classification.
Journal: Biomimetics (Basel, Switzerland)
In common: EEG, 4 references
[7] doi:10.1002/mp.70599 [code]: Accurate estimation of intravoxel incoherent motion parameters based on implicit neural representation.
Journal: Medical physics
In common: pydicom, NiBabel, PyTorch, 1 other tool, other condition
[8] doi:10.1080/07853890.2026.2685416 [code]: Pulmonary and cerebral damage in COVID-19 survivors: is there any association?
Journal: Annals of medicine
In common: pydicom, NiBabel, PyTorch, 1 other tool, other condition
[9] doi:10.1002/hbm.70548 [code]: Improved Multiscale Structural Mapping with Supervertex Vision Transformer for the Detection of Alzheimer's Disease Neurodegeneration.
Journal: Human brain mapping
In common: NiBabel, PyTorch, scikit-learn, 1 other tool, Alzheimer's / dementia, 1 reference
[10] doi:10.1038/s41586-026-10631-3 [code]: A prognostic human brain network for diffuse midline glioma.
Journal: Nature
In common: pydicom, NiBabel, scikit-learn, 1 other tool, other condition

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.