Building an EEG Event Classification System

01Introduction to EEG Classification

Electroencephalography (EEG) is a non-invasive method of recording electrical activity in the brain. Clinicians use EEG to diagnose conditions like epilepsy, sleep disorders, and brain injuries by identifying specific patterns—called events—in the signal.

Manually reviewing hours of EEG recordings is time-consuming and requires expert knowledge. This is where machine learning comes in: we can train models to automatically detect and classify these events, assisting clinicians in their diagnostic workflow.

The Complete Pipeline

TUH Label Mapping

The TUH EEG Corpus uses a standardized labeling scheme across its datasets. Here's the complete mapping:

TUSZ / TUEV Labels (Events & Seizures)

TUAR Labels (Artifact Combinations)

02Loading EDF Files & Understanding EEG Data

EEG data is typically stored in EDF (European Data Format) files—a standard format for biosignal recordings. Each EDF file contains multiple channels of continuous voltage measurements sampled at a fixed frequency (commonly 250 Hz).

Loading with MNE-Python

The MNE-Python library provides robust tools for EEG analysis. Here's how to load an EDF file:

import mne

file_path = 'recording.edf'
raw = mne.io.read_raw_edf(file_path, preload=False)

# Access metadata
print(f"Channels: {raw.ch_names}")
print(f"Sampling frequency: {raw.info['sfreq']} Hz")
print(f"Duration: {raw.n_times / raw.info['sfreq']:.1f} seconds")

The 10-20 Electrode System

EEG electrodes are placed according to the 10-20 international system—a standardized arrangement ensuring consistent positioning across recordings. Each electrode has a name like FP1, C3, or O2:

• Letters indicate brain region (F=frontal, C=central, T=temporal, P=parietal, O=occipital)
• Odd numbers are on the left hemisphere
• Even numbers are on the right hemisphere
• Z indicates the midline (zero)

Montage Transformation

Raw EDF files often store data in referential montage—each electrode measured against a common reference. However, clinical analysis typically uses bipolar montage, where adjacent electrodes are subtracted to highlight local differences.

# Transform to bipolar montage
# Example: FP1-F7 = FP1 electrode - F7 electrode
bipolar_data[0, :] = referential_data[fp1_idx, :] - referential_data[f7_idx, :]

The difference between referential and bipolar montage is clearly visible when visualizing the same recording:

data = raw.get_data()

The TUH dataset uses a 22-channel TCP (Temporal-Central-Parietal) montage organized into chains:

Loading Event Labels

The TUH dataset provides labels in .rec files (CSV format) alongside each EDF:

18,10.5,11.5,4    # channel, start_time, end_time, event_code
18,2.6,3.6,4
18,358.3,359.3,4
18,359.3,360.3,5

We convert these time-based annotations into a labels array matching the data dimensions—shape (n_channels, n_samples)—where each sample has an associated event code.

03Exploring Dataset Statistics

Before training a model, understanding your data distribution is crucial. The TUH EEG Corpus provides two complementary datasets with different annotation schemes. Note that we use only the 22-channel TCP montage described in the previous section across both datasets.

TUH EEG Events Distribution

The Events dataset contains 359 EDF files with annotations for six clinical event types. Background activity dominates, while clinically significant patterns like spike-and-wave are rare:

TUH EEG Artifacts Distribution

The Artifacts dataset contains 290 EDF files with fine-grained annotation of non-brain signals. Understanding artifact patterns helps build robust preprocessing pipelines:

04Preparing Data for Training

From this point on, we'll focus exclusively on the TUH EEG Events dataset. Our strategy is to split continuous EEG recordings into fixed-size windows for classification.

Windowing Strategy

We slice recordings into fixed-length windows (e.g., 1 second = 250 samples at 250 Hz). Key considerations:

• Filter unwanted labels: Skip windows containing only background/unlabeled segments
• Respect discontinuities: Only generate windows within contiguous valid segments
• Configurable overlap: Overlapping windows increase training data but risk data leakage

