EEG Seizure Detection - Interactive CNN Laboratory

SPECTROGRAM WORKSPACE VIEW DATASET: VALIDATION

NON-SEIZURE SPECTROGRAM

File: Loading... Scale: $280 \times 274$

SEIZURE SPECTROGRAM

File: Loading... Scale: $280 \times 274$

CONVOLUTIONAL NETWORK EVALUATION PORTAL RUN: ACTIVE

TRAINING PERFORMANCE CURVE

CONFUSION MATRIX

Dataset Diagnostics

Target Set Select

Non-Seizure Index (1 / 30)

Seizure Index (1 / 30)

Model Execution Records

Select Training Execution

Execution Output Terminal

Loading training execution parameters...

Overview

This laboratory exploration system provides an interactive diagnostic interface for evaluating the performance of a multi-layer Convolutional Neural Network (CNN) configured for the classification of EEG raw segments converted into time-frequency spectrogram visual maps. This method represents a major paradigm shift in automated seizure detection, bridging clinical electrophysiology and deep spatial learning algorithms. In typical clinical workflow pathways, continuous scalp EEG recordings yield massive data pools containing several gigabytes of raw voltage streams spanning hours or days. Reviewing this raw data manually presents a bottleneck for neurologists [INDEX].

SYSTEM AUDIO OVERVIEW

Listen to an AI-generated deep dive conversation explaining this EEG seizure detection system, the CHB-MIT dataset, and Convolutional Neural Networks.

Raw electroencephalogram signals track scalp potential fluctuations $V(t)$ against specified reference electrodes, expressing the synchronous postsynaptic potential dynamics of thousands of pyramidal neurons oriented perpendicularly to the cortical surface. During a paroxysmal epileptic event, normal background activity drops away as clusters of neural pathways experience hypersynchronous hyper-excitation. These transient micro-volt currents propagate through cerebral tissue, cerebrospinal fluid, dural structures, and cranial bone matrices, experiencing spatial low-pass filtering before reaching the scalp sensors. Consequently, raw amplitude readings often contain complex baseline drifts, high-frequency muscular artifact interference, ocular artifacts, and external electrical hums.

To bypass the limitations of classical raw time-domain analysis, we leverage the Short-Time Fourier Transform (STFT). This transformation maps continuous time sequences into visual matrix fields representing time-localized frequency spectra. Mathematically, for a continuous-time brain signal $x(t)$ windowed by an analysis function $w(t)$ centered at time coordinate $\tau$, the linear spectrogram transformation is written as: $$\text{STFT}\{x(t)\}(\tau, \omega) = \int_{-\infty}^{\infty} x(t) w(t - \tau) e^{-i\omega t} \, dt$$ By computing the squared magnitude of this complex representation, we obtain the spectral power density: $$P(\tau, \omega) = \left| \text{STFT}\{x(t)\}(\tau, \omega) \right|^2$$ This process transforms the raw EEG wave pattern into an image where the horizontal dimension maps to elapsed time, the vertical dimension represents spectral frequency coordinates, and pixel brightness corresponds to energy intensity. The resulting spectrogram acts as a structural signature of brain state dynamics. During interictal (between seizures) intervals, spectral energy is distributed among normal brain rhythms: delta bands ($0.5 - 4\text{ Hz}$), theta bands ($4 - 8\text{ Hz}$), alpha bands ($8 - 12\text{ Hz}$), and beta bands ($12 - 30\text{ Hz}$). When an ictal (active seizure) event begins, the energy distribution shifts dramatically. It manifests as highly localized, intense, and synchronous frequency spikes that ripple across the spectrogram image.

How to Use

The portal is designed around standard responsive layout grids to simplify model exploration. The core visualizer workspace displays the currently selected pair of EEG spectrogram images. The **Non-Seizure Spectrogram** on the left shows interictal background states, while the **Seizure Spectrogram** on the right captures ictal event transitions.

Use the controls on the right panel to navigate the datasets and training history. Expand the **Dataset Diagnostics** accordion to select different splits of the clinical database: the Training set ($300$ pairs), Validation set ($30$ pairs), or Test set ($30$ pairs). Use the **Non-Seizure Index** and **Seizure Index** range sliders to scroll sequentially through the spectrogram images. The file metadata display updates instantly below each spectrogram card, showing the exact source folder structure and file name from the CHB-MIT Scalp database [INDEX].

