How to Process Neural Signals: From Raw EEG to Decoded Intentions

Step-by-Step Guide

1. 1

   Understand EEG Signal Characteristics

   EEG measures voltage fluctuations from pyramidal neuron populations in the cortex. Signals are tiny (10-100 µV), noisy (50/60 Hz power line, muscle artifacts, eye blinks), and mixed (each electrode sees a weighted sum of many sources). Spatial resolution: ~3-9 cm at scalp. Temporal resolution: ~1 ms. Key frequency bands: delta (sleep), theta (memory), alpha (relaxation, motor cortex idling), beta (active concentration, motor), gamma (high-level cognition).

   text Copy

   EEG Frequency Bands:
   Delta  0.5-4 Hz   | Deep sleep
   Theta  4-8 Hz    | Memory, drowsiness
   Alpha  8-13 Hz   | Relaxation, motor idling (mu)
   Beta   13-30 Hz  | Active concentration, motor
   Gamma  30-100 Hz | High-level cognition
   
   Signal: 10-100 µV (vs ~1V ECG)
   Noise: 50/60 Hz, muscle (EMG), eye (EOG)
   Electrodes: 1-256 channels
   Sampling: 250-1000 Hz typical

2. 2

   Apply Preprocessing

   Raw EEG needs cleaning before feature extraction. Steps: 1) Bandpass filter (0.5-50 Hz) — removes DC drift and high-frequency noise, 2) Notch filter (50/60 Hz) — removes power line interference, 3) Artifact removal — ICA (Independent Component Analysis) separates EEG from eye blinks, muscle, and heartbeat. 4) Re-referencing — Common Average Reference (CAR) or Laplacian. 5) Epoching — segment data around events (e.g., -2 to +6 seconds).

   python Copy

   import numpy as np
   from scipy.signal import butter, filtfilt
   
   # Bandpass filter 0.5-50 Hz
   def bandpass(data, low, high, fs, order=4):
       nyq = fs / 2
       b, a = butter(order, [low/nyq, high/nyq], btype="band")
       return filtfilt(b, a, data, axis=-1)
   
   # Notch filter 60 Hz
   def notch(data, freq, fs, Q=30):
       from scipy.signal import iirnotch
       b, a = iirnotch(freq, Q, fs)
       return filtfilt(b, a, data, axis=-1)
   
   # Apply
   eeg_clean = bandpass(raw_eeg, 0.5, 50, fs=250)
   eeg_clean = notch(eeg_clean, 60, fs=250)
   
   # Common Average Reference
   eeg_car = eeg_clean - np.mean(eeg_clean, axis=0, keepdims=True)

3. 3

   Remove Artifacts with ICA

   ICA decomposes multi-channel EEG into independent components. Eye blinks, muscle activity, and heartbeat appear as distinct components with characteristic topographies. Remove artifact components and reconstruct. Steps: 1) Center and whiten data, 2) Apply ICA (FastICA or Infomax), 3) Identify artifact components (topography, time course), 4) Remove and back-project. MNE-Python and EEGLAB provide automated ICA labeling.

   💡

   Tip: ICA is powerful but not perfect. It assumes: linear mixing, non-Gaussian sources, and statistically independent components. Over-removal can distort neural signals. Always visually inspect removed components. Automated labeling (ICLabel in EEGLAB) achieves ~90% accuracy for eye and muscle artifacts.
4. 4

   Extract Frequency Features

   For motor imagery BCIs, the key features are power in mu (8-13 Hz) and beta (13-30 Hz) bands. Methods: 1) Band power — filter into band, square, average over time window, 2) Welch's method — PSD estimation via FFT on windowed segments, 3) STFT (Short-Time Fourier Transform) — time-frequency analysis, 4) Wavelet transform — multi-resolution time-frequency. For P300 BCIs: time-domain features (amplitude at 200-400ms post-stimulus).

   python Copy

   # Band power features for motor imagery
   from scipy.signal import welch
   
   def band_power(eeg, fs, fmin, fmax):
       freqs, psd = welch(eeg, fs=fs, nperseg=fs*2)
       idx = np.logical_and(freqs >= fmin, freqs <= fmax)
       return np.mean(psd[idx], axis=-1)
   
   # Mu (8-13 Hz) and Beta (13-30 Hz) power
   mu_power = band_power(epochs, fs=250, fmin=8, fmax=13)
   beta_power = band_power(epochs, fs=250, fmin=13, fmax=30)
   
   features = np.log(np.concatenate([mu_power, beta_power], axis=-1))

