Meta Learning In Context Brain Decoding V3

---
name: meta-learning-in-context-brain-decoding-v3
description: "Meta-learning in-context brain decoding methodology for zero-shot cross-subject generalization in BCI. Enables training-free adaptation to new users by framing brain signal decoding as an in-context learning problem — constructing support sets from other subjects and using them as context at inference time without any fine-tuning. Applicable to EEG, MEG, fMRI, and invasive recordings."
version: 3.0.0
metadata:
  hermes:
    tags:
      - brain-decoding
      - meta-learning
      - in-context-learning
      - BCI
      - cross-subject-generalization
      - zero-shot-decoding
      - EEG
      - MEG
      - fMRI
      - training-free
      - neural-decoding
      - few-shot-learning
    source_paper: "Meta-Learning In-Context Brain Decoding (NeurIPS/arXiv, 2024)"
    doi: "10.48550/arXiv.2406.04567"
---

# Meta-Learning In-Context Brain Decoding

**Training-free cross-subject brain signal decoding via in-context learning — enabling zero-shot generalization to new BCI users without fine-tuning.**

## Core Innovation

This methodology reformulates cross-subject brain decoding as an **in-context learning** problem, inspired by how large language models adapt to new tasks from a few examples in the prompt context. Instead of traditional fine-tuning or domain adaptation on new subjects' data, the model:

1. **Learns a universal decoding function** during meta-training across many source subjects
2. **Constructs a support set** of labeled brain signal examples at inference time
3. **Uses the support set as in-context examples** to adapt predictions for the target subject
4. **Requires zero gradient updates** — all adaptation happens through the model's forward pass conditioned on the support set

This enables **true zero-shot generalization**: deploying a trained model to entirely new BCI users with no subject-specific training or calibration data collection beyond the support set.

## Architecture Overview

### High-Level Pipeline

```
┌─────────────────────────────────────────────────────────────┐
│                    META-TRAINING PHASE                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Source Subjects: S₁, S₂, ..., Sₙ                           │
│                                                             │
│  For each subject Sᵢ:                                       │
│    ┌──────────────┐    ┌──────────────┐                    │
│    │ Brain Signals│ →  │   Encoder    │ → hᵢ               │
│    │   xᵢ, yᵢ     │    │  (Transformer│   (latent reps)    │
│    └──────────────┘    │   or CNN)    │                    │
│                        └──────────────┘                    │
│                                                             │
│  Support Set S: {(x₁,y₁), ..., (xₖ,yₖ)}                     │
│  Query:       x_q                                          │
│                                                             │
│  ┌──────────────────────────────────────────┐              │
│  │         In-Context Decoder                │              │
│  │                                          │              │
│  │  Input: [S; x_q] (concatenated sequence)  │              │
│  │  ┌────────────────────────────────────┐  │              │
│  │  │ Cross-Attention / Self-Attention   │  │              │
│  │  │ (queries learn from support set)   │  │              │
│  │  └────────────────────────────────────┘  │              │
│  │         ↓                                 │              │
│  │     Predict: ŷ_q                          │              │
│  └──────────────────────────────────────────┘              │
│                                                             │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│                  INFERENCE PHASE (Zero-Shot)                │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  New Target Subject S_new (unseen during training)          │
│                                                             │
│  Step 1: Collect small support set {(x₁,y₁),...,(xₖ,yₖ)}   │
│          (can be as few as 5-20 labeled examples)           │
│                                                             │
│  Step 2: Encode query brain signal x_q → h_q               │
│                                                             │
│  Step 3: Forward pass through decoder with                 │
│          [Support(h₁,y₁), ..., Support(hₖ,yₖ), Query(h_q)] │
│          as context → ŷ_q                                   │
│                                                             │
│  ✓ No gradient updates required                             │
│  ✓ No subject-specific fine-tuning                          │
│  ✓ Works immediately for any new subject                    │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### Key Components

| Component | Role | Typical Architecture |
|-----------|------|---------------------|
| **Signal Encoder** | Maps raw brain signals → latent representations | CNN, Transformer, or hybrid encoder |
| **Support Set Constructor** | Selects/organizes examples for in-context conditioning | KNN, random sampling, or learned selection |
| **In-Context Decoder** | Processes [support; query] sequence for prediction | Transformer with cross-attention |
| **Label Encoder** | Maps labels into same space as signal representations | MLP or embedding layer |
| **Positional Encoding** | Distinguishes support vs. query positions | Learned or sinusoidal |

## In-Context Learning Mechanism for Brain Signals

The core idea is to treat brain signal decoding as a **sequence-to-sequence** problem where the "context" consists of labeled examples from the current subject:

### Mathematical Formulation

Given:
- **Support set**: `S = {(x₁, y₁), ..., (xₖ, yₖ)}` where xᵢ are brain signal trials and yᵢ are labels
- **Query**: `x_q` (new unlabeled brain signal)

The model computes:
```
ŷ_q = f_θ(x_q | S)

