mamba-spike-forecaster-bci

name: mamba-spike-forecaster-bci description: "Implicit Behavioral Decoding from Next-Step Spike Forecasts at Population Scale — using a single Mamba state-space model trained only on next-step spike counts (Neuropixels scale) to simultaneously forecast neural population activity and decode behavioral state via lightweight linear readout. arXiv: 2605.12999" tags: [bci, mamba, state-space-model, neural-decoding, spike-forecasting, neuropixels, behavioral-decoding, closed-loop] arxiv_id: "2605.12999" date: "2026-05-13"

Mamba Spike Forecaster for BCI Decoding

Paper Reference

Title: Implicit Behavioral Decoding from Next-Step Spike Forecasts at Population Scale Authors: John R. Minnick, Jesus Gonzalez-Ferrer, Kamran Hussain, Jinghui Geng, Ash Robbins, Mohammed A. Mostajo-Radji, David Haussler, Jason Eshraghian, Mircea Teodorescu arXiv: 2605.12999 (May 13, 2026) Categories: q-bio.NC, cs.LG Submitted to: NeurIPS 2026 Neuroscience & Cognitive Science Track

Abstract Summary

A single Mamba state-space model forecaster, trained only on next-step spike counts at Neuropixels scale, can simultaneously:

1. Forecast upcoming neural population activity
2. Decode behavioral state (mouse choice, stimulus side)

A lightweight per-session linear head reading the model's predicted rates outperforms the same linear classifier reading raw spike counts.

Key Results

Benchmark Performance (Steinmetz Visual Discrimination)

Performance vs Baseline

• 4-6 pp improvement over matched 500ms-context linear decoder on raw spikes
• Pipeline fits inside 50 ms bin budget on workstation GPUs
• 39 sessions, ~27,000 neurons, 1,994 held-out trials

Architecture

System Overview

┌─────────────────────────────────────────────────────────┐
│                   Mamba Forecaster                       │
│                                                           │
│  Input: Spike Counts (t-N ... t-1)                       │
│  ┌─────────────────────────────────────────────────┐     │
│  │  ┌───┐  ┌───┐  ┌───┐      ┌───┐               │     │
│  │  │t-N│→ │t-N│→ │t-N│→ ...→│t-1│               │     │
│  │  └───┘  └───┘  └───┘      └───┘               │     │
│  │       Mamba SSM Block (×L layers)               │     │
│  │  ┌─────────────────────────────────────────┐    │     │
│  │  │  State Space Model                       │    │     │
│  │  │  h_t = A·h_{t-1} + B·x_t                │    │     │
│  │  │  y_t = C·h_t + D·x_t                     │    │     │
│  │  │  + Selective scan (data-dependent A,B,C) │    │     │
│  │  └─────────────────────────────────────────┘    │     │
│  └─────────────────────────────────────────────────┘     │
│         │                                                 │
│         ▼                                                 │
│  ┌─────────────────────────────────────────────────┐     │
│  │  Output: Forecast spike rates (next time step)  │     │
│  └─────────────────────────────────────────────────┘     │
│         │                                                 │
│         ▼                                                 │
│  ┌─────────────────────────────────────────────────┐     │
│  │  Lightweight Linear Readout Head                │     │
│  │  (per-session, minimal parameters)              │     │
│  │  ┌───────────────────────────────────────┐      │     │
│  │  │  behav_pred = W · forecast_rates + b   │      │     │
│  │  └───────────────────────────────────────┘      │     │
│  └─────────────────────────────────────────────────┘     │
│         │                                                 │
│         ▼                                                 │
│  Output: Choice (left/right) + Stimulus Side              │
└─────────────────────────────────────────────────────────┘

Key Components

1. Mamba SSM (State Space Model)

The Mamba architecture uses:

• Data-dependent state transitions: A, B, C matrices vary per input token
• Selective scan algorithm: Efficient parallel computation
• Linear complexity: O(N) instead of O(N²) like transformers

class MambaBlock(nn.Module):
    def __init__(self, d_model, d_state, d_conv):
        super().__init__()
        self.d_model = d_model
        self.d_state = d_state
        self.conv1d = nn.Conv1d(d_model, d_model, d_conv, groups=d_model)
        self.x_proj = nn.Linear(d_model, d_state * 2 + d_model + d_model)
        self.dt_proj = nn.Linear(d_model, d_model)
        self.A_log = nn.Parameter(log_tensor(d_state, d_model))
        self.D = nn.Parameter(ones(d_model))
        
    def forward(self, x):
        # x: (batch, seq_len, d_model)
        # Selective scan: data-dependent A, B, C
        # ... (standard Mamba implementation)
        return y

2. Spike Forecasting Objective

def forecast_loss(predicted_rates, actual_spikes):
    """Training objective: predict next-step spike counts."""
    # Poisson negative log-likelihood
    loss = -sum(actual_spikes * log(predicted_rates) - predicted_rates)
    return loss

