eeg-mftnet-multi-scale-temporal

name: eeg-mftnet-multi-scale-temporal description: "EEG-MFTNet: Enhanced EEGNet with multi-scale temporal convolution and fusion transformer for cross-session motor imagery decoding. Addresses session variability in BCI through dual-branch architecture combining frequency-specific temporal features with global temporal modeling." version: 1.0.0 author: Hermes Agent license: MIT metadata: hermes: tags: [eeg, motor-imagery, bci, deep-learning, transformer] source_paper: "EEG-MFTNet: An Enhanced EEGNet Architecture with Multi-Scale Temporal Convolution and Fusion Transformer for Cross-Session Motor Imagery Decoding (arXiv:2604.05843)" citations: 0

EEG-MFTNet: Multi-Scale Temporal Fusion for Cross-Session MI Decoding

Overview

EEG-MFTNet addresses the critical challenge of cross-session performance degradation in motor imagery (MI) BCI systems. Session variability (electrode placement shifts, mental state changes, fatigue) causes significant accuracy drops. EEG-MFTNet combines multi-scale temporal convolution with a fusion transformer to achieve robust cross-session decoding.

Source Paper: arXiv:2604.05843

Architecture

Dual-Branch Design

1. Frequency-Specific Temporal Branch (FSTB)

   • Multi-scale temporal convolutions capture different frequency bands
   • Filters tuned to MI-relevant bands (mu: 8-13 Hz, beta: 13-30 Hz)
   • Parallel paths for different temporal resolutions

2. Fusion Transformer Branch

   • Global temporal attention across all channels
   • Captures long-range temporal dependencies
   • Fuses features from FSTB with learned attention weights

Cross-Session Robustness

• Domain adaptation through feature alignment
• Batch normalization statistics tracking across sessions
• Regularization to prevent overfitting to session-specific patterns

Implementation Pattern

import torch
import torch.nn as nn

class MultiScaleTemporalConv(nn.Module):
    """Multi-scale temporal convolution for EEG feature extraction."""
    
    def __init__(self, in_channels=22, num_scales=3, 
                 kernel_sizes=[15, 35, 65]):
        super().__init__()
        self.branches = nn.ModuleList([
            nn.Sequential(
                nn.Conv2d(1, num_scales, (1, ks), padding=(0, ks//2)),
                nn.BatchNorm2d(num_scales),
                nn.ELU()
            ) for ks in kernel_sizes
        ])
        self.spatial_conv = nn.Conv2d(
            num_scales * len(kernel_sizes), num_scales * len(kernel_sizes),
            (in_channels, 1), groups=1
        )
        
    def forward(self, x):
        # x: (B, 1, channels, time)
        features = [branch(x) for branch in self.branches]
        features = torch.cat(features, dim=1)
        features = self.spatial_conv(features)
        return features

class FusionTransformer(nn.Module):
    """Transformer for global temporal fusion of EEG features."""
    
    def __init__(self, d_model=64, nhead=4, num_layers=2):
        super().__init__()
        encoder_layer = nn.TransformerEncoderLayer(
            d_model=d_model, nhead=nhead, dim_feedforward=128
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)
        
    def forward(self, x):
        # x: (time, B, d_model)
        return self.transformer(x)

class EEGMFTNet(nn.Module):
    """Complete EEG-MFTNet architecture."""
    
    def __init__(self, channels=22, num_classes=4):
        super().__init__()
        self.temporal_branch = MultiScaleTemporalConv(channels)
        self.transformer = FusionTransformer(d_model=64)
        self.classifier = nn.Sequential(
            nn.Linear(64, 32),
            nn.ELU(),
            nn.Dropout(0.5),
            nn.Linear(32, num_classes)
        )
        
    def forward(self, x):
        # x: (B, 1, channels, time)
        features = self.temporal_branch(x)
        # Reshape for transformer
        features = features.mean(dim=1)  # (B, features, time)
        features = features.permute(2, 0, 1)  # (time, B, features)
        features = self.transformer(features)
        features = features.mean(dim=0)  # (B, features)
        return self.classifier(features)

Key Design Decisions

1. Multi-Scale Kernels: Different kernel sizes capture different oscillatory patterns
2. Fusion Strategy: Attention-based fusion outperforms simple concatenation
3. Regularization: Dropout and weight decay critical for cross-session generalization

Applications

1. Motor Imagery BCI: Cross-session decoding for rehabilitation
2. BCI Calibration Reduction: Reduce calibration time for new sessions
3. Clinical Applications: Stroke rehabilitation, neuroprosthetics

Activation Keywords

• EEG motor imagery decoding
• cross-session BCI
• multi-scale temporal convolution
• EEG transformer
• EEG-MFTNet
• 脑电运动想象解码
• 跨会话BCI

Related Skills

• eeg-visual-attention-decoding
• eccentricity-confound-eeg-visual-attention-decoding
• eeg-hopfield-emotion-energy
• copilot-assisted-second-thought-bci