where f_θ is the in-context decoder parameterized by θ,
conditioned on the support set S
```

### Attention-Based Conditioning

The decoder uses **cross-attention** where:
- **Queries**: Derived from the query brain signal
- **Keys/Values**: Derived from the support set representations

```
Attention(Q, K, V) = softmax(QK^T / √d) · V

Q = W_Q · h_q          (query representations)
K = W_K · [h₁; ...; hₖ]  (support signal representations)
V = W_V · [h₁⊕y₁; ...; hₖ⊕yₖ]  (support signals with labels)
```

### Why This Works for Brain Signals

1. **Subject-invariant features**: The meta-trained encoder learns representations that are partially shared across subjects
2. **Subject-specific calibration**: The support set provides the "calibration offset" needed for the new subject
3. **Non-parametric adaptation**: In-context learning performs a form of nearest-neighbor adaptation in representation space
4. **Gradient-free**: The model's learned attention patterns automatically weight relevant support examples

## Support Set Construction and Query Processing

### Support Set Selection Strategies

#### 1. Random Sampling
```python
import numpy as np

def random_support_set(X_source, y_source, k, random_state=42):
    """Randomly sample k examples for the support set."""
    rng = np.random.RandomState(random_state)
    indices = rng.choice(len(X_source), size=k, replace=False)
    return X_source[indices], y_source[indices]
```

#### 2. K-Nearest Neighbor (in Representation Space)
```python
from sklearn.neighbors import NearestNeighbors

def knn_support_set(X_source, y_source, x_query, k, n_neighbors=10):
    """Select support examples near the query in representation space."""
    nn = NearestNeighbors(n_neighbors=min(k, len(X_source)), metric='cosine')
    nn.fit(X_source)
    distances, indices = nn.kneighbors(x_query.reshape(1, -1))
    return X_source[indices[0]], y_source[indices[0]]
```

#### 3. Stratified Sampling (for Classification)
```python
def stratified_support_set(X_source, y_source, k, classes=None):
    """Ensure balanced class representation in support set."""
    if classes is None:
        classes = np.unique(y_source)
    per_class = k // len(classes)
    X_s, y_s = [], []
    for c in classes:
        mask = y_source == c
        indices = np.random.choice(np.where(mask)[0], size=per_class, replace=False)
        X_s.extend(X_source[indices])
        y_s.extend(y_source[indices])
    # Add remainder to first class
    remaining = k - len(y_s)
    if remaining > 0:
        extra_idx = np.random.choice(len(X_source), size=remaining, replace=False)
        X_s.extend(X_source[extra_idx])
        y_s.extend(y_source[extra_idx])
    return np.array(X_s), np.array(y_s)
```

#### 4. Learned Support Selection
```python
import torch
import torch.nn as nn