3. Linear Behavioral Readout

class BehavioralReadout(nn.Module):
    def __init__(self, n_neurons, n_classes):
        super().__init__()
        # Per-session linear head
        self.W = nn.Linear(n_neurons, n_classes)
    
    def forward(self, forecast_rates):
        # forecast_rates: (batch, n_neurons)
        logits = self.W(forecast_rates)
        return logits  # Cross-entropy loss for decoding

Training & Deployment Pipeline

Step 1: Data Preparation

def prepare_spike_data(spike_times, bin_width=50, n_bins_context=10):
    """
    Convert spike times to binned counts.
    bin_width=50ms (matching Neuropixels recording budget)
    """
    bins = np.arange(0, max(spike_times), bin_width)
    spike_counts, _ = np.histogram(spike_times, bins)
    # Context window: last n_bins_context bins
    context = spike_counts[-n_bins_context:]
    target = spike_counts[0]  # Next bin
    return context, target

Step 2: Mamba Forecaster Training

def train_mamba_forecaster(sessions_data, d_model=256, d_state=64, 
                            n_layers=4, learning_rate=1e-4):
    model = MambaForecaster(d_model, d_state, n_layers)
    optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)
    
    for epoch in range(num_epochs):
        for session in sessions_data:
            spike_counts = session['spike_counts']
            # Slide window prediction
            for t in range(context_len, len(spike_counts)):
                context = spike_counts[t-context_len:t]
                target = spike_counts[t]
                pred = model(context)
                loss = forecast_loss(pred, target)
                loss.backward()
                optimizer.step()
    return model

Step 3: Adaptive Calibration (Per-Session)

def calibrate_readout(model, session_start_data, n_calib_trials=150):
    """
    Calibrate linear readout with minimal trials.
    """
    # Freeze Mamba forecaster weights
    for param in model.mamba.parameters():
        param.requires_grad = False
    
    # Train only the linear readout head
    readout = BehavioralReadout(model.d_model, n_classes=2)
    optimizer = torch.optim.Adam(readout.parameters(), lr=1e-3)
    
    for trial in range(n_calib_trials):
        spike_context = session_start_data[trial]
        with torch.no_grad():
            forecast = model.mamba(spike_context)
        pred = readout(forecast)
        # Cross-entropy loss
        loss = F.cross_entropy(pred, session_start_data[trial]['label'])
        loss.backward()
        optimizer.step()
    
    return readout  # Within 1-2 pp of asymptote

Why This Works

Intuition

The Mamba forecaster learns the statistical structure of neural population dynamics. The predicted rates represent a denoised, temporally smoothed version of the neural activity that emphasizes behaviorally-relevant signal while suppressing noise.

Raw spikes:     | ▁▂▃▁▄▅▆▇▅▄▃▂▁ | ← Noisy
                |
Mamba forecast: | ▁▂▃▃▄▅▆▆▅▄▃▂▁ | ← Smooth + Denoised
                |   ↑ behavior    ↑
                |   relevant signal preserved

Benefits over Raw Spikes

Experimental Setup (Steinmetz Dataset)

• Task: Visual discrimination (left/right grating orientation)
• Recording: Neuropixels probes, multiple brain regions
• Animals: Mice (39 sessions)
• Neurons: ~27,000 total across sessions
• Trials: 1,994 held-out test trials
• Bin width: 50 ms
• Context: 500 ms (10 bins)

Applications

1. Closed-loop BCI: Real-time decoding with minimal calibration
2. Neural population forecasting: Predict upcoming activity patterns
3. Behavioral state monitoring: Continuous readout from neural data
4. Low-latency decoding: Suitable for real-time neuroprosthetics

Pitfalls & Considerations

• Per-session calibration: Still needs 100-150 trials per session
• GPU requirement: Workstation-class GPU needed for 50 ms budget
• Cross-session generalization: Linear readout is per-session
• Dataset specificity: Validated on visual discrimination; other behaviors may differ

Related Work

• Mamba (Gu & Dao, 2023): Original state space model architecture
• Steinmetz et al. (2019): Visual discrimination dataset
• Neuropixels: Large-scale neural recording technology

Activation Keywords

• Mamba neural decoding
• spike forecasting BCI
• implicit behavioral decoding
• Neuropixels Mamba
• state space model neuroscience
• Steinmetz benchmark
• closed-loop BCI Mamba
• neural population forecasting
• arXiv:2605.12999

References

• arXiv:2605.12999 — "Implicit Behavioral Decoding from Next-Step Spike Forecasts at Population Scale" (Minnick et al., 2026)
• Gu & Dao, "Mamba: Linear-Time Sequence Modeling with Selective State Spaces" (2023)
• Steinmetz et al., "Distributed coding of choice, action and engagement across the mouse brain" (Nature, 2019)