Under **Model Execution Records**, the **Select Training Execution** dropdown lists all 18 historical training sessions. Swapping runs updates the model results section on the left. The system dynamically updates the **Training Performance Curve** (showing the loss minimization curves alongside validation curves over training epochs) and the corresponding **Confusion Matrix** showing model performance on unseen data. Below these plots, the **Misclassified Target Examples** gallery dynamically populates with the specific spectrogram files from the test set where the selected run model predicted incorrectly, highlighting the edge cases that challenge the classifier.

Click **Start Demo** to run an automated simulation. In demo mode, the application locks into a loop that cycles through spectrogram images and steps through different training iterations, illustrating how optimization choices change the model's performance. Click anywhere inside the controls, move a slider, or select a run to immediately halt the demonstration loop and restore your original settings. Click **Reset Baseline** to instantly restore the default Validation set and reset all runs to the optimal baseline state.

Technical Details

The model evaluated on these datasets is a lightweight Convolutional Neural Network optimized for edge clinical computing environments. The input layer accepts three-channel color representations of spectrograms normalized to an exact image shape of $280 \times 274 \times 3$. The core model architecture consists of sequential Feature Extraction layers followed by a Classification head: $$\text{Input } (280 \times 274 \times 3) \rightarrow \text{Conv2D}(16, 3\times3) \rightarrow \text{ReLU} \rightarrow \text{MaxPool2D}(2\times2) \rightarrow \text{Conv2D}(32, 3\times3) \rightarrow \text{ReLU} \rightarrow \text{MaxPool2D}(2\times2) \rightarrow \text{Flatten} \rightarrow \text{Dense}(64) \rightarrow \text{ReLU} \rightarrow \text{Dense}(2) \rightarrow \text{Softmax}$$ In the convolutional steps, a grid of learnable weights (kernels) slides over the image. This operation computes local dot products to extract edge orientations and frequency bands: $$S[i, j] = (I * K)[i, j] = \sum_{m} \sum_{n} I[i - m, j - n] K[m, n]$$ The max-pooling layers reduce spatial resolution by taking the maximum value within a $2 \times 2$ window, reducing calculation complexity and providing spatial translation invariance.

The output head utilizes a 2-node Softmax dense layer to compute probability distributions over the target classes: $$P(y = c \mid \mathbf{x}) = \frac{e^{\mathbf{z}_c}}{\sum_{j=1}^{2} e^{\mathbf{z}_j}}$$ The networks are trained to minimize the Binary Cross-Entropy loss function: $$\mathcal{L} = -\frac{1}{N}\sum_{i=1}^{N} \left[ y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i) \right]$$ The 18 historical runs in the dropdown document the path to optimization. Early SGD configurations (Runs 1 and 8) using large learning rates suffered from slow convergence and validation instability, stalling near 82% validation accuracy. Swapping the optimizer to Adam (Run 2) stabilized the descent, while adjusting batch sizes to 64 (Runs 4-7) helped smooth the noisy gradient steps. The optimal baseline, Run 9 (`final_optimal_run_1`), achieved a high test accuracy of 96.67%.

Run 10 uses identical parameters to Run 9, but displays a lower test accuracy of 90.00%. This comparison highlights the impact of stochastic factors in training, such as random weight initialization and dataset shuffling order. In clinical contexts, evaluating multiple training seeds is critical to ensure model convergence holds across different training conditions before clinical deployment.

Future Directions & Challenges

Our upcoming research path aims to deploy the neural network in real-time, closed-loop clinical environments. One priority is moving beyond pre-rendered static spectrogram images to a dynamic, real-time sliding Short-Time Fourier Transform (STFT) pipeline. This setup will feed continuous scalp EEG streams directly into the model to enable sub-second detection latency. We are also evaluating deeper architecture structures, such as 1D-CNN temporal networks and vision transformers (ViT) that utilize multi-head self-attention to process global correlations across long time scales, which can help capture the subtle changes that precede a seizure.

Furthermore, we plan to validate these models against more diverse, multi-center datasets to test their generalization capability across different patient demographics and varying EEG sensor setups. Finally, to help clinicians interpret model findings, we are integrating explainable AI techniques like Grad-CAM (Gradient-weighted Class Activation Mapping). Grad-CAM overlays a visual heat map on the spectrogram, highlighting the specific frequency bands and time frames that drove the model's prediction and helping clinicians verify its reasoning [INDEX].

Appendix: Python Code for Model Training (train_new.py)

import os
import numpy as np
from PIL import Image
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras import Input
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
import time

# Set random seeds for reproducibility
np.random.seed(42)
tf.random.set_seed(42)

# Parameters
img_size = (280, 274)  # Image size from the study

batch_size = 64          # Better results
epochs = 100             # Number of epochs for training
initial_lr = 0.001       # Better learning rate
augmentation = False     # Data augmentation flag
shuffling = True         # Data shuffling flag

