OSCR

An edge-AI enabled wearable platform for real-time epileptic seizure detection with geolocated alerting.

Code ↔ Paper

3 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 3 matches
  1. [1] § Methods ↔ Real_Time_Seizure_Detection_and_Alert_System.ipynb, lines 208–248 · score 0.80 · Linear SVM, maximum depth, ReLU, Neural Network, Adam, dropout
  2. [2] § Methods ↔ Real_Time_Seizure_Detection_and_Alert_System.ipynb, lines 394–514 · score 0.56 · heart rate, seizure detection, predictions, activities, preprocessing, acceleration
  3. [3] § System architecture ↔ Real_Time_Seizure_Detection_and_Alert_System.ipynb, lines 394–514 · score 0.56 · seizure detection model, heart rate, Preprocessing, accelerometer, configuration, sensor

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 · 561 lines · 20 KB · no license · 3 matches

  1. # %% [markdown]
  2. # <a href="https://colab.research.google.com/github/abdibbey/Real_Time_Seizure_Detection_and_Alert_System/blob/main/Real_Time_Seizure_Detection_and_Alert_System.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
  4. # %% [markdown]
  5. # # **Real-Time Seizure Detection and Alert System**
  6. # ### **Overview**
  7. #
  8. # This project implements a real-time seizure detection system using machine learning and sensor data, optimized for deployment on a Raspberry Pi 3 Model B. It prioritizes high recall to minimize missed seizures, efficient processing, and robust data handling.
  9. #
  10. # ### **Key Objectives**
  11. #
  12. # * **Maximize Recall:** Ensure detection of all potential seizures.
  13. # * **Real-Time Performance:** Achieve low-latency inference on Raspberry Pi 3 Model B.
  14. # * **Robust Preprocessing:** Manage noisy sensor data effectively.
  15. #
  16. #
  17. # ### **Workflow**
  18. #
  19. # 1. **Data Preprocessing**: Load, clean, and normalize sensor data.
  20. # 2. **Feature Engineering**: Extract relevant features.
  21. # 3. **Model Training**: Train Random Forest, SVM, and Neural Network models.
  22. # 4. **Model Evaluation**: Assess training/testing performance, resource usage, and fitting status (overfit, underfit, ideally fit).
  23. # 5. **Model Selection**: Select the optimal model.
  24. # 6. **Raspberry Pi Deployment**: Export model and configurations.
  26. # %% [markdown]
  27. # ## **Step 1: Library Import and Initialization**
  28. #
  29. # Imports and verifies required Python libraries.
  30. #
  31. # ### **Libraries**
  32. #
  33. #
  34. # * **Data Processing:** Pandas, NumPy, JSON.
  35. # * **Visualization:** Matplotlib, Seaborn
  36. # * **Machine Learning:** Scikit-learn
  37. # * **Deep Learning:** TensorFlow/Keras
  38. # * **Class Balancing:** Imbalanced-learn (RandomUnderSampler).
  39. # * **Model Persistence:** Joblib
  40. # * File System: os.
  42. # %%
  43. print("=" * 50)
  44. print("📦 Step 1: Importing Libraries")
  45. print("=" * 50)
  47. try:
  48. import pandas as pd
  49. import numpy as np
  50. import json
  51. import matplotlib.pyplot as plt
  52. import seaborn as sns
  53. import joblib
  54. import os
  55. from sklearn.preprocessing import MinMaxScaler
  56. from sklearn.model_selection import train_test_split
  57. from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score
  58. from sklearn.ensemble import RandomForestClassifier
  59. from sklearn.svm import LinearSVC
  60. import tensorflow as tf
  61. from tensorflow.keras.models import Sequential
  62. from tensorflow.keras.layers import Dense, Dropout
  63. from imblearn.under_sampling import RandomUnderSampler
  64. # Check pandas and others
  65. assert pd is not None, "pandas not imported"
  66. assert tf is not None, "TensorFlow not imported"
  68. print("✅ Libraries imported")
  69. print(f"- Pandas: {pd.__version__}")
  70. print(f"- Scikit-learn: {joblib.__version__}")
  71. print(f"- TensorFlow: {tf.__version__}")
  73. except ImportError as e:
  74. print(f"❌ Import error: {e}")
  75. raise
  76. except AssertionError as e:
  77. print(f"❌ Critical import missing: {e}")
  78. raise
  80. # %% [markdown]
  81. # ## **Step 2: Data Preparation**
  82. #
  83. # Prepares the dataset by cleaning, normalizing, and balancing it, with visualizations for class distributions and train/test splits.
  84. #
  85. # ### **Sub-Steps**
  86. #
  87. # 1. Load Dataset: Read CSV data.
  88. #
  89. # 2. Identify Columns: Detect sensor and target columns.
  90. #
  91. # 3. Convert Labels: Map labels to binary (0: normal, 1: seizure).
  92. #
  93. # 4. Clean Data: Remove missing values.
  94. #
  95. # 5. Normalize Features: Apply MinMax scaling.
  96. #
  97. # 6. Balance Classes: Use UNDERSAMPLE for oversampling minority class.
  98. #
  99. # 7. Split Data: Create train/test sets.
  101. # %%
  102. print("=" * 50)
  103. print("🔍 Step 2: Data Preparation")
  104. print("=" * 50)
  106. def handle_error(step, error):
  107. print(f"❌ Error in {step}: {error}")
  108. exit()
  110. # Load Data
  111. try:
  112. data = pd.read_csv("/content/drive/MyDrive/Dataset/SHAR-100-20.csv")
  113. print(f"✅ Loaded dataset: {data.shape[0]} samples, {data.shape[1]} features")
  114. except Exception as e:
  115. handle_error("loading dataset", e)
  117. # Identify Columns
  118. try:
  119. if 'label' in data.columns:
  120. data = data.rename(columns={'label': 'seizure_status'})
  121. sensor_cols = [col for col in data.columns if any(x in col.lower() for x in ['accel', 'gyro', 'hr', 'heart'])]
  122. target_col = next((col for col in data.columns if 'seizure' in col.lower() or 'status' in col.lower()), None)
  123. if not sensor_cols or not target_col:
  124. raise ValueError("Sensor or target columns not found")
  125. print(f"✔ Sensor features: {len(sensor_cols)}")
  126. print(f"✔ Target: {target_col}")
  127. except Exception as e:
  128. handle_error("column identification", e)
  130. # Convert Labels
  131. try:
  132. data[target_col] = data[target_col].replace({'normal': 0, 'seizure': 1, 'no': 0, 'yes': 1, 0: 0, 1: 1})
  133. class_distribution = data[target_col].value_counts(normalize=True)
  134. print("✔ Class distribution:")
  135. for cls, proportion in class_distribution.items():
  136. print(f" - {cls}: {proportion:.6f}")
  137. except Exception as e:
  138. handle_error("label conversion", e)
  140. # Clean Data
  141. try:
  142. initial_count = len(data)
  143. data = data[sensor_cols + [target_col]].dropna()
  144. print(f"✔ Removed {initial_count - len(data)} rows with missing values")
  145. except Exception as e:
  146. handle_error("data cleaning", e)
  148. # Normalize Features
  149. try:
  150. X = data[sensor_cols].values
  151. y = data[target_col].values
  152. scaler = MinMaxScaler().fit(X)
  153. X = scaler.transform(X)
  154. print("✔ Features normalized")
  155. except Exception as e:
  156. handle_error("feature normalization", e)
  158. # Balance Classes with Visualization
  159. try:
  160. plt.figure(figsize=(10, 4))
  161. plt.subplot(1, 2, 1)
  162. sns.countplot(x=y)
  163. plt.title('Original Class Distribution')
  164. plt.xlabel('Class (0: Normal, 1: Seizure)')
  165. plt.ylabel('Count')
  167. undersampler = RandomUnderSampler(random_state=42)
  168. X, y = undersampler.fit_resample(X, y)
  170. plt.subplot(1, 2, 2)
  171. sns.countplot(x=y)
  172. plt.title('Balanced Class Distribution (Undersampling)')
  173. plt.xlabel('Class (0: Normal, 1: Seizure)')
  174. plt.ylabel('Count')
  175. plt.tight_layout()
  176. plt.show()
  177. print(f"✔ Dataset balanced: {len(X)} samples")
  178. except Exception as e:
  179. handle_error("class balancing", e)
  181. # Split Data with Visualization
  182. try:
  183. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
  184. print(f"✔ Training set: {X_train.shape[0]} samples")
  185. print(f"✔ Test set: {X_test.shape[0]} samples")
  187. plt.figure(figsize=(12, 4))
  188. plt.subplot(1, 3, 1)
  189. sns.countplot(x=y)
  190. plt.title('Full Dataset')
  191. plt.xlabel('Class')
  193. plt.subplot(1, 3, 2)
  194. sns.countplot(x=y_train)
  195. plt.title('Training Set')
  196. plt.xlabel('Class')
  198. plt.subplot(1, 3, 3)
  199. sns.countplot(x=y_test)
  200. plt.title('Test Set')
  201. plt.xlabel('Class')
  202. plt.tight_layout()
  203. plt.show()
  204. except Exception as e:
  205. handle_error("data splitting", e)
  208. # %% [markdown]
  209. # ## **Step 3: Model Training**
  210. #
  211. # Trains three models: Random Forest, Linear SVM, and Neural Network.
  212. #
  213. #
  214. #
  215. # * **Random Forest:** Configured with 35 trees, a maximum depth of 5, and a subsample ratio of 0.7.
  216. #
  217. # * **Linear SVM:** Uses a regularization parameter C of 0.7 and a maximum of 2000 iterations.
  218. # * **Neural Network:** Features 10 ReLU neurons in the input layer, a 0.2 dropout rate, a single sigmoid output neuron, and is optimized with Adam.
  220. # %%
  221. print("=" * 50)
  222. print("⚙️ Step 3: Model Training")
  223. print("=" * 50)
  225. models = {}
  227. # Random Forest
  228. rf_model = RandomForestClassifier(n_estimators=50, max_depth=7, max_samples=0.8, random_state=42)
  229. rf_model.fit(X_train, y_train)
  230. models['RF'] = rf_model
  231. print("✅ Random Forest trained")
  233. # Linear SVM
  234. svm_model = LinearSVC(C=0.7, dual=False, random_state=42, max_iter=2000)
  235. svm_model.fit(X_train, y_train)
  236. models['SVM'] = svm_model
  237. print("✅ Linear SVM trained")
  239. # Neural Network
  240. nn_model = Sequential([
  241. Dense(16, activation='relu', input_shape=(X_train.shape[1],)),
  242. Dropout(0.2),
  243. Dense(1, activation='sigmoid')
  244. ])
  245. nn_model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='binary_crossentropy', metrics=['accuracy'])
  246. nn_model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.2, verbose=0)
  247. models['NN'] = nn_model
  248. print("✅ Neural Network trained")
  250. # %% [markdown]
  251. # ## **Step 4: Model Evaluation**
  252. #
  253. # Evaluates models on training and testing performance metrics, resource usage, and fitting status (overfit, underfit, ideally fit), with bar plots comparing training vs. testing metrics and testing performance.
  254. #
  255. # **Metrics**
  256. # * Accuracy, Recall, F1 Score (for both training and testing).
  257. # * Resource usage: Size (KB), Speed (ms), Parameters.
  258. # * Fitting Status: Determined by comparing training and testing performance.
  260. # %%
  261. print("=" * 50)
  262. print("🔍 Step 4: Model Evaluation")
  263. print("=" * 50)
  265. def evaluate_models(models, X_train, y_train, X_test, y_test):
  266. results = []
  267. for name, model in models.items():
  268. # Training predictions
  269. y_train_pred = (model.predict(X_train) > 0.5).astype(int) if name == 'NN' else model.predict(X_train)
  270. # Testing predictions
  271. y_test_pred = (model.predict(X_test) > 0.5).astype(int) if name == 'NN' else model.predict(X_test)
  273. # Calculate metrics
  274. train_accuracy = accuracy_score(y_train, y_train_pred)
  275. test_accuracy = accuracy_score(y_test, y_test_pred)
  276. train_recall = recall_score(y_train, y_train_pred)
  277. test_recall = recall_score(y_test, y_test_pred)
  278. train_f1 = f1_score(y_train, y_train_pred)
  279. test_f1 = f1_score(y_test, y_test_pred)
  281. # Determine fitting status
  282. acc_gap = train_accuracy - test_accuracy
  283. recall_gap = train_recall - test_recall
  284. if train_accuracy > 0.9 and (acc_gap > 0.1 or recall_gap > 0.1):
  285. fit_status = "Overfit"
  286. elif train_accuracy < 0.7 and test_accuracy < 0.7:
  287. fit_status = "Underfit"
  288. else:
  289. fit_status = "Ideally Fit"
  291. results.append({
  292. 'Model': name,
  293. 'Train Accuracy': train_accuracy,
  294. 'Test Accuracy': test_accuracy,
  295. 'Train Recall': train_recall,
  296. 'Test Recall': test_recall,
  297. 'Train F1': train_f1,
  298. 'Test F1': test_f1,
  299. 'Fit Status': fit_status,
  300. 'Size (KB)': estimate_size(model, name),
  301. 'Speed (ms)': estimate_speed(model, name),
  302. 'Params': count_parameters(model, name)
  303. })
  304. return pd.DataFrame(results)
  306. def estimate_size(model, model_type):
  307. if model_type == 'RF':
  308. return round((50 * (2**7) * 4) / 1024, 1)
  309. elif model_type == 'SVM':
  310. return round((model.coef_.size * 4) / 1024, 1)
  311. return round((model.count_params() * 4) / 1024, 1)
  313. def estimate_speed(model, model_type):
  314. return {'RF': 10, 'SVM': 5, 'NN': 20}[model_type]
  316. def count_parameters(model, model_type):
  317. if model_type == 'RF':
  318. return model.n_estimators * (2**model.max_depth)
  319. elif model_type == 'SVM':
  320. return model.coef_.size
  321. return model.count_params()
  323. results_df = evaluate_models(models, X_train, y_train, X_test, y_test)
  325. # Visualize Training vs. Testing Performance
  326. plt.figure(figsize=(12, 6))
  327. results_melted = results_df.melt(id_vars='Model', value_vars=['Train Recall', 'Test Recall', 'Train F1', 'Test F1', 'Train Accuracy', 'Test Accuracy'],
  328. var_name='Metric', value_name='Score')
  329. sns.barplot(x='Model', y='Score', hue='Metric', data=results_melted)
  330. plt.title('Training vs. Testing Performance Comparison')
  331. plt.ylabel('Score')
  332. plt.ylim(0, 1)
  333. plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
  334. plt.tight_layout()
  335. plt.show()
  337. # Visualize Testing Performance Only
  338. plt.figure(figsize=(10, 6))
  339. results_melted_test = results_df.melt(id_vars='Model', value_vars=['Test Recall', 'Test F1', 'Test Accuracy'],
  340. var_name='Metric', value_name='Score')
  341. sns.barplot(x='Model', y='Score', hue='Metric', data=results_melted_test)
  342. plt.title('Testing Performance Comparison')
  343. plt.ylabel('Score')
  344. plt.ylim(0, 1)
  345. plt.show()
  347. # Visualize Ideally Fit Models
  348. plt.figure(figsize=(10, 6))
  349. ideal_df = results_df[results_df['Fit Status'] == 'Ideally Fit']
  350. if not ideal_df.empty:
  351. ideal_melted = ideal_df.melt(id_vars='Model', value_vars=['Test Recall', 'Test F1', 'Test Accuracy'],
  352. var_name='Metric', value_name='Score')
  353. sns.barplot(x='Model', y='Score', hue='Metric', data=ideal_melted)
  354. plt.title('Ideally Fit Models: Test Performance')
  355. plt.ylabel('Score')
  356. plt.ylim(0, 1)
  357. else:
  358. plt.text(0.5, 0.5, 'No Ideally Fit Models Found',
  359. horizontalalignment='center', verticalalignment='center', fontsize=12)
  360. plt.title('Ideally Fit Models: Test Performance')
  361. plt.gca().set_xticks([])
  362. plt.gca().set_yticks([])
  363. plt.tight_layout()
  364. plt.show()
  366. print("\n📊 Model Comparison:")
  367. print(results_df[['Model', 'Train Accuracy', 'Test Accuracy', 'Train Recall', 'Test Recall', 'Train F1', 'Test F1', 'Fit Status', 'Size (KB)', 'Speed (ms)']])
  369. # %% [markdown]
  370. # ## **Step 5: Model Selection**
  371. #
  372. # Selects the best model based on test recall, F1 score, fitting status, and hardware constraints.
  373. #
  374. # **Criteria**
  375. #
  376. # * Primary: High recall
  377. # * Secondary: Test F1 score, test accuracy, ideally fit status.
  378. # * Hardware: Size, speed, RAM usage (Raspberry Pi 3 Model B has ~1GB RAM, 1.2 GHz quad-core CPU).
  380. # %%
  381. print("=" * 50)
  382. print("🔍 Step 5: Model Selection")
  383. print("=" * 50)
  385. # Select model with highest test recall, preferring ideally fit models
  386. best_model = results_df.loc[results_df['Test Recall'].idxmax()]
  387. print(f"✅ Best model: {best_model['Model']}")
  388. print(f"- Test Recall: {best_model['Test Recall']:.3f}")
  389. print(f"- Test F1 Score: {best_model['Test F1']:.3f}")
  390. print(f"- Fit Status: {best_model['Fit Status']}")
  391. print(f"- Size: {best_model['Size (KB)']} KB")
  392. print(f"- Speed: {best_model['Speed (ms)']} ms")
  394. # %% [markdown]
  395. # ## **Step 6: Raspberry Pi Deployment**
  396. #
  397. # Exports the selected model (named by model type, e.g., random_forest.pkl) and configurations to a single Google Drive folder (/content/drive/MyDrive/SeizureDetection_Models/). The Raspberry Pi runs a Python script to load the model, interface with sensors (e.g., via I2C/SPI), and send alerts.
  398. #
  399. # ### **Deployment Steps**
  400. #
  401. # 1. Create a Google Drive folder for output files.
  402. #
  403. #
  404. #
  405. # 2. Save the model (e.g., random_forest.pkl, svm.pkl, or neural_network.h5), scaler, and configurations in the folder.
  406. #
  407. #
  408. #
  409. # 3. Generate a Python script for Raspberry Pi, referencing the model file.
  410. #
  411. # 4. Provide instructions for setting up the Raspberry Pi environment.
  413. # %%
  414. print("=" * 50)
  415. print("🚀 Step 6: Raspberry Pi Deployment")
  416. print("=" * 50)
  418. # Define output folder locally
  419. output_folder = '/content/SeizureDetection_Models/'
  420. try:
  421. os.makedirs(output_folder, exist_ok=True)
  422. print(f"✅ Output folder created/verified: {output_folder}")
  423. except Exception as e:
  424. print(f"❌ Error creating output folder: {e}")
  425. exit()
  427. # Save Model and Scaler
  428. try:
  429. best_model_name = best_model['Model']
  430. model = models[best_model_name]
  431. # Map model names to file names
  432. model_file_map = {
  433. 'RF': 'random_forest.pkl',
  434. 'SVM': 'svm.pkl',
  435. 'NN': 'neural_network.h5'
  436. }
  437. model_file = model_file_map[best_model_name]
  438. model_file_path = os.path.join(output_folder, model_file)
  439. scaler_file_path = os.path.join(output_folder, 'scaler.pkl')
  441. if best_model_name == 'NN':
  442. model.save(model_file_path)
  443. else:
  444. joblib.dump(model, model_file_path)
  445. joblib.dump(scaler, scaler_file_path)
  446. print(f"✅ Model saved as {model_file_path}")
  447. print(f"✅ Scaler saved as {scaler_file_path}")
  448. except Exception as e:
  449. print(f"❌ Error saving model or scaler: {e}")
  450. exit()
  452. # Save Preprocessing Configuration
  453. try:
  454. preprocessing_config = {
  455. 'sensor_columns': sensor_cols,
  456. 'scaler_params': {
  457. 'min': scaler.data_min_.tolist(),
  458. 'max': scaler.data_max_.tolist()
  459. }
  460. }
  461. preprocessing_file_path = os.path.join(output_folder, 'preprocessing.json')
  462. with open(preprocessing_file_path, 'w') as f:
  463. json.dump(preprocessing_config, f)
  464. print(f"✅ Preprocessing configuration saved: {preprocessing_file_path}")
  465. except Exception as e:
  466. print(f"❌ Error saving preprocessing configuration: {e}")
  467. exit()
  469. # Generate Raspberry Pi Script
  470. pi_script = f"""
  471. import numpy as np
  472. {'import tensorflow as tf' if best_model_name == 'NN' else 'import joblib'}
  473. import json
  475. # Load model and scaler
  476. model = {'tf.keras.models.load_model("' + model_file + '")' if best_model_name == 'NN' else 'joblib.load("' + model_file + '")'}
  477. scaler = joblib.load("scaler.pkl")
  479. # Load preprocessing configuration
  480. with open('preprocessing.json', 'r') as f:
  481. config = json.load(f)
  482. sensor_cols = config['sensor_columns']
  484. # Simulated sensor data reading (replace with actual sensor code, e.g., I2C/SPI)
  485. def read_sensor_data():
  486. # Example: Read from accelerometer, gyroscope, heart rate sensor
  487. # Use libraries like smbus2 or spidev for I2C/SPI communication
  488. return np.random.rand({len(sensor_cols)}) # Replace with real sensor data
  490. # Inference loop
  491. while True:
  492. data = read_sensor_data()
  493. data_scaled = scaler.transform([data])
  494. prediction = model.predict(data_scaled)
  495. prediction = (prediction > 0.5).astype(int) if '{best_model_name}' == 'NN' else prediction
  496. if prediction[0] == 1:
  497. print("⚠️ Seizure detected! Sending alert...")
  498. # Add code for SMS/email alert (e.g., using smtplib or Twilio API)
  499. else:
  500. print("✔ Normal activity")
  501. # Adjust sleep time based on sensor sampling rate
  502. import time
  503. time.sleep(0.1)
  504. """
  506. # Save script
  507. try:
  508. script_file_path = os.path.join(output_folder, 'seizure_detection_pi.py')
  509. with open(script_file_path, 'w') as f:
  510. f.write(pi_script)
  511. print(f"✅ Raspberry Pi script generated: {script_file_path}")
  512. except Exception as e:
  513. print(f"❌ Error saving script: {e}")
  514. exit()
  516. # %% [markdown]
  517. # ## **Deployment Instructions**
  518. #
  519. # 1. **Locate Files**: Find the model file (random_forest.pkl, svm.pkl, or neural_network.h5), scaler.pkl, preprocessing.json, and seizure_detection_pi.py in the Google Drive folder /content/drive/MyDrive/SeizureDetection_Models/. Copy these files to your Raspberry Pi 3 Model B (e.g., via SCP, USB, or downloading from Google Drive).
  520. #
  521. #
  522. # 2. **Include Libraries**:
  523. #
  524. # * Random Forest: Requires joblib (included in scikit-learn)
  525. #
  526. # * SVM: Requires joblib (included in scikit-learn).
  527. # * Neural Network: Requires tensorflow.
  528. # * Install on Raspberry Pi:
  529. # $ pip3 install numpy scikit-learn tensorflow joblib
  530. # 3. **Implement Preprocessing**: Use preprocessing.json to configure sensor data scaling in the Raspberry Pi script.
  531. #
  532. # 4. **Test**: Validate the script with sample sensor data before production deployment.
  533. #
  534. # ### **Notes**
  535. #
  536. # * Verify file paths in the Raspberry Pi script (seizure_detection_pi.py). Ensure random_forest.pkl, svm.pkl, or neural_network.h5, scaler.pkl, and preprocessing.json are in the same directory as the script on the Raspberry Pi.
  537. #
  538. #
  539. #
  540. # * Monitor memory usage during inference (Raspberry Pi 3 Model B has ~1GB RAM).
  541. #
  542. #
  543. #
  544. # * Periodically validate model performance with real-world data.
  545. #
  546. # * In Colab, files in /content/SeizureDetection_Models/ are temporary and will be deleted after the session ends. Download them promptly.
  547. #
  548. # ### **Visualizations Displayed**
  549. #
  550. #
  551. #
  552. #
  553. #
  554. # * **Class Distribution:** Original vs. undersampled classes.
  555. #
  556. #
  557. #
  558. # * **Train/Test Split:** Full dataset, training, and test sets
  559. #
  560. #
  561. # * **Model Performance:** Training vs. testing recall, F1, accuracy comparison; testing performance comparison; ideally fit models’ test performance (or a message if none are ideally fit).