class LearnedSupportSelector(nn.Module):
    """Neural network that learns optimal support set selection."""
    
    def __init__(self, embed_dim, hidden_dim=128):
        super().__init__()
        self.scorer = nn.Sequential(
            nn.Linear(2 * embed_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, 1)
        )
    
    def forward(self, query_emb, support_embs, k):
        """Score each support example by relevance to query."""
        batch_size = support_embs.shape[0]
        # Broadcast query to all support examples
        query_expanded = query_emb.unsqueeze(0).expand(batch_size, -1)
        # Concatenate query and support for scoring
        combined = torch.cat([query_expanded, support_embs], dim=-1)
        scores = self.scorer(combined).squeeze(-1)
        # Select top-k
        top_k_indices = torch.topk(scores, k=k, dim=0).indices
        return top_k_indices
```

### Query Processing Pipeline

```python
class InContextBrainDecoder:
    """Complete in-context brain decoding pipeline."""
    
    def __init__(self, encoder, decoder, label_encoder=None):
        self.encoder = encoder          # Brain signal encoder
        self.decoder = decoder          # In-context decoder
        self.label_encoder = label_encoder or IdentityLabelEncoder()
    
    def decode(self, support_signals, support_labels, query_signal):
        """Zero-shot decoding using in-context learning.
        
        Args:
            support_signals: Tensor of shape (k, channels, time) or (k, features)
            support_labels: Tensor of shape (k,) or (k, num_classes)
            query_signal: Tensor of shape (channels, time) or (features,)
        
        Returns:
            Predicted label(s) for the query signal
        """
        # Step 1: Encode all signals
        support_embs = self.encoder(support_signals)   # (k, embed_dim)
        query_emb = self.encoder(query_signal)         # (embed_dim,)
        
        # Step 2: Encode labels
        label_embs = self.label_encoder(support_labels)  # (k, label_dim)
        
        # Step 3: Combine into context sequence
        # Format: [signal_1, label_1, signal_2, label_2, ..., query]
        context = self._build_context(support_embs, label_embs, query_emb)
        
        # Step 4: Forward pass through in-context decoder
        predictions = self.decoder(context)
        
        return predictions
    
    def _build_context(self, support_embs, label_embs, query_emb):
        """Construct the in-context sequence."""
        k = support_embs.shape[0]
        # Interleave signal and label embeddings
        context_tokens = torch.zeros(2 * k + 1, support_embs.shape[-1])
        context_tokens[0::2][:k] = support_embs      # Signal tokens at even positions
        context_tokens[1::2][:k] = label_embs         # Label tokens at odd positions
        context_tokens[-1] = query_emb                # Query token at end
        return context_tokens
```

### EEG/MEG-Specific Processing

```python
import torch
from torch import nn
import torch.nn.functional as F

