Probabilistic Model Specification

NimbusSDK provides pre-built probabilistic models powered by RxInfer.jl, a reactive message passing framework for efficient Bayesian inference. In the Python SDK these models are also the heads behind Personalizer(head=...) — see Personalizer & Middleware.

Nimbus Models Available:

NimbusLDA - Fast, shared covariance (Python + Julia); default Personalizer(head="lda")
NimbusQDA - Flexible, class-specific covariances (Python + Julia); Personalizer(head="qda")
NimbusSoftmax - Non-Gaussian static model (Python only); Personalizer(head="softmax")
NimbusProbit - Non-Gaussian static model (Julia only)
NimbusSTS - Stateful adaptive model (Python only; classical / streaming path)

For detailed implementation, see the individual model pages above.

Start Here

Personalizer & Middleware

Python product path: frozen trunk → Bayesian head → BrainState.

Bayesian LDA

Default Personalizer head (head="lda") and fast classical baseline.

Bayesian QDA

Class-specific covariance; Personalizer(head="qda").

Bayesian STS

Adaptive stateful modeling for non-stationarity.

Model Architecture

The static models (LDA, QDA, Softmax, Probit) are built on factor graphs with reactive message passing:

        Prior               Likelihood            Posterior
    p(class)  ────────────────────────────────►  p(class|data)
                          ▲
                          │
                      p(data|class)
                   (Gaussian or Softmax)

Factor Graphs

Factor graphs represent the joint probability distribution:

p(\text{class}, \text{data}) = p(\text{class}) \cdot p(\text{data}|\text{class})

Components:

Prior: $p(\text{class})$ - uniform or learned class probabilities
Likelihood: $p(\text{data}|\text{class})$ - Gaussian (LDA/QDA) or a non-Gaussian classifier (Softmax/Probit)
Posterior: $p(\text{class}|\text{data})$ - computed via message passing

Reactive Message Passing

RxInfer.jl uses reactive programming for efficient inference:

Data Stream ──► Factor Graph ──► Message Passing ──► Posterior Updates
                     │
                     ▼
              (Incremental Updates)

Benefits:

Incremental processing: Process data chunks as they arrive
Low latency: 10-25ms per chunk
Memory efficient: Constant memory usage
Real-time capable: Streaming inference without buffering

Model Comparison

Feature	NimbusLDA	NimbusQDA	NimbusSoftmax (Py)	NimbusSTS (Py)
Covariance	Shared across classes	Class-specific	N/A (logistic)	N/A (state-space)
Decision Boundary	Linear	Quadratic	Non-linear (flexible)	Dynamic (time-varying)
Temporal Model	Static	Static	Static	Stateful (EKF)
Flexibility	Lower	Higher	Highest	Adaptive
Speed	Fastest (10-15ms)	Fast (15-25ms)	Fast (15-25ms)	Real-time (20-30ms)
Best For	Motor imagery, stationary	P300, overlapping classes	Complex multinomial	Non-stationary, long sessions
State Management	None	None	None	`propagate_state()`, `get_latent_state()`
Online Learning	`partial_fit()`	`partial_fit()`	`partial_fit()`	Continuous with delayed feedback
Use Case	Short sessions	Short sessions	Short sessions	Long sessions, cross-day, adaptive BCI
Training Time	Fast	Moderate	Moderate
Parameters	Fewer (efficient)	More (flexible)	Most (very flexible)
Best For	Well-separated classes	Overlapping distributions	Complex multinomial tasks
Overfitting Risk	Lowest	Moderate	Higher (more parameters)
Data Requirements	40+ trials/class	60+ trials/class	80+ trials/class

BCI Paradigm Applications

Motor Imagery

Recommended Model: Bayesian LDA (NimbusLDA) Motor imagery classes are typically well-separated in CSP feature space, making NimbusLDA ideal:

2-class (left/right hand): 75-90% accuracy
4-class (hands/feet/tongue): 70-85% accuracy
Inference: 10-15ms per trial
ITR: 15-25 bits/minute

Why NimbusLDA?

Fast inference for real-time control
Shared covariance assumption holds well
Lowest data requirements

See Basic Examples - Motor Imagery for implementation. Recommended Model: Bayesian QDA (NimbusQDA) P300 target and non-target ERPs have overlapping distributions, requiring flexible modeling:

