Advanced Applications

Advanced BCI patterns without duplicating full SDK walkthroughs. Use this as an implementation checklist, then follow the linked guides for exact APIs.

Frozen-encoder personalization: Personalizer. Python streaming / sklearn: Python Streaming Inference, sklearn Integration. Julia streaming: Julia Streaming Inference.

Under deployment stress on a frozen trunk, prefer Personalizer + small labeled calibration over full fine-tuning. Classical cross-subject / multi-session recipes still apply to feature pipelines and standalone heads.

Cross-subject training

Combine calibration data from multiple users, then personalize to a new user with a small labeled set. When a frozen trunk already transfers, prefer Personalizer + per-user calibration over full fine-tuning. Core workflow:

Extract the same feature type (or freeze the same encoder) for every subject.
Normalize using training subjects only.
Train a conservative baseline (Personalizer(head="lda") or NimbusLDA).
Evaluate with subject-wise splits, not random trial splits.
Personalize with a small calibration set for the target subject.

Python
Julia

from nimbus_bci import Personalizer, wrap, estimate_normalization_params, apply_normalization
from sklearn.model_selection import LeaveOneGroupOut

# Frozen trunk path — same encoder for all subjects
enc = wrap(model.encode, model_id="shared-trunk", embedding_dim=64)

X, y, groups = load_multi_subject_features()  # or embeddings from enc
logo = LeaveOneGroupOut()

for train_idx, test_idx in logo.split(X, y, groups):
    norm = estimate_normalization_params(X[train_idx], method="zscore")
    X_train = apply_normalization(X[train_idx], norm)
    X_test = apply_normalization(X[test_idx], norm)

    adapter = Personalizer(
        encoder=None,  # features/embeddings already prepared
        head="lda",
        classes=["left", "right"],
        preset="research",
    )
    adapter.fit(X_train, y[train_idx])
    states = adapter.predict(X_test)
    # score from labels when available; gate on states[*].confidence in apps

using NimbusSDK

features, labels, subject_ids = load_multi_subject_features()

for subject in unique(subject_ids)
    train_mask = subject_ids .!= subject
    test_mask = subject_ids .== subject

    norm = estimate_normalization_params(features[:, :, train_mask]; method=:zscore)
    train_features = apply_normalization(features[:, :, train_mask], norm)
    test_features = apply_normalization(features[:, :, test_mask], norm)

    train_data = BCIData(train_features, metadata, labels[train_mask])
    model = train_model(NimbusLDA, train_data; iterations=50)
    results = predict_batch(model, BCIData(test_features, metadata, labels[test_mask]))
end

Hybrid BCI

Hybrid BCIs combine evidence from multiple paradigms, such as motor imagery plus P300. Recommended pattern:

Keep one Personalizer / head per paradigm (or one frozen trunk + head).
Normalize each feature family separately.
Combine posterior probabilities or confidence-weighted decisions.
Log disagreement between paradigms for later review.

mi_states = mi_adapter.predict(mi_features)
p300_states = p300_adapter.predict(p300_features)

# Or combine head posteriors for research fusion
mi_proba = mi_adapter.head.predict_proba(mi_features)
p300_proba = p300_adapter.head.predict_proba(p300_features)
combined = 0.6 * mi_proba + 0.4 * p300_proba

Use conservative thresholds for high-stakes actions and require confirmation when paradigms disagree. App gates: BrainState.

Continuous control

Continuous control maps repeated predictions into a smoothed command stream.

alpha = 0.3
smoothed = None

for state in brain_state_stream:  # or posterior_stream from a head
    command = posterior_to_velocity(state.posterior)
    smoothed = command if smoothed is None else alpha * command + (1 - alpha) * smoothed
    if not state.rejected:
        send_control(smoothed)

Keep smoothing outside the classifier. The model reports uncertainty; the control layer decides how aggressively to act.

Adaptive learning

Adaptation is useful when signal distributions drift during long sessions or across days.

Signal	Pattern
Which trials to label	Active Learning / `CalibrationSession`
Whether to stream-update	`Personalizer.recommend_adapt(..., tau=...)` then `partial_fit`
Trial accept / reject	`BrainState.rejected` / `need_more_data`
Non-stationary state	`NimbusSTS` / `StreamingSessionSTS`

dec = adapter.recommend_adapt(X_stream, tau=your_tau)
if dec.should_adapt:
    adapter.partial_fit(X_lab, y_lab)

states = adapter.predict(X_eval)
# optional: state.extras.update(dec.to_extras())

See Personalizer overview for adapt vs trial gates, and Active Learning for label selection.

Multi-session experiments

For experiments that span days or weeks:

Use a stable preprocessing / encoder pipeline and save its parameters (model_id, embedding_dim).
Save normalization parameters with each trained profile (Personalizer.save / head artifacts).
Track hardware, montage, impedance, session time, and participant state.
Evaluate same-session and cross-session performance separately.
Compare adaptation against a no-adaptation baseline.

Suggested metadata to log:

{
  "subject_id": "S001",
  "session_id": "2026-04-25-AM",
  "paradigm": "motor_imagery",
  "model_id": "partner-encoder",
  "head": "lda",
  "feature_type": "embedding",
  "normalization": "zscore",
  "sampling_rate": 250
}

Robust deployment

Production systems should separate personalization, control, and safety policy:

Personalizer returns BrainState (intent, posterior, confidence, gates).
Quality gate accepts, rejects, or asks for more data (need_more_data).
Control layer maps accepted intents to actions.
Monitoring logs confidence, latency, rejection rate, and drift.

for state in adapter.predict(X_online):
    if state.rejected or state.need_more_data:
        reject_or_ask_more(state)
    elif state.confidence >= 0.9:
        execute(state.intent)
    elif state.confidence >= 0.7:
        request_confirmation(state.intent)
    else:
        reject_or_ask_more(state)

For detailed safeguards, see Error Handling and BrainState.

Next read

Personalizer

Encoder contract, adapt helper, BrainState

Basic Examples

Compact starter recipes

Active Learning

Label-efficient calibration

Streaming configuration

Chunking and aggregation decisions

Getting started

Personalizer

Python SDK

Inference & pipelines

Heads & models

Concepts

Julia SDK

Cloud API

Examples

Advanced Applications

Cross-subject training

Hybrid BCI

Continuous control

Adaptive learning

Multi-session experiments

Robust deployment

Next read

Personalizer

Basic Examples

Active Learning

Streaming configuration

​Cross-subject training

​Hybrid BCI

​Continuous control

​Adaptive learning

​Multi-session experiments

​Robust deployment

​Next read

Personalizer

Basic Examples

Active Learning

Streaming configuration

Cross-subject training

Hybrid BCI

Continuous control

Adaptive learning

Multi-session experiments

Robust deployment

Next read