# Define base directory
base_dir = os.path.expanduser('./RhythmScan/static/data/dataset')
train_dir = os.path.join(base_dir, 'train')
val_dir = os.path.join(base_dir, 'val')
test_dir = os.path.join(base_dir, 'test')

# Function to load images from a folder
def load_images_from_folder(folder, label):
    images = []
    labels = []
    if not os.path.exists(folder):
        print(f"Directory {folder} does not exist.")
        return np.array(images), np.array(labels)
    for filename in os.listdir(folder):
        img_path = os.path.join(folder, filename)
        try:
            img = Image.open(img_path).convert('RGB')
            img = img.resize(img_size)
            img_array = np.array(img)
            images.append(img_array)
            labels.append(label)
        except Exception as e:
            print(f"Error loading image {img_path}: {e}")
    return np.array(images), np.array(labels)

# Load images
print("Loading and processing Train set images:")
seizure_train_images, seizure_train_labels = load_images_from_folder(os.path.join(train_dir, 'seizure'), 1)
non_seizure_train_images, non_seizure_train_labels = load_images_from_folder(os.path.join(train_dir, 'non seizure'), 0)

print("Loading and processing Validation set images:")
seizure_val_images, seizure_val_labels = load_images_from_folder(os.path.join(val_dir, 'seizure'), 1)
non_seizure_val_images, non_seizure_val_labels = load_images_from_folder(os.path.join(val_dir, 'non seizure'), 0)

print("Loading and processing Test set images:")
seizure_test_images, seizure_test_labels = load_images_from_folder(os.path.join(test_dir, 'seizure'), 1)
non_seizure_test_images, non_seizure_test_labels = load_images_from_folder(os.path.join(test_dir, 'non seizure'), 0)

# Combine datasets
X_train = np.concatenate((seizure_train_images, non_seizure_train_images), axis=0)
y_train = np.concatenate((seizure_train_labels, non_seizure_train_labels), axis=0)

X_val = np.concatenate((seizure_val_images, non_seizure_val_images), axis=0)
y_val = np.concatenate((seizure_val_labels, non_seizure_val_labels), axis=0)

X_test = np.concatenate((seizure_test_images, non_seizure_test_images), axis=0)
y_test = np.concatenate((seizure_test_labels, non_seizure_test_labels), axis=0)

# Confirm that both 0 and 1 labels are present
print("Unique labels in y_train:", np.unique(y_train))
print("Unique labels in y_val:", np.unique(y_val))
print("Unique labels in y_test:", np.unique(y_test))

# Confirm dataset shapes
print(f"X_train shape: {X_train.shape}")
print(f"y_train shape: {y_train.shape}")
print(f"X_val shape: {X_val.shape}")
print(f"y_val shape: {y_val.shape}")
print(f"X_test shape: {X_test.shape}")
print(f"y_test shape: {y_test.shape}")

# Normalize and reshape data
X_train = X_train / 255.0
X_val = X_val / 255.0
X_test = X_test / 255.0

# One-hot encode labels
y_train = to_categorical(y_train, 2)
y_val = to_categorical(y_val, 2)
y_test = to_categorical(y_test, 2)

# Define the model
model = Sequential([
    Input(shape=(img_size[0], img_size[1], 3)),
    Conv2D(16, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(32, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(64, activation='relu'),
    Dense(2, activation='softmax')
])

# Compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=initial_lr)
optimizer_name = 'Adam'
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])

# Data augmentation (only if augmentation is set to True)
if augmentation:
    datagen = ImageDataGenerator(
        rotation_range=20,
        width_shift_range=0.2,
        height_shift_range=0.2,
        horizontal_flip=True
    )
else:
    datagen = ImageDataGenerator()

# Prepare data generators
train_generator = datagen.flow(X_train, y_train, batch_size=batch_size, shuffle=shuffling)
val_generator = datagen.flow(X_val, y_val, batch_size=batch_size, shuffle=shuffling)

# Callbacks for saving the best model and early stopping
model_checkpoint = ModelCheckpoint(os.path.expanduser('./RhythmScan/best_model.keras'), monitor='val_loss', save_best_only=True)
early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)

# Track training time
start_time = time.time()

# Train the model
history = model.fit(
    train_generator,
    validation_data=val_generator,
    epochs=epochs,
    steps_per_epoch=len(X_train) // batch_size,
    validation_steps=len(X_val) // batch_size,
    callbacks=[model_checkpoint, early_stopping]
)

# Calculate training time per epoch
training_time_per_epoch = (time.time() - start_time) / epochs