Binary detection: 85-95% accuracy (with averaging)
Inference: 15-25ms per epoch
ITR: 10-20 bits/minute

Why NimbusQDA?

Class-specific covariances capture ERP morphology
Better for overlapping distributions
Handles individual differences

See Basic Examples - P300 Detection for implementation.

SSVEP (Steady-State Visual Evoked Potential)

Recommended Model: NimbusLDA or NimbusQDA

4-target: 85-95% accuracy, use NimbusLDA
6+ target: 80-90% accuracy, use NimbusQDA
Inference: 10-20ms per trial
ITR: 30-50 bits/minute

Model Selection:

NimbusLDA: For 2-4 targets with well-separated frequencies
NimbusQDA: For 6+ targets with overlapping harmonics

See Advanced Applications for deployment patterns and model-combination guidance.

Paradigm Comparison

Paradigm	Recommended Model	Typical Accuracy	ITR	User Training
Motor Imagery	NimbusLDA (or NimbusSTS for long sessions)	70-85% (4-class)	15-25 bits/min	High
P300	NimbusQDA	85-95% (with reps)	10-20 bits/min	Low
SSVEP	NimbusLDA / NimbusQDA	85-95% (4-class)	30-50 bits/min	Low
Long-duration Adaptive	NimbusSTS (Py)	75-90% (maintains over time)	Varies	Medium

New: Use NimbusSTS (Python-only) for sessions >30 minutes or when you observe accuracy degradation over time. It’s the only model that explicitly handles temporal drift and non-stationarity.

Advanced Techniques

Hyperparameter Optimization

Use grid search or Bayesian optimization to find optimal hyperparameters:

Python
Julia

from sklearn.model_selection import GridSearchCV
from nimbus_bci import NimbusLDA

param_grid = {
    'mu_scale': [1.0, 3.0, 5.0, 7.0],
    'class_prior_alpha': [0.5, 1.0, 2.0]
}

grid = GridSearchCV(NimbusLDA(), param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)

print(f"Best params: {grid.best_params_}")
best_clf = grid.best_estimator_

# Grid search over hyperparameters
mean_prior_precisions = [0.001, 0.01, 0.05, 0.1]
best_accuracy = 0.0
best_params = nothing

for mean_prior_precision in mean_prior_precisions
    model = train_model(
        NimbusLDA,
        train_data;
        mean_prior_precision=mean_prior_precision
    )
    results = predict_batch(model, val_data)
    accuracy = sum(results.predictions .== val_data.labels) / length(val_data.labels)
    
    if accuracy > best_accuracy
        best_accuracy = accuracy
        best_params = (mean_prior_precision=mean_prior_precision,)
    end
end

See Python SDK - sklearn Integration for more tuning examples.

Cross-Subject Transfer Learning

Train on multiple subjects for better generalization:

from nimbus_bci import NimbusLDA, estimate_normalization_params, apply_normalization
import numpy as np

# Collect data from multiple subjects
all_X = [load_subject_data(s) for s in subjects]
X_combined = np.vstack(all_X)

# Normalize across subjects
norm_params = estimate_normalization_params(X_combined, method="zscore")
X_norm = apply_normalization(X_combined, norm_params)

# Train with higher regularization
clf = NimbusLDA(mu_scale=7.0)  # Higher than single-subject
clf.fit(X_norm, y_combined)

# Calibrate for new subject
clf.partial_fit(X_new_subject[:20], y_new[:20])

Ensemble Methods

Combine multiple models for improved robustness:

from nimbus_bci import NimbusLDA, NimbusQDA
import numpy as np

# Train multiple models
clf_lda = NimbusLDA()
clf_lda.fit(X_train, y_train)

clf_qda = NimbusQDA()
clf_qda.fit(X_train, y_train)

# Ensemble prediction (weighted average)
probs_lda = clf_lda.predict_proba(X_test)
probs_qda = clf_qda.predict_proba(X_test)

ensemble_probs = 0.6 * probs_lda + 0.4 * probs_qda
ensemble_predictions = ensemble_probs.argmax(axis=1)

Confidence Calibration

Ensure predicted probabilities match actual accuracy:

from sklearn.calibration import CalibratedClassifierCV
from nimbus_bci import NimbusLDA, compute_calibration_metrics

# Train and calibrate
clf = NimbusLDA()
clf.fit(X_train, y_train)

