li-dsn-eeg-decoding

name

li-dsn-eeg-decoding

description

Layer-wise Interactive Dual-Stream Network (LI-DSN) for EEG Motor Imagery decoding with cross-subject generalization, spatial-temporal dual-stream architecture, and layer-wise interactive fusion. Addresses the challenge of EEG signal variability across subjects through dual-stream processing and interactive fusion at each network layer. Use when: EEG motor imagery decoding, cross-subject EEG classification, dual-stream neural networks, layer-wise feature fusion, brain-computer interface classification, spatial-temporal EEG features, EEG domain adaptation, motor imagery BCI. Activation: LI-DSN, dual-stream EEG, motor imagery decoding, cross-subject EEG, layer-wise fusion, spatial-temporal EEG network, EEG BCI classification, interactive dual-stream, EEG motor classification.

LI-DSN: Layer-wise Interactive Dual-Stream Network for EEG Decoding

Overview

LI-DSN addresses the key challenge in EEG motor imagery decoding: high variability across subjects. The architecture uses:

1. Spatial stream: Captures electrode-topology-based spatial patterns
2. Temporal stream: Extracts time-frequency dynamics
3. Layer-wise interactive fusion: Bidirectional information exchange between streams at each layer
4. Cross-subject generalization: Domain-invariant feature learning

Source Paper: LI-DSN (arXiv:2604.00123, 2026-04-01)

Core Architecture

┌──────────────────────────────────────────────┐
│              LI-DSN Architecture              │
├──────────────────────────────────────────────┤
│           EEG Input (C × T)                   │
│              ↓                                │
│    ┌──────────────┬──────────────┐            │
│    │ Spatial Stream│ Temporal Stream│           │
│    │  (topology)  │ (time-freq)   │           │
│    └──────┬───────┴───────┬───────┘            │
│           ↓  ↕ FUSION ↕   ↓                    │
│    ┌──────────────┬──────────────┐            │
│    │ Spatial Layer│ Temporal Layer│            │
│    │     n        │      n        │            │
│    └──────┬───────┴───────┬───────┘            │
│           ↓               ↓                    │
│         Classification Layer                    │
└──────────────────────────────────────────────┘

Key Innovations

1. Interactive fusion: Streams communicate at every layer, not just at the end
2. Dual-stream design: Separately models spatial topology and temporal dynamics
3. Cross-subject robustness: Learns domain-invariant representations

Implementation Pattern

import torch
import torch.nn as nn

class InteractiveFusion(nn.Module):
    """Layer-wise bidirectional fusion between spatial and temporal streams."""
    
    def __init__(self, dim):
        super().__init__()
        self.spatial_to_temporal = nn.Linear(dim, dim)
        self.temporal_to_spatial = nn.Linear(dim, dim)
        self.norm = nn.LayerNorm(dim)
        
    def forward(self, spatial_feat, temporal_feat):
        # Spatial features inform temporal processing
        temporal_update = temporal_feat + self.spatial_to_temporal(spatial_feat)
        # Temporal features inform spatial processing  
        spatial_update = spatial_feat + self.temporal_to_spatial(temporal_feat)
        
        return self.norm(spatial_update), self.norm(temporal_update)


class LIDSN(nn.Module):
    """Layer-wise Interactive Dual-Stream Network."""
    
    def __init__(self, n_channels=22, n_classes=4, n_layers=4, dim=64):
        super().__init__()
        # Spatial stream: convolution over electrode topology
        self.spatial_conv = nn.Conv2d(1, dim, (n_channels, 1))
        # Temporal stream: depthwise separable conv over time
        self.temporal_conv = nn.Conv2d(, dim, (, ))
        
        
        .fusion_layers = nn.ModuleList([
            InteractiveFusion(dim)  _  (n_layers)
        ])
        
        .classifier = nn.Linear(dim, n_classes)
    
     ():
        
        spatial_feat = .spatial_conv(x).squeeze()
        temporal_feat = .temporal_conv(x).squeeze()
        
        
         fusion  .fusion_layers:
            spatial_feat, temporal_feat = fusion(spatial_feat, temporal_feat)
        
        
        combined = spatial_feat + temporal_feat
         .classifier(combined.mean(dim=))

Applications

• Motor imagery BCI: Classify intended movements from EEG
• Rehabilitation: Control prosthetic devices via motor imagery
• Cross-subject deployment: Deploy models without per-subject calibration
• Neurofeedback: Real-time brain state classification

Related Skills

• eeg-visual-attention-decoding — EEG-based visual attention decoding
• am-mteeg-classification — Multi-task EEG classification
• eeg2vision-multimodal-eeg-framework — EEG-to-image reconstruction