# Save the final model
model.save(os.path.expanduser('./RhythmScan/seizure_detection_final_model.keras'))

# Evaluate the model
val_loss, val_acc = model.evaluate(X_test, y_test)
print(f'Test accuracy: {val_acc * 100:.2f}%')

# Model size
model_size = os.path.getsize(os.path.expanduser('./RhythmScan/seizure_detection_final_model.keras')) / (1024 * 1024)  # in MB

# Calculate averages for accuracy and loss
avg_train_acc = np.mean(history.history['accuracy'])
avg_val_acc = np.mean(history.history['val_accuracy'])
avg_train_loss = np.mean(history.history['loss'])
avg_val_loss = np.mean(history.history['val_loss'])

# Output results
print(f'Average Training Accuracy: {avg_train_acc * 100:.2f}%')
print(f'Average Validation Accuracy: {avg_val_acc * 100:.2f}%')
print(f'Average Training Loss: {avg_train_loss:.4f}')
print(f'Average Validation Loss: {avg_val_loss:.4f}')
print(f'Training time per epoch: {training_time_per_epoch:.2f} seconds')
print(f'Model size: {model_size:.2f} MB')

# Plot accuracy and loss over epochs
plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Train')
plt.plot(history.history['val_accuracy'], label='Validation')
plt.title('Model accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(loc='upper left')

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Train')
plt.plot(history.history['val_loss'], label='Validation')
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(loc='upper left')

# Save the figure
timestamp = time.strftime("%Y%m%d-%H%M%S")
save_dir = os.path.expanduser(f'./RhythmScan/static/results_{timestamp}')
os.makedirs(save_dir, exist_ok=True)

plt.savefig(os.path.join(save_dir, f'accuracy_loss_{timestamp}.png'))
plt.show()

# Predict the classes for the test set
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true_classes = np.argmax(y_test, axis=1)

# Find misclassified indices
misclassified_indices = np.where(y_pred_classes != y_true_classes)[0]

# Plot the confusion matrix
conf_matrix = confusion_matrix(y_true_classes, y_pred_classes)
plt.figure(figsize=(10, 7))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=['Non-Seizure', 'Seizure'], yticklabels=['Non-Seizure', 'Seizure'])
plt.title('Confusion Matrix')
plt.xlabel('Predicted Label')
plt.ylabel('True Label')

# Save the confusion matrix figure
plt.savefig(os.path.join(save_dir, f'confusion_matrix_{timestamp}.png'))
plt.show()

# Save the terminal output to a log file
log_file_path = os.path.join(save_dir, f'training_log_{timestamp}.txt')
output_text = f"""Test accuracy: {val_acc * 100:.2f}%
Average Training Accuracy: {avg_train_acc * 100:.2f}%
Average Validation Accuracy: {avg_val_acc * 100:.2f}%
Average Training Loss: {avg_train_loss:.4f}
Average Validation Loss: {avg_val_loss:.4f}
Training time per epoch: {training_time_per_epoch:.2f} seconds
Model size: {model_size:.2f} MB

# Model Settings:
Batch Size: {batch_size}
Epochs: {epochs}
Initial Learning Rate: {initial_lr}
Augmentation: {augmentation}
Shuffling: {shuffling}
Optimizer: {optimizer_name}
Random Seed: 42
Early Stopping Patience: {early_stopping.patience}
"""

# Save log text to the file
with open(log_file_path, 'w') as log_file:
    log_file.write(output_text)

# Plot the first 10 misclassified images
num_images_to_display = 10
plt.figure(figsize=(15, 15))
for i, index in enumerate(misclassified_indices[:num_images_to_display]):
    plt.subplot(5, 2, i + 1)
    plt.imshow(X_test[index])
    plt.title(f"True label: {y_true_classes[index]}, Predicted: {y_pred_classes[index]}")
    plt.axis('off')

# Save misclassified images plot
plt.tight_layout()
plt.savefig(os.path.join(save_dir, f'misclassified_images_{timestamp}.png'))
plt.show()

RELATED DIAGNOSTIC ENVIRONMENTS

seizuresim/
Simulate brain seizure wave dynamics and explore deep three-dimensional EEG layouts.
neurofeedback/
Explore real-time neural mapping algorithms and feedback loop synchronization engines.
icapcaeeg/
Isolate mixed cortical signals using blind source separation algorithms.
spectrogram/
Analyze acoustic wave signals in real-time with an interactive fast Fourier transform visualizer.

NON-SEIZURE SPECTROGRAM

SEIZURE SPECTROGRAM

TRAINING PERFORMANCE CURVE

CONFUSION MATRIX

MISCLASSIFIED TARGET EXAMPLES