5. 5

   Apply Spatial Filtering with CSP

   Common Spatial Pattern (CSP) finds spatial filters that maximize variance for one class while minimizing for another. Steps: 1) Compute covariance matrices for each class, 2) Solve generalized eigenvalue problem, 3) Select top and bottom eigenvectors (most discriminative), 4) Project data onto these filters, 5) Extract log-variance features. CSP is the standard spatial filter for motor imagery BCIs — typically improves accuracy 10-20% over raw band power.

   python Copy

   from mne.decoding import CSP
   from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
   from sklearn.pipeline import Pipeline
   
   # CSP + LDA pipeline (standard motor imagery BCI)
   clf = Pipeline([
       ("csp", CSP(n_components=4, reg="empirical", log=True)),
       ("lda", LinearDiscriminantAnalysis())
   ])
   
   # X: (n_trials, n_channels, n_samples)
   # y: labels (0=left hand, 1=right hand)
   clf.fit(X_train, y_train)
   accuracy = clf.score(X_test, y_test)

6. 6

   Train a Classifier

   Common BCI classifiers: 1) LDA (Linear Discriminant Analysis) — linear, fast, robust with small datasets. The workhorse of BCI. 2) SVM (Support Vector Machine) — handles non-linear boundaries with kernels, good generalization. 3) Neural networks — deep learning for complex patterns (EEGNet, ShallowConvNet). 4) Riemannian geometry — classify covariance matrices directly, no feature extraction needed. For online BCIs: LDA is preferred (fast, interpretable). For offline analysis: try multiple classifiers and cross-validate.

   ⚠️

   Warning: Avoid overfitting! BCI datasets are small (50-200 trials per subject). Use: cross-validation (k-fold or leave-one-out), regularization (shrinkage LDA, C-SVM), and feature selection. Report cross-validated accuracy, not training accuracy. A model with 99% training accuracy and 65% test accuracy is overfit and useless for online BCI.
7. 7

   Implement Online Classification

   Online BCI processes data in real-time: 1) Sliding window (e.g., 2-second buffer), 2) Preprocess (filter, re-reference), 3) Extract features (CSP + log-variance), 4) Classify (LDA), 5) Output command (e.g., move cursor left/right). Latency: 100-500 ms from brain signal to output. Key challenge: non-stationarity — EEG patterns drift over time (fatigue, attention, electrode impedance changes). Solutions: adaptive classifiers (update during use), unsupervised adaptation, and transfer learning.

   python Copy

   # Online BCI loop (pseudo-code)
   buffer = collections.deque(maxlen=fs*2)  # 2-second buffer
   
   while True:
       sample = eeg_stream.get_sample()  # latest sample
       buffer.append(sample)
       
       if len(buffer) == fs * 2:
           epoch = np.array(buffer).T  # (n_channels, n_samples)
           epoch = preprocess(epoch)    # filter, CAR
           features = csp.transform(epoch[None])  # CSP features
           label = lda.predict(features)  # classify
           send_command(label)  # control cursor/wheelchair
   
   # Latency: ~200-500ms (buffer + processing + output)

8. 8

   Evaluate BCI Performance

   Metrics: 1) Classification accuracy — percentage of correct trials. Chance level: 50% (binary), 25% (4-class). Target: >70% for usable BCI. 2) Information Transfer Rate (ITR) — bits per minute: ITR = B * log2(N) * P, where B=trial rate, N=classes, P=accuracy. 3) Cohen's kappa — chance-corrected accuracy (0=random, 1=perfect). 4) ROC/AUC — for binary classification. 5. Subject variability — BCI performance varies widely (5-20% of users are "BCI illiterate" with <60% accuracy).

   💡

   Tip: ITR is the key practical metric. A 4-class BCI at 70% accuracy with 4-second trials: ITR = (60/4) * log2(4) * 0.7 = 21 bits/min. A 2-class BCI at 85% with 2-second trials: ITR = (60/2) * log2(2) * 0.85 = 25.5 bits/min. Sometimes fewer classes with higher accuracy is better than more classes with lower accuracy.
9. 9

   Handle Non-Stationarity

   EEG is non-stationary — patterns change within and across sessions. Causes: fatigue, learning, electrode impedance, attention, mood. Solutions: 1) Session-to-session: recalibrate classifier at start of each session (5-10 min calibration). 2) Within-session: unsupervised adaptation (update classifier without labels using confidence). 3) Transfer learning: use data from other subjects + small calibration from current subject. 4) Riemannian methods: more robust to non-stationarity than CSP+LDA. 5) Deep learning: EEGNet with data augmentation.

   ⚠️

   Warning: Non-stationarity is the #1 challenge for practical BCIs. A classifier trained in the morning may not work in the afternoon. Current solutions require recalibration (annoying for users) or complex adaptation (hard to implement robustly). This is why BCIs are still mostly research tools, not consumer products.