def window_generator(dataset, filter_labels, window_size_sec, overlap):
"""Generate windows from EEG data, avoiding discontinuities."""
for data, labels, metadata in dataset:
    window_size = int(window_size_sec * metadata['sfreq'])
    step_size = int(window_size * (1 - overlap))
    
    # Create mask for valid samples (not in filter_labels)
    mask = np.any(~np.isin(labels, filter_labels), axis=0)
    
    # Find contiguous segments using diff
    padded = np.concatenate([[False], mask, [False]])
    changes = np.diff(padded.astype(int))
    starts = np.where(changes == 1)[0]
    ends = np.where(changes == -1)[0]
    
    for seg_start, seg_end in zip(starts, ends):
        for win_start in range(seg_start, seg_end - window_size + 1, step_size):
            yield data[:, win_start:win_start + window_size], ...

Normalization

EEG amplitudes vary significantly across recordings, channels, and subjects. We apply z-score normalization per channel to standardize:

def normalize_window(data: np.ndarray) -> np.ndarray:
"""Z-score normalization per channel."""
eps = 1e-8
mean = data.mean(axis=1, keepdims=True)
std = data.std(axis=1, keepdims=True)
return ((data - mean) / (std + eps)).astype(np.float32)

Label Aggregation

Each window contains multiple sample-level labels. We use majority voting to assign a single label per window:

def majority_label_vote(labels: np.ndarray) -> int:
"""Return label if all samples identical, else 0 (mixed)."""
if labels.min() == labels.max():
    return int(labels.flat[0])
return 0  # Discard mixed-label windows

Preprocessing Tips

Before feeding EEG data into a model, consider these common preprocessing steps:

• Band-pass filter (0.5–50 Hz): Removes DC drift and high-frequency noise while preserving clinically relevant frequencies
• Notch filter (50/60 Hz): Eliminates power line interference (50 Hz in Europe, 60 Hz in North America)
• Amplitude clipping: Cap extreme values (e.g., ±500 µV) to reduce impact of movement artifacts and electrode pops

In this tutorial, we skip these steps to focus on the ML pipeline, but they can significantly improve model robustness in production.

05Training the Classification Model

With prepared data, we can now train a deep learning classifier. We use ResNet1D—a 1D adaptation of the popular ResNet architecture optimized for time series.

Class Remapping

To simplify our problem and address data scarcity in minority classes, we merge related events:

This gives us a 3-class problem: Background, Artifacts, and Periodic Discharges.

Handling Class Imbalance

Even after remapping, background dominates. We apply random downsampling to balance:

# Before balancing:
# Class 0 (Background): 51,636
# Class 1 (Artifacts):  10,773
# Class 2 (Periodic):   12,646

dataset_balanced = downsample_class(dataset, class_to_downsample=0, target_count=13000)

# After balancing:
# Class 0: 13,000
# Class 1: 10,773
# Class 2: 12,646

Model Architecture

ResNet1D applies the residual learning framework to 1D convolutions:

Training Configuration

We use HuggingFace Trainer for a production-ready training loop:

training_args = TrainingArguments(
num_train_epochs=80,
per_device_train_batch_size=128,
learning_rate=0.0001,
weight_decay=0.01,
warmup_ratio=0.1,
lr_scheduler_type="cosine",

# Evaluation strategy
eval_strategy="steps",
eval_steps=200,
metric_for_best_model="f1_macro",
load_best_model_at_end=True,

# Logging
logging_steps=50,
report_to=["tensorboard"],
)

Metrics

For imbalanced classification, accuracy alone is misleading—a model predicting only the majority class would achieve 68% accuracy but be clinically useless. We track multiple metrics:

For our EEG classifier, we use F1 Macro as the primary model selection metric because it treats all classes equally—critical when rare events like SPSW (0.5% of data) are clinically important.

Training completed in approximately 6 minutes on GPU, demonstrating the efficiency of the ResNet1D architecture for EEG classification tasks.

06Conclusion & Next Steps

We've built a complete EEG event classification DEMO system from scratch:

1. Data Loading: Parsed EDF files and transformed to bipolar montage
2. Exploration: Analyzed dataset statistics and identified class imbalance
3. Preparation: Windowed, normalized, and aggregated labels
4. Training: Built and trained a ResNet1D classifier