mteeg-multi-task-eeg-lora

name	mteeg-multi-task-eeg-lora
description	Multi-task EEG analysis framework using Low-Rank Adaptation (LoRA) for efficient adaptation of pre-trained models to multiple downstream tasks. Addresses EEG signal heterogeneity and task conflicts through task-specific low-rank decomposition. Activation: multi-task EEG, LoRA adaptation, MTEEG, parameter-efficient fine-tuning, cross-subject EEG, task conflict resolution.

MTEEG: Multi-Task EEG Analysis with Low-Rank Adaptation

Parameter-efficient framework for adapting pre-trained EEG models to multiple downstream tasks simultaneously using Low-Rank Adaptation to handle task conflicts.

Metadata

• Source: arXiv:2604.25131
• Authors: Sicheng Dai, Kai Chen, Hongwang Xiao, Xiang Zhang, Bao-Liang Lu
• Published: 2026-04-28
• Category: EEG Analysis, Multi-Task Learning

Core Methodology

Key Innovation

Traditional EEG pre-training requires full fine-tuning for each downstream task, making multi-task deployment computationally expensive. MTEEG enables simultaneous adaptation to multiple tasks using Low-Rank Adaptation (LoRA), resolving task conflicts through task-specific low-rank decomposition.

Problem: Task Conflicts in Multi-Task EEG

EEG signals exhibit heterogeneity due to:

• Different subjects with varying neural patterns
• Diverse recording devices and electrode placements
• Various experimental paradigms and tasks
• Domain shifts between pre-training and downstream tasks

These factors create optimization conflicts when jointly training on multiple tasks.

Solution: LoRA-Based Task Adaptation

Pre-trained Model → Task-Specific LoRA Modules → Multi-Task Outputs
                          ↓
                    Low-Rank Decomposition: W = W₀ + BA
                    where B ∈ ℝ^(d×r), A ∈ ℝ^(r×k), r << min(d,k)

Technical Framework

Architecture Components

Component	Purpose	Details
Shared Encoder	Universal feature extraction	Pre-trained EEG transformer
LoRA Modules	Task-specific adaptation	Low-rank matrices per task
Task Heads	Output prediction	Classification/regression heads
Conflict Resolver	Gradient alignment	Gradient surgery or PCGrad

LoRA Formulation for EEG

For each task t, the adapted weight matrix:

W_t = W_0 + ΔW_t = W_0 + B_t × A_t

Where:

• W_0: Frozen pre-trained weights
• B_t: Task-specific low-rank matrix (down-projection)
• A_t: Task-specific low-rank matrix (up-projection)
• r: Rank (typically 4-16 for EEG)

Multi-Task Training Strategy

Gradient Surgery for Conflict Resolution

def pcgrad(gradients):
    """Project Conflicting Gradients"""
    for i, g_i in enumerate(gradients):
        for j, g_j in enumerate(gradients):
            if i != j and dot(g_i, g_j) < 0:
                # Project g_i onto normal of g_j
                g_i = g_i - (dot(g_i, g_j) / norm(g_j)**2) * g_j
    return gradients

Task Balancing

# Uncertainty-weighted task loss
loss_total = Σ_t (1 / (2 * σ_t²)) * loss_t + log(σ_t)

Implementation Guide

Prerequisites

• Pre-trained EEG foundation model (e.g., EEGNet, Conformer)
• Multiple downstream task datasets
• PyTorch with transformers library

Step-by-Step Implementation

Step 1: Install Dependencies

pip install torch transformers peft

Step 2: LoRA Configuration

from peft import LoraConfig, get_peft_model

lora_config = LoraConfig(
    r=8,  # Rank
    lora_alpha=16,  # Scaling
    target_modules=["query", "value"],  # Apply to attention layers
    lora_dropout=0.1,
    bias="none",
    task_type="classification"
)

# Apply to base model
model = get_peft_model(base_eeg_model, lora_config)

Step 3: Multi-Task Data Loading

class MultiTaskEEGDataset(Dataset):
    def __init__(self, task_datasets):
        self.task_datasets = task_datasets
        self.task_indices = {
            task: idx for idx, task in enumerate(task_datasets.keys())
        }
    
    def __getitem__(self, idx):
        # Sample from random task
        task = random.choice(list(self.task_datasets.keys()))
        data = self.task_datasets[task][idx % len(self.task_datasets[task])]
        return {
            'eeg': data['eeg'],
            'label': data['label'],
            'task_id': self.task_indices[task]
        }

Step 4: Training Loop with Task Routing

class MTEEGTrainer:
    def __init__(self, model, task_heads, num_tasks):
        self.model = model
        self.task_heads = task_heads
        self.num_tasks = num_tasks
        
    def forward(self, eeg_batch, task_ids):
        # Shared encoding
        features = self.model.encode(eeg_batch)
        
        # Task-specific prediction
        outputs = []
        for task_id in range(self.num_tasks):
            mask = task_ids == task_id
            if mask.any():
                task_features = features[mask]
                task_output = self.task_heads[task_id](task_features)
                outputs.append((task_id, task_output, mask))
        
        return outputs
    
    def compute_loss(self, outputs, labels, task_ids):
        total_loss = 0
        for task_id, preds, mask in outputs:
            task_labels = labels[mask]
            task_loss = F.cross_entropy(preds, task_labels)
            total_loss += task_loss
        return total_loss

Complete Training Example

def train_mteeg(model, train_loader, num_epochs=100):
    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)
    
    for epoch in range(num_epochs):
        for batch in train_loader:
            eeg = batch['eeg'].cuda()
            labels = batch['label'].cuda()
            task_ids = batch['task_id'].cuda()
            
            # Forward pass
            outputs = trainer.forward(eeg, task_ids)
            loss = trainer.compute_loss(outputs, labels, task_ids)
            
            # Backward with gradient surgery
            optimizer.zero_grad()
            loss.backward()
            
            # Apply PCGrad
            grads = [p.grad for p in model.parameters() if p.grad is not None]
            if len(grads) > 0:
                pcgrad(grads)
            
            optimizer.step()

Applications

1. Multi-Domain BCI

• Motor imagery classification
• Emotion recognition
• Mental workload estimation
• All from single adapted model

2. Cross-Subject Generalization

• Subject-independent models
• Few-shot personalization
• Domain adaptation

3. Clinical EEG Analysis

• Seizure detection
• Sleep stage classification
• Cognitive state monitoring

Performance Characteristics

Metric	Full Fine-tuning	MTEEG (LoRA)	Improvement
Parameters	100%	0.5-2%	50-200x reduction
Memory	High	Low	Suitable for edge
Training Time	Long	Short	5-10x faster
Multi-task Accuracy	Task-specific	Joint	Comparable

Pitfalls

1. Rank Selection: Too low rank may lose task-specific information; too high increases parameters
2. Task Similarity: Highly dissimilar tasks may still conflict despite LoRA
3. Data Imbalance: Unequal dataset sizes across tasks can bias optimization
4. Pre-training Quality: Poor base model limits adaptation effectiveness

Related Skills

• eeg-foundation-model-adapters
• meta-learning-in-context-brain-decoding
• tta-eeg-foundation-models
• pa-tcnet-cross-subject-eeg

References

• Dai, S., Chen, K., Xiao, H., Zhang, X., & Lu, B. L. (2026). Towards Unified Multi-task EEG Analysis with Low-Rank Adaptation. arXiv:2604.25131.
• Hu, E., et al. (2021). LoRA: Low-Rank Adaptation of Large Language Models. arXiv:2106.09685.
• Yu, T., et al. (2020). Gradient Surgery for Multi-Task Learning. NeurIPS 2020.