clf_calibrated = CalibratedClassifierCV(clf, method='isotonic', cv='prefit')
clf_calibrated.fit(X_val, y_val)

# Check calibration improvement
calib_metrics = compute_calibration_metrics(preds, confidences, y_test)
print(f"ECE: {calib_metrics.ece:.3f}")

Model Limitations

General Limitations:

Static models: No built-in temporal dynamics (use preprocessing for temporal features)
Supervised only: Require labeled training data
Fixed structure: Cannot modify factor graph structure at runtime

Model-Specific:

NimbusLDA: Assumes Gaussian distributions with shared covariance, linear decision boundaries
NimbusQDA: Assumes Gaussian distributions with class-specific covariances, higher overfitting risk with limited data
NimbusSoftmax / NimbusProbit: May require more training data than LDA/QDA for complex tasks

Troubleshooting

Model Overfitting

Symptoms: High training accuracy, low test accuracySolutions:

Increase mu_scale (stronger regularization)
Use cross-validation for hyperparameter tuning
Collect more training data
Apply ensemble methods

Poor Cross-Subject Generalization

Symptoms: Good within-subject, poor across-subject performanceSolutions:

Train on multi-subject data
Increase regularization (mu_scale)
Normalize features consistently
Use subject-specific calibration

Class Imbalance

Symptoms: Model biased toward majority classSolutions:

Use class weighting
Apply SMOTE or other resampling
Adjust decision threshold
Use stratified cross-validation

Next Read

NimbusLDA

Fast, shared covariance classifier

NimbusQDA

Flexible, class-specific covariances

NimbusSTS (Python)

Adaptive, for non-stationary data

NimbusSoftmax (Python)

Non-Gaussian static classification

NimbusProbit (Julia)

Non-Gaussian static classification

Basic Examples

Compact Python and Julia recipes

Advanced Applications

Calibration, adaptation, hybrid systems

Development Philosophy: Nimbus provides battle-tested, production-ready models (NimbusLDA, NimbusQDA, NimbusSoftmax (Py), NimbusProbit (Jl), NimbusSTS (Py)) that are proven effective for BCI applications. These models cover the majority of BCI use cases with fast inference, uncertainty quantification, and online learning. NimbusSTS adds adaptive capabilities for non-stationary data and long-duration sessions.

Getting started

Personalizer

Python SDK

Inference & pipelines

Heads & models

Concepts

Julia SDK

Cloud API

Examples

Model Specification

Probabilistic Model Specification

Start Here

Personalizer & Middleware

Bayesian LDA

Bayesian QDA

Bayesian STS

Model Architecture

Factor Graphs

Reactive Message Passing

Model Comparison

BCI Paradigm Applications

Motor Imagery

SSVEP (Steady-State Visual Evoked Potential)

Paradigm Comparison

Advanced Techniques

Hyperparameter Optimization

Cross-Subject Transfer Learning

Ensemble Methods

Confidence Calibration

Model Limitations

Troubleshooting

Next Read

NimbusLDA

NimbusQDA

NimbusSTS (Python)

NimbusSoftmax (Python)

NimbusProbit (Julia)

Basic Examples

Advanced Applications

​Probabilistic Model Specification

​Start Here

Personalizer & Middleware

Bayesian LDA

Bayesian QDA

Bayesian STS

​Model Architecture

​Factor Graphs

​Reactive Message Passing

​Model Comparison

​BCI Paradigm Applications

​Motor Imagery

​P300 Event-Related Potential

​SSVEP (Steady-State Visual Evoked Potential)

​Paradigm Comparison

​Advanced Techniques

​Hyperparameter Optimization

​Cross-Subject Transfer Learning

​Ensemble Methods

​Confidence Calibration

​Model Limitations

​Troubleshooting

​Next Read

NimbusLDA

NimbusQDA

NimbusSTS (Python)

NimbusSoftmax (Python)

NimbusProbit (Julia)

Basic Examples

Advanced Applications

Probabilistic Model Specification

Start Here

Model Architecture

Factor Graphs

Reactive Message Passing

Model Comparison

BCI Paradigm Applications

Motor Imagery

P300 Event-Related Potential

SSVEP (Steady-State Visual Evoked Potential)

Paradigm Comparison

Advanced Techniques

Hyperparameter Optimization

Cross-Subject Transfer Learning

Ensemble Methods

Confidence Calibration

Model Limitations

Troubleshooting

Next Read