Python SDK Quickstart

pip install nimbus-bci

pip install nimbus-bci[mne]

from nimbus_bci import Personalizer, wrap, BrainState
import nimbus_bci
print(f"nimbus-bci version: {nimbus_bci.__version__}")

from nimbus_bci import Personalizer, wrap
import numpy as np

np.random.seed(42)
n_samples, n_features = 100, 16
X_cal = np.random.randn(n_samples, n_features)
y_cal = np.random.randint(0, 2, n_samples)
X_test = np.random.randn(20, n_features)

# Toy identity encoder — replace with partner / foundation encode(X) → Z
enc = wrap(lambda X: X, model_id="demo-encoder", embedding_dim=n_features)
adapter = Personalizer.for_deployment(
    enc, ["left", "right"], paradigm="motor_imagery"
)
adapter.fit(X_cal, y_cal)
states = adapter.predict(X_test)  # list[BrainState]
print(states[0].intent, states[0].confidence, states[0].need_more_data)
adapter.save("subject_demo_profile")

from nimbus_bci import NimbusLDA, Personalizer
import numpy as np

np.random.seed(42)
n_samples, n_features = 100, 16
X_train = np.random.randn(n_samples, n_features)
y_train = np.random.randint(0, 4, n_samples)

clf = NimbusLDA()
clf.fit(X_train, y_train)

X_test = np.random.randn(20, n_features)
predictions = clf.predict(X_test)
probabilities = clf.predict_proba(X_test)

print(f"Predictions: {predictions}")
print(f"Probabilities shape: {probabilities.shape}")  # (20, 4)

# Same app surface without a trunk:
# p = Personalizer.for_features(["a", "b", "c", "d"]).fit(X_train, y_train)

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score
from nimbus_bci import NimbusLDA

pipe = make_pipeline(
    StandardScaler(),
    NimbusLDA(mu_scale=3.0),
)
pipe.fit(X_train, y_train)
predictions = pipe.predict(X_test)
scores = cross_val_score(pipe, X_train, y_train, cv=5)
print(f"CV Accuracy: {scores.mean():.2%} (+/- {scores.std():.2%})")

from nimbus_bci import NimbusLDA

clf = NimbusLDA()
clf.fit(X_train, y_train)

X_new = np.random.randn(10, n_features)
y_new = np.random.randint(0, 4, 10)
clf.partial_fit(X_new, y_new)

# Personalizer path
# adapter.adapt(X_lab, y_lab)           # preferred gateway
# adapter.partial_fit(X_lab, y_lab)     # head-only conjugate update
# dec = adapter.recommend_adapt(X_stream, tau=your_tau)
# if dec.should_adapt:
#     adapter.partial_fit(X_lab, y_lab)