class EEGInContextDecoder(nn.Module):
    """In-context decoder optimized for EEG/MEG signals."""
    
    def __init__(
        self,
        n_channels=64,
        n_timepoints=500,
        embed_dim=256,
        n_heads=8,
        n_layers=6,
        n_classes=4,
        dropout=0.1
    ):
        super().__init__()
        
        # Temporal encoder: raw EEG → features
        self.temporal_encoder = nn.Sequential(
            nn.Conv1d(n_channels, 64, kernel_size=3, padding=1),
            nn.BatchNorm1d(64),
            nn.GELU(),
            nn.Conv1d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm1d(128),
            nn.GELU(),
            nn.Conv1d(128, embed_dim, kernel_size=3, padding=1),
            nn.AdaptiveAvgPool1d(1)
        )
        
        # In-context transformer decoder
        decoder_layer = nn.TransformerDecoderLayer(
            d_model=embed_dim,
            nhead=n_heads,
            dim_feedforward=embed_dim * 4,
            dropout=dropout,
            batch_first=True
        )
        self.decoder = nn.TransformerDecoder(decoder_layer, num_layers=n_layers)
        
        # Output head
        self.classifier = nn.Sequential(
            nn.Linear(embed_dim, embed_dim // 2),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(embed_dim // 2, n_classes)
        )
        
        # Positional encoding
        self.pos_encoding = PositionalEncoding(embed_dim, max_len=100)
        
        # Label embedding for one-hot labels
        self.label_embedding = nn.Linear(n_classes, embed_dim)
    
    def forward(self, support_signals, support_labels, query_signal):
        """
        Args:
            support_signals: (batch, k, channels, time)
            support_labels:  (batch, k, n_classes) - one-hot
            query_signal:    (batch, channels, time)
        """
        batch_size, k = support_signals.shape[:2]
        
        # Encode support signals: (batch, k, embed_dim)
        support_flat = support_signals.view(batch_size * k, *support_signals.shape[2:])
        support_embs = self.temporal_encoder(support_flat)
        support_embs = support_embs.view(batch_size, k, -1)
        
        # Encode query signal: (batch, 1, embed_dim)
        query_embs = self.temporal_encoder(query_signal).unsqueeze(1)
        
        # Encode labels: (batch, k, embed_dim)
        label_embs = self.label_embedding(support_labels)
        
        # Build context: [signal_1, label_1, ..., signal_k, label_k, query]
        context = torch.cat([
            support_embs.unsqueeze(2),   # (batch, k, 1, embed_dim)
            label_embs.unsqueeze(2)      # (batch, k, 1, embed_dim)
        ], dim=2).view(batch_size, 2 * k, -1)
        context = torch.cat([context, query_embs], dim=1)  # (batch, 2k+1, embed_dim)
        
        # Add positional encoding
        context = self.pos_encoding(context)
        
        # Decoder: self-attention over entire context
        decoder_out = self.decoder(context)
        
        # Extract query position (last token) and classify
        query_out = decoder_out[:, -1, :]  # (batch, embed_dim)
        logits = self.classifier(query_out)
        
        return logits
```

### fMRI-Specific Processing

```python
class fMRIInContextDecoder(nn.Module):
    """In-context decoder for fMRI BOLD signal patterns."""
    
    def __init__(
        self,
        n_regions=400,  # e.g., Schaefer-400 atlas
        embed_dim=256,
        n_heads=8,
        n_layers=4,
        n_classes=2,
        use_temporal=True,
        temporal_window=10
    ):
        super().__init__()
        
        self.use_temporal = use_temporal
        self.temporal_window = temporal_window
        
        # Region encoder: fMRI volumes → embeddings
        input_dim = n_regions * (temporal_window if use_temporal else 1)
        self.region_encoder = nn.Sequential(
            nn.Linear(input_dim, embed_dim * 2),
            nn.LayerNorm(embed_dim * 2),
            nn.GELU(),
            nn.Dropout(0.2),
            nn.Linear(embed_dim * 2, embed_dim),
            nn.LayerNorm(embed_dim)
        )
        
        # Cross-attention decoder
        self.cross_attn = nn.MultiheadAttention(
            embed_dim=embed_dim,
            num_heads=n_heads,
            batch_first=True,
            dropout=0.1
        )
        
        # Self-attention layers for context
        self.self_attn_layers = nn.ModuleList([
            nn.MultiheadAttention(embed_dim, n_heads, batch_first=True, dropout=0.1)
            for _ in range(n_layers)
        ])
        
        # Classification head
        self.classifier = nn.Sequential(
            nn.Linear(embed_dim, embed_dim // 2),
            nn.GELU(),
            nn.LayerNorm(embed_dim // 2),
            nn.Linear(embed_dim // 2, n_classes)
        )
    
    def forward(self, support_signals, support_labels, query_signal):
        """
        Args:
            support_signals: (batch, k, n_regions, temporal_window)
            support_labels:  (batch, k)
            query_signal:    (batch, n_regions, temporal_window)
        """
        batch_size, k = support_signals.shape[:2]
        
        # Flatten temporal dimension if needed
        if self.use_temporal:
            support_flat = support_signals.reshape(batch_size * k, -1)
            query_flat = query_signal.reshape(batch_size, -1)
        else:
            support_flat = support_signals.reshape(batch_size * k, -1)
            query_flat = query_signal.reshape(batch_size, -1)
        
        # Encode
        support_embs = self.region_encoder(support_flat).reshape(batch_size, k, -1)
        query_embs = self.region_encoder(query_flat).unsqueeze(1)
        
        # Embed labels
        label_embs = nn.Embedding(2, query_embs.shape[-1]).to(support_embs.device)
        support_label_embs = label_embs(support_labels.long())
        
        # Build context sequence
        context = torch.cat([
            support_embs,
            support_label_embs,
            query_embs
        ], dim=1)
        
        # Self-attention over context
        for layer in self.self_attn_layers:
            attn_out, _ = layer(context, context, context)
            context = context + attn_out
            context = context / context.norm(dim=-1, keepdim=True)
        
        # Extract query prediction
        query_out = context[:, -1, :]
        logits = self.classifier(query_out)
        
        return logits
```

## Meta-Training Procedure

The model is trained using episodic meta-learning, where each "episode" simulates a few-shot task:

```python
def meta_train_episode(model, source_subjects, k_support, q_query, optimizer):
    """One episode of meta-training (e.g., MAML-style)."""
    
    # Sample a task (subject)
    task_subject = random.choice(source_subjects)
    task_data = task_subject.get_data()
    
    # Split into support and query
    support_x, support_y = random.sample(task_data, k_support)
    query_x, query_y = random.sample(
        [d for d in task_data if d not in zip(support_x, support_y)],
        q_query
    )
    
    # Forward pass
    logits = model(
        support_signals=support_x,
        support_labels=support_y,
        query_signal=query_x
    )
    
    # Compute loss
    loss = F.cross_entropy(logits, query_y)
    
    # Backprop and update
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    return loss.item()
```

### Episode Construction for Cross-Subject Generalization

```python
class CrossSubjectEpisodeSampler:
    """Creates meta-learning episodes that maximize cross-subject generalization."""
    
    def __init__(self, subjects, k_support=10, q_query=20, n_ways=4):
        self.subjects = subjects
        self.k_support = k_support
        self.q_query = q_query
        self.n_ways = n_ways
    
    def sample_episode(self):
        """Sample one episode with support from mixed subjects."""
        # Strategy: Support set drawn from all subjects except one
        # Query set drawn from the held-out subject
        # This forces the model to learn cross-subject transfer
        
        held_out_idx = np.random.randint(len(self.subjects))
        held_out = self.subjects[held_out_idx]
        source_subjects = [s for i, s in enumerate(self.subjects) if i != held_out_idx]
        
        # Support: mixed from source subjects (stratified)
        support_x, support_y = [], []
        per_source = self.k_support // len(source_subjects)
        for subject in source_subjects:
            x_s, y_s = subject.sample(per_source, n_ways=self.n_ways)
            support_x.append(x_s)
            support_y.append(y_s)
        
        support_x = np.concatenate(support_x)
        support_y = np.concatenate(support_y)
        
        # Query: from held-out subject
        query_x, query_y = held_out.sample(self.q_query, n_ways=self.n_ways)
        
        return support_x, support_y, query_x, query_y
```

## Implementation Patterns

### Pattern 1: Basic EEG Motor Imagery Decoding

```python
# Zero-shot cross-subject motor imagery decoding
import torch
from incontext_brain import EEGInContextDecoder

# Load pretrained model
model = EEGInContextDecoder(
    n_channels=22,       # 22 EEG channels (e.g., BCI Competition IV)
    n_timepoints=500,    # 1 second @ 500Hz
    embed_dim=256,
    n_heads=8,
    n_layers=6,
    n_classes=4          # left hand, right hand, feet, tongue
)
model.load_state_dict(torch.load('eeg_incontext_pretrained.pt'))
model.eval()

# New subject: collect minimal calibration data
# In practice, these would be a few labeled trials
support_signals = torch.randn(1, 20, 22, 500)    # 20 support examples
support_labels = torch.randint(0, 4, (1, 20))     # 4-class labels

# Decode new trial (zero-shot — no fine-tuning!)
query_signal = torch.randn(1, 22, 500)
with torch.no_grad():
    logits = model(support_signals, support_labels, query_signal)
    predicted_class = logits.argmax(dim=-1).item()
    probabilities = torch.softmax(logits, dim=-1)
    
print(f"Predicted class: {predicted_class}")
print(f"Confidence: {probabilities.max().item():.3f}")
```

### Pattern 2: Incremental Support Set Updating

```python
class IncrementalInContextDecoder:
    """Decoder that grows its support set over time."""
    
    def __init__(self, model, max_support_size=50):
        self.model = model
        self.support_signals = []
        self.support_labels = []
        self.max_support_size = max_support_size
    
    def decode_and_update(self, query_signal, true_label=None):
        """Decode query, optionally update support set if label provided."""
        if len(self.support_signals) == 0:
            # Fallback: random prediction if no support
            return None
        
        support_x = torch.stack(self.support_signals)
        support_y = torch.stack(self.support_labels)
        
        with torch.no_grad():
            logits = self.model(
                support_x.unsqueeze(0),
                support_y.unsqueeze(0),
                query_signal.unsqueeze(0)
            )
            prediction = logits.argmax(dim=-1).item()
        
        # Update support set if ground truth provided
        if true_label is not None:
            self.support_signals.append(query_signal)
            self.support_labels.append(torch.tensor(true_label))
            
            # Maintain max size (remove oldest)
            if len(self.support_signals) > self.max_support_size:
                self.support_signals.pop(0)
                self.support_labels.pop(0)
        
        return prediction
```

### Pattern 3: Multi-Modal Support Set (EEG + Eye Tracking)

```python
class MultiModalInContextDecoder(nn.Module):
    """In-context decoder with multi-modal support sets."""
    
    def __init__(self, eeg_dim=256, eye_dim=128, fused_dim=512, n_classes=4):
        super().__init__()
        self.eeg_encoder = EEGEncoder(output_dim=eeg_dim)
        self.eye_encoder = EyeTrackerEncoder(output_dim=eye_dim)
        
        # Cross-modal fusion
        self.fusion = nn.Sequential(
            nn.Linear(eeg_dim + eye_dim, fused_dim),
            nn.LayerNorm(fused_dim),
            nn.GELU()
        )
        
        self.label_encoder = nn.Embedding(n_classes, fused_dim)
        
        # In-context transformer
        decoder_layer = nn.TransformerDecoderLayer(
            d_model=fused_dim, nhead=8, batch_first=True
        )
        self.decoder = nn.TransformerDecoder(decoder_layer, num_layers=4)
        self.classifier = nn.Linear(fused_dim, n_classes)
    
    def forward(self, eeg_support, eye_support, labels, eeg_query, eye_query):
        # Encode modalities
        eeg_support_emb = self.eeg_encoder(eeg_support)
        eye_support_emb = self.eye_encoder(eye_support)
        eeg_query_emb = self.eeg_encoder(eeg_query).unsqueeze(1)
        eye_query_emb = self.eye_encoder(eye_query).unsqueeze(1)
        
        # Fuse modalities
        support_fused = self.fusion(torch.cat([eeg_support_emb, eye_support_emb], dim=-1))
        query_fused = self.fusion(torch.cat([eeg_query_emb, eye_query_emb], dim=-1))
        
        # Build context
        label_embs = self.label_encoder(labels.long())
        context = torch.cat([support_fused, label_embs, query_fused], dim=1)
        
        # Decode
        out = self.decoder(context)
        return self.classifier(out[:, -1, :])
```

### Pattern 4: Support Set Quality Assessment

```python
def assess_support_set_quality(model, support_x, support_y, test_x, test_y):
    """Evaluate how informative a support set is."""
    with torch.no_grad():
        # Predict on test set
        logits = model(
            support_x.unsqueeze(0).expand(len(test_x), -1, -1, -1),
            support_y.unsqueeze(0).expand(len(test_x), -1),
            test_x
        )
        accuracy = (logits.argmax(dim=-1) == test_y).float().mean()
    
    # Also compute:
    # 1. Support set diversity (pairwise distances)
    support_embs = model.encoder(support_x)
    diversity = torch.cdist(support_embs, support_embs).mean()
    
    # 2. Support-label consistency
    # (how well do support examples cluster by label?)
    
    return {
        'accuracy': accuracy.item(),
        'diversity': diversity.item(),
        'support_size': len(support_y)
    }
```

## Configuration and Hyperparameters

| Parameter | Default | Range | Description |
|-----------|---------|-------|-------------|
| `k_support` | 10 | 5-50 | Number of support examples per query |
| `embed_dim` | 256 | 128-512 | Latent embedding dimension |
| `n_heads` | 8 | 4-16 | Number of attention heads |
| `n_layers` | 4-6 | 2-12 | Transformer decoder layers |
| `dropout` | 0.1 | 0.0-0.3 | Dropout rate |
| `learning_rate` | 1e-4 | 1e-5-1e-3 | Meta-training learning rate |
| `batch_size` | 32 | 16-128 | Episodes per batch |
| `episodes_per_epoch` | 1000 | 500-5000 | Meta-training episodes |
| `support_selection` | 'random' | 'random', 'knn', 'stratified', 'learned' | Support set strategy |
| `label_encoding` | 'one-hot' | 'one-hot', 'learned', 'continuous' | Label representation |

## Key Considerations and Best Practices

### Support Set Design
- **Minimum effective size**: 5-10 examples per class often sufficient
- **Class balance**: Ensure stratified sampling for classification tasks
- **Quality over quantity**: A small well-chosen support set beats a large random one
- **Domain alignment**: Support examples should match query conditions (task, paradigm)

### Signal Processing
- **Preprocessing is critical**: Bandpass filtering, artifact removal, and normalization must be consistent between support and query
- **Temporal alignment**: Ensure trials are time-locked consistently
- **Channel correspondence**: Same electrode montage across subjects

### Training Strategy
- **Leave-one-subject-out**: Standard cross-validation for cross-subject generalization
- **Episodic training**: Mimics the inference scenario during training
- **Data augmentation**: Add noise, time warping to improve robustness
- **Early stopping**: Monitor validation on held-out subjects

### Inference Optimization
- **Pre-compute support embeddings**: Encode support set once, reuse for multiple queries
- **Batch queries**: Process multiple queries with same support set efficiently
- **Support set caching**: Cache good support sets for repeated use
- **Memory management**: Large support sets increase computation linearly

## Pitfalls and Common Mistakes

### 🚫 Data Leakage
- **Never** let query subject's data appear in the support set during evaluation
- Ensure strict subject-level train/test splits
- Cross-validation must be leave-one-subject-out, not random split

### 🚫 Mismatched Preprocessing
- Support and query signals **must** undergo identical preprocessing
- Different filter settings, referencing schemes, or normalization will break in-context adaptation
- Pipeline: raw → filter → artifact removal → epoch → normalize → encode

### 🚫 Support Set Contamination
- If support set labels are noisy, the model will learn incorrect associations
- Verify label quality before constructing support sets
- Consider label smoothing for uncertain annotations

### 🚫 Over-reliance on Support Size
- More support examples ≠ better performance beyond a point
- Diminishing returns after ~20-30 examples per class
- Focus on support set **quality** and **diversity** instead

### 🚫 Ignoring Subject Heterogeneity
- Extreme outlier subjects (different anatomy, recording equipment) may not transfer well
- Consider subject clustering and cluster-specific support sets
- Monitor per-subject performance to identify problematic cases

### 🚫 Computational Overhead
- In-context learning scales O(k²) with support set size in self-attention
- For large support sets, consider memory-efficient attention or chunking
- Pre-computing support embeddings reduces per-query cost to O(k)

### 🚫 Modality-Specific Issues
- **EEG**: High inter-subject variability in scalp topography; consider spatial filtering
- **fMRI**: Different scanner parameters, head motion; requires careful spatial normalization
- **MEG**: Sensor alignment differences; may need head position compensation
- **Invasive**: Electrode placement variability across subjects is extreme

## Performance Benchmarks (Typical)

| Dataset | Task | Support Size | Accuracy | Baseline (fine-tune) |
|---------|------|-------------|----------|---------------------|
| BCI IV 2a | Motor Imagery (4-class) | 10/trial | ~65-72% | ~70-75% |
| BCI IV 2b | Motor Imagery (2-class) | 10/trial | ~75-82% | ~80-85% |
| MOABB datasets | Various MI tasks | 10/trial | ~60-70% | ~65-75% |
| Custom fMRI | Visual category (2-class) | 20/trial | ~70-80% | ~75-85% |

*Note: In-context performance approaches fine-tuning with adequate support sets, while requiring zero gradient updates.*

## Activation Keywords

### English
- meta-learning brain decoding
- in-context brain decoding
- cross-subject BCI decoding
- zero-shot brain signal decoding
- training-free BCI adaptation
- few-shot neural decoding
- episodic brain decoding
- support set brain decoding
- context-conditioned neural decoding
- calibration-free BCI
- subject-independent brain decoding
- in-context learning EEG
- transformer brain decoding
- meta-learning EEG classification
- cross-subject generalization BCI

### Chinese
- 元学习脑解码
- 上下文脑解码
- 跨被试BCI解码
- 零样本脑信号解码
- 免训练BCI自适应
- 少样本神经解码
- 情景式脑解码
- 支持集脑解码
- 上下文条件神经解码
- 免校准BCI
- 被试独立脑解码
- 上下文学习脑电
- Transformer脑解码
- 元学习脑电分类
- 跨被试泛化BCI

## Related Skills

- **brain-dit-fmri-foundation-model**: fMRI foundation model with diffusion pretraining across brain states
- **eeg2vision-multimodal-eeg-framework-2d-visual**: EEG-to-vision multimodal decoding framework
- **eccentricity-confound-eeg-visual-attention-decoding**: EEG visual attention decoding with eccentricity correction
- **spiking-neural-network-analysis**: Spiking neural network analysis and modeling
- **wavemoe-time-series**: Mixture-of-experts for time series (alternative architecture for temporal signals)
- **neural-emulator-theory**: Neural network emulation of dynamical systems
- **time-varying-brain-connectivity**: Dynamic brain connectivity analysis

## References

- **Paper**: Meta-Learning In-Context Brain Decoding
- **DOI**: 10.48550/arXiv.2406.04567
- **Year**: 2024
- **Venue**: NeurIPS (or arXiv preprint)
- **Key Concepts**: Meta-learning, In-context learning, Cross-subject generalization, BCI, Zero-shot decoding, Few-shot learning, Transformer architectures

## Tools Used

- **python**: PyTorch implementation
- **scikit-learn**: Support set selection (KNN, stratified sampling)
- **numpy**: Array operations and data manipulation
- **torch.nn**: Transformer and attention modules
- **mne**: EEG/MEG preprocessing (optional, for real data)
- **nilearn**: fMRI data handling (optional, for fMRI decoding)