Real_Time_Seizure_Detection_and_Alert_System.ipynb at commit 9ac52ea, no license · at the source

Overview

Authors: Tsion Fekadu1, Kidist Dagnachew1, Abdi Bekele1
ORCID iDs: Tsion Fekadu
  1. Department of Computer Engineering, Dilla University,Dilla, Ethiopia
Institutions: Dilla University (Ethiopia)
Journal: BMC biomedical engineering, volume 8, issue 1, article 13
Dates: received 10 August 2025; accepted 18 June 2026; published online 3 July 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1186/s42490-026-00116-9 · PMID 42400041 · PMCID PMC13332600 · OpenAlex W7167278261
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: other (modality), epilepsy (population)
Methods: Connectivity, Machine learning, Statistics, Physiology & signal measures
Keywords: Edge AI, Seizure detection, Wearable technology, Real-time monitoring, Geolocated alerting
Topic: EEG and Brain-Computer Interfaces (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Dilla University
Citations: not cited yet (Europe PMC); 34 references in the paper

Abstract

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

Repository

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

abdibbey/Real_Time_Seizure_Detection_and_Alert_System

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 9ac52ea359e553a7c68ab9581838797c901847c3, 30 June 2025
Languages: Jupyter (1)
Size: 2 files, 1 script
Software Heritage: not archived
Found in: “Data availability”
Holds: README, 1 notebook
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: imbalanced-learn (1 file), Keras (1 file), Matplotlib (1 file), NumPy (1 file), pandas (1 file), scikit-learn (1 file), seaborn (1 file), TensorFlow (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
2 files
At the source: github.com/abdibbey/Real_Time_Seizure_Detection_and_Alert_System

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;
  • 1 script, each with its path and the digest of its content;
  • 3 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

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

Data

No dataset and no data link were found in the paper.

Code and data availability statement

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

Read it in the paper: doi.org/10.1186/s42490-026-00116-9.

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 2, 28 September 2026

  • Funding: added Dilla University

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 5 keywords, 27 references.

Cite

This paper

Fekadu, T., Dagnachew, K., & Bekele, A. (2026). An edge-AI enabled wearable platform for real-time epileptic seizure detection with geolocated alerting. BMC biomedical engineering, 8(1), 13. https://doi.org/10.1186/s42490-026-00116-9

BibTeX

@article{fekadu2026edge,
author = {Fekadu, Tsion and Dagnachew, Kidist and Bekele, Abdi},
title = {{An edge-AI enabled wearable platform for real-time epileptic seizure detection with geolocated alerting}},
journal = {BMC biomedical engineering},
year = {2026},
month = jul,
volume = {8},
number = {1},
pages = {13},
publisher = {BMC},
issn = {2524-4426},
doi = {10.1186/s42490-026-00116-9},
url = {https://doi.org/10.1186/s42490-026-00116-9},
pmid = {42400041},
pmcid = {PMC13332600}
}

RIS

TY - JOUR
AU - Fekadu, Tsion
AU - Dagnachew, Kidist
AU - Bekele, Abdi
TI - An edge-AI enabled wearable platform for real-time epileptic seizure detection with geolocated alerting
T2 - BMC biomedical engineering
J2 - BMC Biomed Eng
PY - 2026
DA - 2026/07/03
VL - 8
IS - 1
SP - 13
SN - 2524-4426
PB - BMC
DO - 10.1186/s42490-026-00116-9
UR - https://doi.org/10.1186/s42490-026-00116-9
LA - en
ER -

CSL-JSON

{
"id": "10.1186/s42490-026-00116-9",
"type": "article-journal",
"title": "An edge-AI enabled wearable platform for real-time epileptic seizure detection with geolocated alerting",
"container-title": "BMC biomedical engineering",
"author": [
{
"family": "Fekadu",
"given": "Tsion"
},
{
"family": "Dagnachew",
"given": "Kidist"
},
{
"family": "Bekele",
"given": "Abdi"
}
],
"container-title-short": "BMC Biomed Eng",
"volume": "8",
"issue": "1",
"page": "13",
"DOI": "10.1186/s42490-026-00116-9",
"PMID": "42400041",
"PMCID": "PMC13332600",
"ISSN": "2524-4426",
"publisher": "BMC",
"URL": "https://doi.org/10.1186/s42490-026-00116-9",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
3
]
]
}
}

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, Keras, TensorFlow, 5 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, Keras, TensorFlow, 5 other tools
[3] doi:10.1038/s41598-026-55163-y [code]
Autism spectrum disorder identification using machine learning models on MRI data.
Journal: Scientific reports
In common: imbalanced-learn, Keras, TensorFlow, 5 other tools
[4] 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, 5 other tools
[5] doi:10.1038/s41598-026-52330-z [code]
SHAP analysis of an improved EEG-based mental workload classification framework: utilizing data augmentation and explainable AI.
Journal: Scientific reports
In common: imbalanced-learn, Keras, TensorFlow, 4 other tools
[6] doi:10.1002/ana.78203 [code]
AI-Driven Mapping of Seizure Spread Patterns.
Journal: Annals of neurology
In common: Keras, TensorFlow, seaborn, 4 other tools, epilepsy
[7] doi:10.1093/sleepadvances/zpag051 [code]
What matters beyond model choice for wearable sleep staging? How personalization, evaluation choices, and easy-to-classify wake impact performance.
Journal: Sleep advances : a journal of the Sleep Research Society
In common: Keras, TensorFlow, seaborn, 4 other tools, other
[8] doi:10.1371/journal.pone.0347867 [code]
LiteFeatNet: A parameter-efficient and performance-centric deep learning model for multi-ocular disease identification using intermediate feature reduction from fundus images.
Journal: PloS one
In common: Keras, TensorFlow, seaborn, 4 other tools, other
[9] doi:10.64898/2026.05.06.26352540 [code]
Generating synthetic tau-PET scans in Alzheimer’s disease from MRI, blood biomarkers and demographics with deep learning
Journal: medRxiv (preprint)
In common: Keras, TensorFlow, seaborn, 4 other tools, other
[10] doi:10.1038/s41598-026-42310-8 [code]
Sleep awake detection from leg-worn wearables using deep sensor fusion.
Journal: Scientific reports
In common: Keras, TensorFlow, seaborn, 4 other tools, other

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.