Skip to main content Home Creators hiyenwong ai_collection computation-aware-kalman-neural-dynamics
computation-aware-kalman-neural-dynamics Computation-Aware Kalman Filtering with Model Selection for Neural Dynamics - solving scale-imbalanced neural data analysis
Jump to install Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/hiyenwong/ai_collection --skill computation-aware-kalman-neural-dynamicsThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... name computation-aware-kalman-neural-dynamics description Computation-Aware Kalman Filtering with Model Selection for Neural Dynamics - solving scale-imbalanced neural data analysis version 1 category neuroscience activation_keywords ["neural dynamics","Kalman filtering","Bayesian inference","model selection","uncertainty quantification","computational uncertainty","latent variable model","neural recording","state-space model"] created 2026-06-06T00:00:00.000Z paper_id arXiv:2606.01468 authors JR Huml, Jonathan Wenger, John P. Cunningham venue 2nd International Conference on Probabilistic Numerics (2026)
Computation-Aware Kalman Filtering with Model Selection for Neural Dynamics
Paper Summary
Problem: Modern neural datasets (single-cell recordings) are scale-imbalanced - fewer trials than recorded neurons. Bayesian methods model uncertainty well but scale poorly; deep networks scale well but lack uncertainty quantification.
Solution: Computation-Aware State-Space Model (CASSM) - extends computational uncertainty to model selection with novel training loss and optimization scheme.
Key Innovation: Tractable inference in large state-spaces while maintaining uncertainty calibration - competitive with data-hungry deep networks but with principled Bayesian framework.
Core Methodology
1. Scale-Imbalanced Regime
Definition: Number of trials << number of recorded neuronsChallenge: Standard Bayesian methods (Kalman) have O(n²) complexityExample: 50 trials, 1000 neurons → severe overfitting risk
2. Computation-Aware Framework
class CASSM :
"""
Computation-Aware State-Space Model for Neural Dynamics
Key Components:
1. Latent state dynamics: z_t = f(z_{t-1}) + noise
2. Observation model: y_t = g(z_t) + noise
3. Computational uncertainty: accounts for approximation error
4. Model selection: adaptive hyperparameter optimization
"""
def __init__ (self, n_neurons, n_trials, state_dim ):
self .scale_imbalanced = n_trials < n_neurons
self .state_dim = state_dim
self .computational_budget = estimate_complexity(n_neurons, state_dim)
def inference (self, observations ):
state_posterior, uncertainty = kalman_with_computational_error(
observations,
computational_budget=self .computational_budget
)
return state_posterior, uncertainty
3. Model Selection via Novel Training Loss
Objective: Balance predictive accuracy vs computational cost
Loss Function: L(θ) = -log p(y|θ) + λ·computational_error(θ)
Optimization: Gradient-based hyperparameter tuning
4. Uncertainty Calibration
Computational Uncertainty: Quantifies approximation error from finite computationTotal Uncertainty: Data uncertainty + computational uncertaintyBenefit: Better calibrated posteriors than standard methods
Key Findings
Performance Comparison Method Accuracy Uncertainty Calibration Scalability Standard Kalman Medium High Poor (O(n²)) Deep Networks High None Good CASSM High High Medium-Good
Synthetic Data Results
CASSM matches deep network accuracy
Significantly better uncertainty quantification
Robust to scale imbalance
Real Neural Data Results
Competitive with state-of-the-art
Well-calibrated confidence intervals
Model selection adapts to data properties
Practical Implementation
When to Use CASSM ✓ Scale-imbalanced regime (n_trials < n_neurons)
✓ Need uncertainty quantification (confidence intervals, hypothesis testing)
✓ Limited computational budget (need efficiency)
✓ Model selection uncertainty (hyperparameter tuning)
When NOT to Use ✗ Data-rich regime (n_trials >> n_neurons) - use standard methods
✗ No uncertainty needed - use simpler deep networks
✗ Small state dimension - computational error negligible
Implementation Steps
Data Assessment: Check if scale-imbalancedState Dimension Selection: Cross-validation or model selectionComputational Budget Estimation: Based on available resourcesTraining: Novel loss optimizationValidation: Check uncertainty calibration
Technical Details
State-Space Formulation
Latent Dynamics: z_t = A·z_{t-1} + w_t (Gaussian noise)Observations: y_t = C·z_t + v_tUnknowns: A, C, noise covariances, initial state
Computational Error Quantification
Source: Finite precision numerical integrationForm: Added variance term to posteriorEffect: Widens confidence intervals appropriately
Model Selection Mechanism
Hyperparameters: State dimension, noise levels, dynamics parametersTraining Loss: Prediction error + computational penaltyOptimization: Adam with adaptive learning rate
Comparison with Related Work
vs Standard Kalman Filtering
Advantage: Scales to large state spacesAdvantage: Model selection integratedDisadvantage: Additional computational overhead
vs Deep Networks (RNN/LSTM)
Advantage: Principled uncertaintyAdvantage: Interpretable latent dynamicsDisadvantage: Possibly lower predictive power in data-rich regime
vs Previous Bayesian Scaling Attempts
Advantage: Linear complexity (vs quadratic)Advantage: Model selection includedAdvantage: Better uncertainty calibration
Neuroscience Applications
Single-Cell Recording Analysis
Problem: 1000+ neurons, few behavioral trialsSolution: CASSM latent dynamics modelOutput: Neural trajectories with confidence bounds
Behavioral State Inference
Use Case: Infer latent cognitive states from neural activityBenefit: Well-calibrated state uncertaintyApplication: Decision-making, learning paradigms
Cross-Session Analysis
Challenge: Different neuron counts per sessionSolution: Adaptive model selectionResult: Consistent latent space across sessions
Code Implementation Tips
Python Framework import numpy as np
from scipy.linalg import block_diag
class ComputationAwareKalman :
def __init__ (self, n_neurons, state_dim, trials ):
self .n_neurons = n_neurons
self .state_dim = state_dim
self .trials = trials
self .scale_imbalanced = trials < n_neurons
def estimate_computational_budget (self ):
"""
Estimate computational cost for given state dimension
Returns: flops, memory requirements
"""
flops = self .state_dim**2 * self .trials
memory = self .state_dim * self .n_neurons
return flops, memory
def model_selection_loss (self, theta, data, lambda_comp=0.1 ):
"""
Novel training loss balancing prediction and computation
theta: model parameters
lambda_comp: computational penalty weight
"""
log_likelihood = self .compute_log_likelihood(theta, data)
comp_error = self .estimate_computational_error(theta)
loss = -log_likelihood + lambda_comp * comp_error
return loss
Validation Protocol
Accuracy Test: Predictive performance on held-out trialsUncertainty Calibration: Coverage probability of confidence intervalsScalability Test: Runtime vs state dimensionRobustness Test: Performance under scale imbalance
Key Insights for Researchers
Model Selection Guidance
Rule of Thumb: Start with state_dim = sqrt(n_trials)Cross-Validation: Use k-fold for hyperparameter tuningComputational Budget: Adjust λ_comp based on available resources
Uncertainty Interpretation
Data Uncertainty: From stochastic neural responsesComputational Uncertainty: From numerical approximationsTotal Uncertainty: Sum (or convolution) of both
Debugging Tips
Check: Scale imbalance condition (n_trials < n_neurons)Check: Computational budget vs state dimensionCheck: Uncertainty calibration on synthetic dataWarning: Over-regularization if λ_comp too large
Limitations and Caveats
Current Limitations
Assumes Gaussian noise (may not hold for spike data)
Linear dynamics (may miss nonlinear effects)
Computational overhead vs pure deep learning
Future Extensions
Nonlinear dynamics (via neural network transition model)
Spike-count observations (via Poisson observation model)
Real-time implementation (via streaming algorithms)
Research Roadmap
Immediate Applications
Apply to existing single-cell datasets
Compare with state-of-art deep networks
Validate uncertainty calibration
Methodological Extensions
Nonlinear state-space models
Non-Gaussian observations
Hierarchical models (multiple subjects)
Tool Development
Python package release
JAX implementation for GPU acceleration
Integration with existing neuroscience pipelines
References
Huml, Wenger, Cunningham (2026). "Computation-Aware Kalman Filtering with Model Selection for Neural Dynamics." arXiv:2606.01468
Cunningham & Byron (2014). "Dimensionality reduction for large-scale neural recordings"
Pandarinath et al (2018). "LFADS - Latent Factor Analysis via Dynamical Systems"
Linderman et al (2019). "Recurrent switching linear dynamical systems"
Summary for Quick Reference Core Idea: Bayesian neural dynamics modeling with computational uncertainty + model selection
Best Use Case: Scale-imbalanced neural data (few trials, many neurons)
Key Advantage: Principled uncertainty with modern scalability
Main Method: Computation-aware Kalman filtering + novel training loss
Validation: Competitive accuracy, superior uncertainty calibration
Activation Keywords: neural dynamics, Kalman filtering, Bayesian inference, model selection, uncertainty quantification, computational uncertainty, latent variable model, neural recording, state-space model
Related Skills: neural-population-dynamics, latent-dynamics-modeling, kalman-filtering-neural-data, bayesian-neural-modeling
More from this repository
Related occupations SOC
Based on SOC occupation classification
