Overview

New here? The Block Index lists every one of our blocks in a single line, grouped as the palette groups them.

Beyond the general-purpose Custom Blocks, BCILattice injects a much larger set of advanced structural and research blocks covering graph control flow, cross-subject/cross-session domain adaptation, continual (domain-incremental) learning, and full PyTorch-style deep-learning training primitives. These are the blocks that let the ML Suite and Workflow Designer express arbitrary research pipelines — branching, looping, ensembling, adapting between subjects, and training deep models — without writing code.

Like the blocks in the Custom Blocks reference, these are marked is_custom: true and run as server-side routines rather than catalog classes/functions. Click a block on the canvas and use the Documentation link in its property panel to jump straight back to the matching section below.

The block family at a glance

Counting the everyday palette blocks alongside the advanced ones, BCILattice declares and maintains 149 app-owned blocks across 15 categories. These are distinct from the ~11,300 catalog entries introspected out of third-party libraries: an app-owned block is code this application writes, tests and ships.

core blocks are the everyday ones — where a graph in that area usually starts; advanced ones answer more specialised questions. Every block is in the palette either way (the palette is chosen by library, not by tier). The split is a design-time declaration, not a runtime guess. Four blocks are additionally marked community and two legacy; both are counted under “advanced” above.

Engines and plan gates

146 of the 149 run on both engines — the ML Flow canvas and the Workflow Designer. The three exceptions are workflow-only by design: Select Files, Model Set and Sub-Workflow describe how a workflow is assembled rather than what a pipeline computes. Model Collection runs on both, and itsModels port carries into either canvas's trainers the same way.

148 of the 149 are free on every plan. The single gated block is Custom Code, which executes arbitrary Python you supply. Domain adaptation, continual learning, federated averaging, conformal prediction, NAS and the RL trainers are not upsells — they ship to everyone.

Why the count is trustworthy

A block on the canvas is not one artefact, it is five, and they live in five different files:

1. a name constant
2. a schema, which defines its ports and settings
3. an executor branch that actually runs it
4. a palette row, so it can be placed at all
5. a test that runs it end to end

Nothing used to tie those five together, so a block could have four of them for months and still be impossible to place or impossible to run — which is exactly what happened to the eight Domain Adaptation blocks and the eight Domain Incremental ones, and independently to the DL Training optimizers, losses and schedulers.

Complex Structures

Graph control-flow blocks: branching, merging, splitting, ensembling and looping. Available in both the ML Suite and Workflow Designer canvases. Ports on the "n_inputs / n_outputs" family of blocks below (Data Merger, Ensemble Voter, Feature Concatenator, Model Selector, Stacking Assembler, Data Splitter, Parallel Fan-out, Multi-Head Output, Pipeline Switch, Metrics Bundle) are dynamic — changing the corresponding count setting adds or removes numbered ports (1–12) on the block.

Conditional Branch

Routes incoming data down one of two branches based on a condition evaluated against a value. Supports simple threshold/comparison modes as well as a free-form expression.

Settings

Data Splitter

Splits a single incoming array/dataset into 1–12 output splits by ratio, equal partition, or explicit index.

Settings

Data Merger

Combines 1–12 upstream data sources into one output using concatenation, stacking, or an elementwise reduction (mean/sum/max/min). The classic block for fusing multiple channels, sessions, or feature sets back into a single stream.

Settings

Ensemble Voter

Aggregates predictions from up to 12 models into one final prediction via majority vote, soft (probability-averaged) vote, weighted vote, or a stacking meta-combination. Also reports a confidence score.

Settings

Pipeline Switch

Routes data to one of up to 12 output routes based on a lookup of a config key against a case table — effectively a graph-level switch/case statement.

Settings

Parallel Fan-out

Duplicates a single input into up to 12 identical output copies so the same data can feed several independent downstream branches.

Settings

Feature Concatenator

Concatenates up to 12 feature vectors/arrays along a chosen axis, with an option to flatten every input first.

Settings

Stacking Assembler

Builds a stacked ensemble: trains a meta-learner on the out-of-fold predictions of up to 12 base models. Standard technique for squeezing extra accuracy out of several already-trained models.

Settings

Multi-Head Output

Splits a shared feature trunk into up to 12 independent output heads, each with its own hidden size and activation — for multi-task models (e.g. predicting class + confidence + subject ID together).

Settings

ForEach

Re-runs everything wired downstream of this block once per item in an incoming list (e.g. once per model in a Model Set, or once per hyperparameter combination). Each iteration binds item_var to the current item, so downstream blocks can reference it. Supports parallel workers, per-item timeouts, and stop-on-error or continue-on-error handling. Pair with ForEach Collect to rank the per-item results.

Settings

ForEach Collect

Collects the per-iteration outputs of a ForEach loop, ranks them by a chosen metric key, and surfaces the best result plus a full comparison table.

Settings

Workflow Structure

Workflow-only structural blocks for composing larger graphs out of existing experiments and already-published workflows.

Model Set

Selects one or more existing MLflow/Experiment Hub experiments and emits them as a list of items — designed to feed directly into a ForEach loop so you can, for example, run the same evaluation pipeline once per selected model.

Settings

Sub-Workflow

Embeds another workflow's compiled, published graph as a single reusable block. It always references the published snapshot — never the other workflow's live/in-progress canvas — so editing that other workflow later never silently changes a graph that already embeds it.

Settings

Domain Adaptation

Blocks for aligning data or models across subjects, sessions, or recording devices — the core problem in BCI transfer learning, where a model trained on one subject/session often degrades on another.

MMD Aligner

Minimizes Maximum Mean Discrepancy between source and target feature distributions in a kernel space, reducing the statistical gap between two subjects/sessions before training.

Settings

CORAL Adapter

Correlation Alignment: re-colors the source feature covariance to match the target's second-order statistics, a lightweight closed-form domain adaptation technique.

Settings

Transfer Component Analysis

Learns a shared low-dimensional projection where source and target distributions become similar, using kernel-based transfer components (TCA).

Settings

DANN Discriminator

Domain-Adversarial Neural Network discriminator: a gradient-reversal classifier trained to fail at telling source and target features apart, forcing the upstream feature extractor to learn domain-invariant representations.

Settings

Feature Alignment

Simple statistical feature alignment (z-score, whitening, centering, Procrustes, or affine) between source and target — a fast baseline before reaching for MMD/CORAL/DANN.

Settings

Subject Adaptation

Adapts a base model to a new subject using a small amount of that subject's calibration data, picking from several adaptation strategies (fine-tuning, DANN, TCA, Euclidean alignment, or CORAL).

Settings

Euclidean Alignment

Whitens trial covariance matrices toward a reference (mean/median/first trial), a fast and widely used EEG-specific alignment technique that requires no labels.

Settings

Session Transfer

Transfers features across recording sessions of the same or different subjects via reweighting, projection, normalization, or optimal transport, and outputs per-sample importance weights alongside the transferred features.

Settings

Domain Incremental Learning

Continual-learning blocks that let a model keep learning from new subjects/sessions/tasks over time without catastrophically forgetting what it already knew.

EWC Regularizer

Elastic Weight Consolidation: penalizes changes to parameters that were important for previous tasks, estimated via the Fisher information matrix, so the model resists forgetting while learning a new task.

Settings

Replay Buffer

Maintains a fixed-size memory of past examples (random, herding, exemplar, or gradient-based selection) that can be replayed alongside new data to reduce forgetting.

Settings

Task Manager

Maintains a set of per-domain/per-task output heads on top of a shared model and routes each sample to the right head, either from a known domain ID or inferred via entropy/prototype matching.

Settings

PackNet Freezer

Implements PackNet-style continual learning: prunes a fraction of a model's weights, retrains the pruned subnetwork on a new task, and freezes it, packing multiple tasks into disjoint weight subsets of one network.

Settings

Progressive Layers

Expands a base model with new units/layers for a new domain while freezing the original network and adding lateral connections back to it, following the Progressive Neural Networks approach.

Settings

Domain Drift Detector

Monitors incoming data for statistical drift relative to a reference distribution (MMD, KS-test, covariate shift, ADWIN, or Page-Hinkley), flagging when it's time to trigger adaptation or retraining.

Settings

DL Training

A full set of PyTorch-backed deep-learning primitives — optimizers, loss functions, LR schedulers, data loading, metrics, and a trainer block — so deep models can be assembled and trained entirely on the canvas.

Optimizers

Every optimizer block takes a Model input and produces an Optimizer output to wire into BCILattice Trainer.

Adam Optimizer

Adaptive moment estimation — maintains per-parameter running averages of the gradient and its square. The default choice for most DL Training pipelines.

Settings

AdamW Optimizer

Adam with decoupled weight decay — the decay term is applied directly to the weights instead of being folded into the gradient, which generalizes better for large models.

Settings

SGD Optimizer

Stochastic gradient descent with momentum and optional Nesterov acceleration. Slower to converge than Adam variants but often generalizes better on smaller EEG/fNIRS datasets.

Settings

RMSprop Optimizer

Divides the learning rate by a running average of recent gradient magnitudes. Well suited to recurrent/sequence models.

Settings

Adamax Optimizer

Adam variant based on the infinity norm, which is more stable with sparse gradients or embeddings.

Settings

NAdam Optimizer

Adam with Nesterov momentum baked into the moment update, often converging slightly faster than plain Adam.

Settings

Loss Functions

Loss blocks take no data inputs — they configure and emit a Loss Fn to wire into BCILattice Trainer.

CrossEntropy Loss

Standard multi-class classification loss; combines log-softmax and negative log-likelihood in one block.

Settings

BCE Loss

Binary cross-entropy for two-class problems, expects the model output already passed through a sigmoid.

Settings

BCEWithLogits Loss

Numerically stable binary cross-entropy that applies the sigmoid internally — use this instead of BCE Loss whenever the model outputs raw logits.

Settings

MSE Loss

Mean squared error for continuous-target regression tasks (e.g. predicting a continuous BCI control signal).

Settings

L1 Loss

Mean absolute error — less sensitive to outliers than MSE, at the cost of a non-smooth gradient at zero.

Settings

Huber Loss

Quadratic near zero and linear beyond a threshold — a robust middle ground between MSE and L1 for noisy regression targets.

Settings

NLL Loss

Negative log-likelihood loss for use when the model already outputs log-probabilities (e.g. after a manual log-softmax).

Settings

Focal Loss

Down-weights easy, well-classified examples so training focuses on hard/rare examples — useful for imbalanced class distributions common in BCI event detection.

Settings

LR Schedulers

Scheduler blocks wrap an incoming Optimizer and pass it through alongside the new Scheduler.

StepLR

Decays the learning rate by a fixed factor every N epochs.

Settings

CosineAnnealingLR

Smoothly anneals the learning rate along a cosine curve down to eta_min over T_max epochs.

Settings

ReduceLROnPlateau

Reduces the learning rate when a monitored metric stops improving — the standard choice when you do not know a good decay schedule in advance.

Settings

OneCycleLR

Ramps the learning rate up then back down within a single training run, often enabling faster convergence ("super-convergence").

Settings

ExponentialLR

Decays the learning rate by a constant multiplicative factor every epoch.

Settings

CyclicLR

Cycles the learning rate between a lower and upper bound, which can help escape saddle points during training.

Settings

CosineWarmRestarts

Cosine annealing with periodic warm restarts — the cycle length can grow by T_mult after each restart.

Settings

PyTorch DataLoader

Wraps a dataset in a PyTorch DataLoader with batching, shuffling, worker processes, and pinned memory — the standard entry point for feeding batched data into a deep-learning training run.

Settings

Train/Val Splitter

Splits a dataset into train and validation sets using a random, stratified, subject-wise, session-wise, or leave-one-subject-out policy — important for BCI data where naive random splits leak subject identity between train and val.

Settings

Metric Calculator

Turns predictions and true labels into numbers, on the canvas. Wire Predictions and True Labels (Evaluate Model emits both under those names) and it computes accuracy, F1, precision, recall and the confusion matrix — no metric blocks required. Wire Probabilities too and it adds ROC AUC and Log Loss, which are the only two metrics that need them. Everything lands on one Metrics port as a single {name: value} dict, so an Output Block wired to it reports every metric by name rather than one number, and the Execute page picks the whole set up whether or not you wire the output at all. For finer control, connect individual metric blocks, a Metrics Bundle or a Standard Metrics preset into any Metric N port and those are used instead.

Settings

Standard Metrics

The whole metric suite as one node. Pick a preset and wire its Metrics output into BCILattice Trainer's Metrics port — or into a Metric Calculator — instead of placing seven metric blocks and a Metrics Bundle every time. It emits exactly the configs those blocks would have, so nothing downstream can tell the difference; place the individual blocks when you need two different averages for two different metrics.

Settings

Metric Blocks

Each metric block takes no inputs and emits a single Metric output — aspecification of a metric, not the metric itself. Wire one into Metric Calculator to compute it on a set of predictions, or into BCILattice Trainer (directly, or via Metrics Bundle) to track it during training. If you just want the usual set, reach for Standard Metrics instead of placing all seven.

Accuracy Metric

Fraction of predictions that exactly match the true label. No configurable settings.

F1 Score Metric

Harmonic mean of precision and recall — a better single-number summary than accuracy for imbalanced classes.

Settings

Precision Metric

Of everything predicted positive, the fraction that was actually positive.

Settings

Recall Metric

Of everything actually positive, the fraction the model correctly found.

Settings

ROC AUC Metric

Area under the ROC curve — threshold-independent measure of separability between classes.

Settings

Confusion Matrix Metric

Full per-class prediction breakdown, optionally normalized and printed to the training log.

Settings

Log Loss Metric

Cross-entropy of the predicted class probabilities against the true labels — penalizes confident wrong predictions heavily.

Settings

R2 Score Metric

Regression. How much of the target's variance the model explains: 1 is perfect, 0 is no better than always predicting the mean, and it can go negative.

MAE Metric

Regression. Mean absolute error — the average distance between prediction and truth, in the target's own units.

MSE Metric

Regression. Mean squared error — like MAE but squares each error first, so large misses count much more.

RMSE Metric

Regression. Root mean squared error — MSE brought back to the target's units, so it reads like MAE but still punishes large misses.

Median AE Metric

Regression. Median absolute error — the typical miss, unaffected by a few very bad predictions.

MAPE Metric

Regression. Mean absolute percentage error — the average miss as a share of the true value. Misleading when true values are near zero.

Explained Variance Metric

Regression. Like R², but ignores a constant offset between prediction and truth — a biased model can score well here and worse on R².

Pearson Correlation Metric

Regression. Whether predictions rise and fall with the truth (−1 to 1), regardless of scale or offset. A high correlation can still come with large errors.

Metrics Bundle

Bundles 1–12 individual metric blocks into a single Metrics output for BCILattice Trainer, so multiple metrics (accuracy, F1, ROC AUC, …) can be tracked from one training run.

Settings

BCILattice Trainer

The plain supervised trainer, and the one to reach for. It covers both classical ML and deep learning behind one node: wire a Dataset, a Model and Labels, and it handles the split, the training loop and the evaluation. Leave Validation empty for one hold-out split; wire a Validation Scheme into it to cross-validate, or an Evaluation Protocol to choose which sessions or subjects train and which test. Other kinds of training (fine-tuning, DANN, contrastive, multi-task, incremental, distillation) are separate trainer blocks, listed below. Optimizer and loss default to 'auto' and are chosen from the model and task, so a working pipeline needs no optimizer/loss/dataloader wiring at all.

Settings

Dedicated trainers

Each kind of training has its own block, because each has a different training loop. They share the BCILattice Trainer’s settings (split, epochs, optimizer…) and add only their own. Fine-Tuning Trainer: Base Model + Frozen Layers. DANN Trainer: Source Dataset/Labels, unlabelled Target Dataset, optional Domain Discriminator. Contrastive Trainer: masked-signal or NT-Xent pretraining over View A / View B. Multi-Task Trainer: one encoder, weighted task heads. Class-Incremental, Domain-Incremental and Continual Learning Trainers: sequential training with replay / EWC. Distillation Trainer: Student Model trained on a frozen Teacher Model’s soft targets. Every one of them except the Contrastive Trainer takes an Evaluation Protocol on its Val/Eval input, so you choose which sessions or subjects train and which test — see Evaluation Protocol for what each trainer does with it.

Validation Scheme

How a trainer is validated, and the one way to cross-validate. Wire its Validation output into the BCILattice Trainer’s Val/Eval input: the trainer then trains and scores once per fold and reports mean ± confidence interval with out-of-fold predictions, instead of holding out one split. By default it also refits one final model on every row, so the trainer still hands a trained model to whatever follows. With strict_leakage_check on (the default), a non-grouped scheme over data spanning more than one subject or session STOPS the run with an actionable message rather than quietly reporting an inflated score. The Val/Eval input takes only this block or an Evaluation Protocol; a scikit-learn splitter or a bare number of folds is refused. Every run records its validation design (hold-out, cross-validation or protocol), and the Results page, the Leaderboard and Paired Statistics never mix runs validated differently.

Settings

Evaluation Protocol

Which data trains a model and which data tests it. Wire its Validation output into the BCILattice Trainer’s Val/Eval input (the same input a Validation Scheme uses). Train on Session 1 and test on Session 1 (a held-back part) and on every other session; train each session in turn and test on the others, so indoor → outdoor and outdoor → indoor both run; or train on fifteen named subjects and test on the other five. Several values named to train on are combined into one model; each in turn trains one model per value. As trained, a model is fitted on its training part and never sees a row of a part it is tested on; fine_tune adds a second, separately reported model that is given a labelled slice of it. Every dedicated trainer that scores against labels takes it too, each in its own way — the DANN Trainer adapts to each test session’s data without its labels and reports the unadapted score beside it; the Fine-Tuning Trainer fine-tunes on a labelled slice of each test session (target_size) and is scored on the rest, beside the score before fine-tuning; the Class-Incremental, Domain-Incremental and Continual Learning Trainers learn the sessions as a sequence in the order you name them and are scored on every session after every step; the Multi-Task and Distillation Trainers evaluate like the plain trainer. The Contrastive Trainer has no labels to score against and refuses it. The headline metric is the mean over the train → test pairs, which is the cross-session or cross-subject claim; within_accuracy is the same-part check beside it, and every pair gets its own row (‘Session 1 -> Session 2 accuracy’). A run whose jobs hold one session each stops and names the Select Files ‘Runs’ setting to change rather than switching it for you. It has no input: everything is set on its card. The same-session check (within_check) scores the model on trials of its own training session it never trained on — hold-out sets some aside, k-fold repeats that in rounds and averages. The card and the property panel show only the settings your choices use (train_values only when train_on is named, target_size only while fine_tune is on or a Fine-Tuning Trainer is wired, source_size only for source + target, check_before_transfer only for the Fine-Tuning or DANN Trainer) and the panel says under each one what it does. Set fine_tune (default none) to also fine-tune every pair. target only: the model is trained further on target_size (default 0.2) of the other session, with labels, and tested on the rest of it. source + target: it is trained further on source_size of its own training session together with target_size of the other session, so it does not forget its own session, and it is tested on the rest of the other session and on the trials of its own session it never trained on. Either way the score as trained stays beside it. Set direction to one pair (e.g. indoor -> outdoor) to run one way only; both ways is the default. A model that cannot train further (LDA, SVM and the other classical models) is trained again from zero instead: on its whole training session plus the slice for target only, on the two slices for source + target. Every model the protocol trains is kept under its own name for export, e.g. ‘CNN · trained on indoor’. The overlap guard is always on: overlapping samples refuse a row hold-out.

Settings

Nested CV

Cross-validation when you are also tuning hyperparameters. Choosing settings by looking at cross-validation scores and then reporting those same scores inflates the result. Nested CV runs two loops: the outer loop estimates performance, and inside each outer training fold an inner loop picks the hyperparameters — so no test fold ever influences the choice. The report also says whether the 'best' setting changed between outer folds, which tells you if it was ever a real property of the data.

Settings

Time-Resolved Decoder

When in the trial can the classes be told apart? Trains one decoder per time point of epoched data (sliding), or trains at each time point and tests at every other one (generalizing — a temporal-generalization matrix). Gives a decoding curve over time instead of one number, and can run a cluster permutation test to say which stretches of the curve are really above chance. Wire an Estimator, not a trainer: it cross-validates internally.

Settings

Pseudo Label

Turns a model's confident predictions on unlabelled trials into training labels — the core of semi-supervised learning. Wire Evaluate Model's Probabilities and Predictions in, and the selected trials come out on Pseudo Labels, ready for a second training pass (wire that back into a trainer and you have self-training). The port is deliberately not called Labels: scoring a model against its own pseudo-labels measures only its agreement with itself, and that wiring is refused.

Settings

Multiple Models

Every block for working with several models or runs side by side — training them together, keeping one, or telling them apart — in one palette category: Multiple Models (BCILattice), directly below Training. Start from the question you are asking:

Model Collection

Train several models on the same data in one run. A trainer's Model port takes one wire, so wire every model into Model 1, Model 2, … and the Models output into any trainer — BCILattice Trainer (with or without a Validation Scheme), a dedicated trainer, Nested CV. Each subject's recordings are loaded ONCE and every model trains on them, and each model gets its own results row (named '<workflow> · <model>') in the Training dashboard, the Experiment Hub, Results and Model Analysis — as if you had built one workflow per model.

Settings

Model Selector

Keep only the best one. Takes up to 12 candidate models plus one score per model on its Metric port, and passes on the winner (highest score, or lowest for a loss) as Best Model with its Best Score. Use it when the rest of the pipeline should continue with one model; use Model Collection alone when you just want to see every model's results.

Settings

Statistical Comparison

Is model A really better than model B, or is the gap noise? A pairwise significance test: McNemar's exact test for two models' predictions on the same trials, or a paired t-test / Wilcoxon signed-rank test for paired scores (per-fold or per-subject accuracy). 'auto' picks the right test from what is wired in.

Settings

Run Aggregator

Many runs in one table. Wire a ForEach's Output into Items, or up to eight trainers' Metrics into Metrics 1–8, and it reports mean ± confidence interval per group, a learning curve when the runs sweep a number (training-set size, seeds), and — once you name a baseline — paired differences with effect sizes and multiple-comparison-corrected p-values. Without a baseline it only describes; it never picks your control for you.

Settings

Decoding Curve Comparison

When in time do two decoding curves differ, and which one is higher? Two time-resolved curves can each beat chance and still be indistinguishable from each other, and comparing their peaks tests nothing. This runs a cluster-mass permutation test on the paired difference of two Time-Resolved Decoders' Fold Scores and reports the time windows where they genuinely differ.

Settings

Transfer Protocols & Model Reuse

For the everyday protocols — train on one session and test on the others, each session in turn, named subjects to train and test — use Evaluation Protocol on the trainer. These four blocks are for everything else, and make two things drawable rather than hard-coded: a transfer-learning protocol as wiring instead of a matrix of dropdowns (“train on 70% of session A, measure the drop on session B, fine-tune on a slice of B” is four edges, not a setting nobody anticipated), and bringing a model trained in an earlier run back onto a canvas — something no amount of wiring inside one run could ever do.

Split by Domain

Cuts data into two named partitions (A and B) along one axis: the recording's own provenance (session, subject, task, paradigm, dataset, quality) or the wired labels (class — whole categories held out, the cut a zero-shot or open-set protocol makes). The unit follows split_by: rows takes a FRACTION (0.3 = 30% to B, stratified on the labels if they're classes), everything else takes a COUNT of groups to hold out — 0.3 of a subject is not a thing, and the block refuses the wrong unit by name.

Settings

Evaluate Model

Scores an already-trained model on data it never saw, and never fits. The missing primitive for transfer-learning work: a trainer only ever reports on its own held-out split, so 'train on session A, measure the drop on session B' had no representation on the canvas at all before this block. Purely predict-and-score — a test asserts the wired model's parameters are unchanged after it runs.

Settings

Load Trained Model

Puts a model trained in an EARLIER run back on a canvas, weights and all. Within one run, reusing a trained model is a wire — drag the trainer's Trained Model output wherever it's needed. Across runs there was nothing: an autoencoder trained, saved and exported could not be got back onto a canvas at all. This rebuilds the architecture exactly as the original run did, applies the saved weights by node id, and reports — for every node, not just the ones that matched — whether it loaded.

Settings

Forward Pass

output = model(data) — the step every use of a loaded model needs, and the one no other block performs. Evaluate Model looks close but scores against ground truth, so it cannot be used where there are none: an autoencoder's latent codes, an encoder's embeddings, a frozen trunk's features for a new head, a saved classifier's raw outputs on a fresh recording. Framework-neutral: torch models are called, an sklearn-API estimator is asked for predict / transform / predict_proba — model(X) on a RandomForest raises, so auto resolves the right convention rather than assuming one.

Settings

Evaluation

Blocks that ask a harder question of a trained model than “what is its accuracy?” — would it work live, what did it use, and how should a ranking, a rejection or a reconstruction be scored.

Pseudo-Online Evaluator

Would this decoder work in a live session? Offline scores are optimistic: they are computed on epochs, so the decoder is told where each trial starts. This block slides a window over the continuous recording with no trial boundaries, matches confident outputs against the event markers, and reports false activations per minute, detection latency and information transfer rate (ITR). A 92% offline decoder that fires eleven times a minute at rest is not a 92% decoder.

Settings

Neuro Explainer

Which channels, frequency bands or time windows did the model rely on — drawn on a head. It groups feature importance by the feature names (so 'C3|beta' counts toward channel C3 and the beta band) and renders a topomap, a time course and a spectrum. For linear models it reports patterns, not raw weights: a large weight can belong to a channel that only cancels noise, and every output is labelled 'patterns' or 'filters' so a figure never says the wrong one.

Settings

Embed & Retrieve

For when the answer is a ranking, not a class: which of these 200 stimuli was the person looking at? Embeds each trial, ranks a candidate set (usually a Candidate Bank) by similarity, and reports top-1 / top-k accuracy, recall@k, median rank and mAP — each against the chance level of that particular bank, since top-5 out of 10 and top-5 out of 1,000 are very different claims.

Settings

Open-Set Scorer

Gives a classifier the option to answer 'none of these'. A normal classifier handed a class it never saw still picks one of the classes it knows, confidently and wrongly. This scores how familiar each trial looks (max softmax, energy, distance…), rejects the unfamiliar ones at a declared threshold, and reports how well known and unknown trials are separated (AUROC).

Settings

Reconstruction Evaluator

Scores a reconstructed stimulus — an image decoded from brain activity — against the real one: SSIM, PSNR and correlation, shown side by side. It also runs an identity check (is each reconstruction closer to its own stimulus than to the others?), because a blurry average image can score well on pixel metrics while recovering nothing specific to any trial.

Settings

Model Structure

Blocks that shape a model before it is trained. Model Concat and Model Add are in Custom Blocks.

Model Pipeline

Chains preprocessing steps and an estimator into ONE model (e.g. CSP → LDA), so cross-validation refits every step inside each fold. That matters for anything that learns from labels — a CSP filter fitted once on the whole recording has already seen the test trials, and the score is inflated. Wire the steps into Step 1, Step 2, … in order, with the estimator last.

Settings

Expression Layer

A small calculation inside a network, with no weights — for example torch.log1p(x), or reshaping between two layers. Chain it between layer blocks like any other layer. The expression is limited to array operations; it cannot run arbitrary code.

Settings

Neural Prefix Encoder

Brain-to-text. Learns to map neural features onto a few 'prefix' embeddings that a frozen language model reads before generating text. Only this mapping is trained; the language model is untouched. Every decode is reported beside two controls — the same model fed shuffled and zeroed brain features — because a language model generates fluent text from anything, and only the gap to the controls shows the brain signal mattered.

Settings

Neural Image Prefix

Brain-to-image. Learns to map neural features into the conditioning space of a frozen image decoder, which then draws the picture. Only the mapping is trained. Scored on pixel correlation, SSIM and CLIP score plus the identity check, always beside the shuffled- and zeroed-feature controls.

Settings

Data Adapters

Blocks that get data into the shape the next block needs, or bring in a set that is not one row per trial.

Epoching

Cuts continuous rows (one per recorded time point) into samples for a model, sized in the unit you think in: seconds, Hz or rows — one at a time. The same settings as Select Files' Samples, for data that reached a wire some other way (a filter step, a compiled pipeline's input). It refuses data that is already cut into samples, so nothing is epoched twice, and a sample never spans two recordings. Stacked samples come out as samples × channels × steps; feed Epoch Features for a classical model.

Settings

Epoch Features

Turns epoched data (trials × channels × time) into one row of features per trial, which is what classical classifiers need. Pick how: summary statistics per channel (mean, spread, range, RMS, roughness), the average over time, a few time windows, or everything flattened. Features are named by channel, so Neuro Explainer can later draw importance on a head. Trials are never mixed up or reordered.

Settings

Projection Adapter

Takes the images Signal Projection makes (trials × channels × size × size) and either keeps them as an image stack for a CNN, picks one channel's image, summarises each image into a few numbers, or flattens them into feature rows for a classical classifier.

Settings

Candidate Bank

Brings in a set of candidates — stimuli, sentences, images — that is NOT one row per trial: 200 candidate stimuli for 40 trials, say. That is what retrieval (Embed & Retrieve) and generation (Neural Prefix Encoder) score against. Every other input insists on one row per trial; this one is deliberately different, and marks its output so nothing downstream mistakes it for labels.

Settings

Advanced Training

Eight blocks for the situations an ordinary BCI session actually produces: not enough labelled trials, data that cannot leave its site, classes with no examples, and labels that disagree with each other. Every one of them reports its result against a floor — a chance level, a random baseline, a held-out split — because on a two-hundred-trial cohort a number without its floor is not a result.

Federated Averaging

Trains one shared model across several sites without pooling their rows: every site fits locally from the current global model, and the parameters are averaged (weighted by row count for FedAvg, unweighted for uniform, coordinate-wise median for Byzantine robustness). It only accepts models whose parameters are a vector space — a torch module's state_dict, or a linear estimator's coef_/intercept_ — and refuses a random forest by name, because the coordinate-wise mean of two forests' trees is not a model of anything. Always reports the centralised score on the pooled rows beside the federated one: the gap between them is the number a reader wants, and a federated score alone is unreadable. dp_noise_sigma adds Gaussian noise to the aggregate and is recorded as NOT a calibrated (ε, δ) guarantee.

Settings

Episode Sampler

Turns a labelled cohort into episodes: an n-way k-shot support set and a query set drawn from the same classes, disjoint by row. This is the unit every few-shot method is defined over, and Data Splitter cannot produce it — that block cuts by ratio and knows nothing about classes. The four data ports carry the FIRST episode, which is what a classifier downstream wants; the Episodes port carries every episode's row indices, which is what Meta-Learner wants. Support/query disjointness is asserted, not assumed.

Settings

Prototypical Adapter

Class prototypes in an embedding space and nearest-prototype classification of the query set (Snell et al., 2017). Non-parametric — no gradients, no training loop, no torch — which is what makes it the right first few-shot block. The Encoder port is optional: without one the features themselves are the embedding. Reports accuracy against BOTH floors (uniform 1/n and the query set's majority-class rate) plus a permutation null over shuffled support labels, because with k=5 a class prototype is one noisy point and beating 1/n on a single episode happens by luck often enough to matter.

Settings

Meta-Learner

Reptile (Nichol et al., 2018) or first-order MAML over the sampler's episodes: adapt on the support set, measure on the query set, and move the initial parameters toward what adaptation found. Both are the same loop with a different meta-update, and which ran is recorded in the provenance. Refuses a single episode — adapting to one task and reporting the result is fine-tuning, and labelling it meta-learning makes the number indistinguishable from a real meta-learned initialisation. Reports the adaptation gain, not only the final accuracy: an initialisation that adapts no better than the one it started from has not learned to learn. Needs PyTorch. Requires PyTorch — the block refuses with the install command when it is absent.

Settings

Zero-Shot Classifier

Predicts classes that have no training trial of their own, by describing them with a semantic vector instead of with examples. Learns a ridge compatibility map from neural features into the semantic space on the SEEN classes, then ranks every candidate — seen and unseen — for a query trial (the ESZSL / DeViSE family). Different from Embed & Retrieve, which ranks candidate items rather than classes. The unseen classes are declared explicitly and the block refuses when one of them appears in the training labels: that is ordinary classification under a zero-shot label, and it is the easiest such claim to make by accident. Seen and unseen accuracy are reported separately — a pooled 'generalised zero-shot' number is dominated by the seen classes.

Settings

Active Learning Sampler

Selects which unlabelled trials are worth a person's time. Pseudo Label's mirror — both consume the Probabilities port Evaluate Model already emits, and together they are the whole label-efficiency loop: confident rows become labels for free, uncertain rows become a labelling queue. Six strategies that genuinely disagree, including random, which is a real strategy because an honest comparison needs it. Every run computes the same selection statistics for a random batch of the same size; with Pool Labels wired (a simulation) it also reports the model's error rate on the selected rows against a random batch, which is the direct statement of whether the strategy found the hard trials.

Settings

Label Model

Combines several unreliable labellers into one probabilistic label. The situation is ordinary in a BCI lab and had no expression on the canvas: ground truth is not a column but several columns that disagree — a stimulus marker, a button press, a rater's annotation, a threshold rule over EMG, an earlier model. Custom Labels takes one column; Pseudo Label takes a model's own belief; neither combines sources. Dawid-Skene estimates a per-source confusion matrix and a class prior jointly with the labels, from the sources' agreement pattern alone. Abstention is first class — a labeller that fires on 12% of trials and is always right is more valuable than one that always fires and is right 70% of the time — and the best single source is reported as the floor.

Settings

Architecture Search

Searches depth, width, dropout, activation and learning rate, and reports the result honestly — which is the whole problem. A search that evaluates 40 architectures on one validation split and reports the best is reporting the maximum of 40 noisy estimates, biased upward by roughly their spread; it has found the architecture that got lucky, not a better one. So selection happens on an inner split and the reported number comes from rows neither the search nor the training touched (the Held-Out ports, or an outer split cut before the search begins), with the difference named selection_bias. It also reports the spread over its own candidates: a winner inside that spread means the search found sampling noise. Needs PyTorch. Requires PyTorch — the block refuses with the install command when it is absent.

Settings

Uncertainty & Causality

How sure the model is, whether that number can be believed, and what leads what. The first two turn a softmax into something a clinical decision can rest on; the third answers a question the symmetric connectivity metrics cannot ask, and is careful about what it does not claim.

Uncertainty Estimator

Per-row uncertainty, plus the calibration report that gives it meaning. A softmax output is a number between 0 and 1 that a reader treats as a probability, and on a small BCI cohort it is routinely 0.99 while being wrong a third of the time — so every run reports ECE, MCE, a reliability curve and the Brier score, and offers temperature scaling to fix what it finds. Three sources: a single model's Probabilities, an Ensemble of probability matrices, or Model + Data for MC-dropout (which refuses a network with no dropout layer, since that would report an epistemic variance of exactly zero). A sampled source separates aleatoric from epistemic uncertainty. Also reports the AUC with which the uncertainty ranks errors above correct rows — a calibration number can look fine while the uncertainty carries no information about which predictions are wrong.

Settings

Conformal Predictor

Split conformal prediction: a SET of classes with a finite-sample, distribution-free coverage guarantee. The only construct in the suite that can say 'the true class is in here 90% of the time' and mean it, which is what a clinical BCI decision needs and what a calibrated softmax still does not provide. Separate Calibration and Test ports and no single-port mode at all, because a guarantee fitted on the rows it is measured on is not a guarantee and on a canvas that mistake is one wire. Refuses a calibration set too small for the requested α — with n calibration points the smallest achievable miscoverage is 1/(n+1). Reports the empirical coverage beside the requested one; empty sets are repaired to their top-1 class and the repair is counted, never silent.

Settings

Causal Connectivity

Directed influence between channels — the question Channel Graph Builder's symmetric metrics cannot ask. Granger causality (an F-test between a restricted and an unrestricted autoregression), transfer entropy (model-free, so it catches nonlinear coupling Granger misses), or partial correlation as the symmetric control. The caveat is part of the output rather than a footnote: these are statements about PREDICTION, not intervention. A common driver, volume conduction, or one channel having a better signal-to-noise ratio all produce significant directed edges between channels with no causal relationship, and on scalp EEG all three are normal — so every run stamps interventional: false and the block will not print the word 'causes'. Every edge clears a time-shifted surrogate null with a Benjamini–Hochberg correction; an uncorrected matrix on 32 channels runs 992 tests and finds ~50 edges in noise.

Settings

Fusion, Flows & Rules

Three blocks that change the shape of the model rather than the data reaching it: combining modalities, replacing discrete depth with a continuous flow, and putting task knowledge back on top of the decoder.

Modality Fusion

Combines EEG with fNIRS (or any two to four modalities) honestly. Feature Concatenator puts two arrays side by side, which is a fusion strategy and not multi-modal learning — it answers none of the questions that make this hard: the modalities live on wildly different scales, they carry different amounts of information, and a concatenation dominated by the wider or louder one reports a 'multi-modal' result the other did not contribute to. So every run with Labels reports a cross-validated probe accuracy for EACH modality alone and for the fusion, plus the lift over the best single modality. On EEG + fNIRS the honest answer is frequently that one modality was carrying it. Row alignment is checked, never assumed: a mismatch means the modalities came from different epoching runs.

Settings

Neural ODE Block

Continuous depth: a learned vector field dh/dt = f(h, t) integrated over an interval, instead of a stack of residual layers. For neural time series the appeal is concrete — the hidden state evolves in continuous time, so irregular sampling and variable epoch lengths stop being a preprocessing problem. Fixed-step Euler, midpoint and RK4 in plain torch rather than against torchdiffeq, which keeps the determinism claim checkable and avoids a dependency for thirty lines of Runge–Kutta. Every run reports a solver-consistency number — the same field integrated again at double the step count — because an ODE with too few steps IS a residual network and the 'continuous' claim is decoration. It also reports how far the state travels: h(T) ≈ h(0) is an array of the right shape carrying the input unchanged. Needs PyTorch. Requires PyTorch — the block refuses with the install command when it is absent.

Settings

Rule Constraint Layer

Task knowledge as a symbolic layer over the decoder's probabilities. A BCI decoder does not emit predictions into a vacuum: a wheelchair cannot turn left immediately after turning right, a state must be held for a minimum dwell before it counts as intentional. This block decodes the most likely sequence the rules PERMIT — a constrained Viterbi over the whole sequence, not a filter over argmax, which is why it can repair a violation by changing an earlier prediction. Five rule forms, one per line: forbid A · forbid A after B · require A after B · min_dwell A n · max_run A n. Anything else is refused rather than ignored. Rows are read as consecutive time steps. Constraints can only lower the model's own likelihood; whether they raise accuracy is empirical, so with Labels wired the block reports accuracy before and after and splits the changes into corrections and new errors.

Settings

Graph Learning

The montage as a graph. Channels have a known neighbourhood structure — spatial and functional — and a dense layer has to rediscover it from the few hundred trials a BCI session provides.

Channel Graph Builder

An EEG cap is a graph, and every block in the suite treated it as a flat feature vector. This builds the channel × channel adjacency — from the data (correlation, magnitude-squared coherence, phase-locking value) or from the montage (Gaussian kernel over electrode distance) — sparsified by k-nearest-neighbour or a threshold. Useful on its own: the adjacency it emits is a connectivity matrix. Which metric is chosen decides what can be seen at all: zero-lag correlation is blind to a purely lagged coupling that coherence and PLV both find. The data-driven metrics are compared against a phase-randomised surrogate null, because a connectivity matrix on band-limited neural data has strong structure by construction and 'these channels are connected' is not a finding until it beats that.

Settings

Graph Neural Encoder

Symmetric-normalised graph convolution, Â = D^-½(A+I)D^-½ (Kipf & Welling), over a Channel Graph Builder adjacency. Two modes and the choice is deliberate: 'embeddings' propagates node features in pure numpy and needs no torch at all — propagation over the montage is a spatial filter and a perfectly good preprocessing step — while 'model' emits a trainable nn.Module whose adjacency is registered as a BUFFER, so a saved model still knows its montage. Reports the Dirichlet energy before and after: repeated convolution drives it to zero, at which point every node holds the same vector and the output is a constant of the right shape. The output rank is reported for the same reason.

Settings

Generative Models

Synthesising trials, for augmentation and class rebalancing. Neither block returns samples without the same three-part audit, because a generative model is the easiest thing in the suite to fool yourself with.

GAN Trainer

A conditional MLP generator and discriminator over trial features — synthesising trials for augmentation, class rebalancing and sample-efficiency questions. The other direction from Neural Prefix Encoder, which goes from neural activity to text. Samples never come back without the audit: nearest-neighbour distance to the real trials against the distance real trials sit from each other (a memorised generator produces beautiful samples and zero new information), a held-out classifier two-sample test where 0.5 means indistinguishable, and — with Labels — train-on-synthetic/test-on-real accuracy against train-on-real, which is the only number that says the samples are USEFUL rather than realistic-looking. Refuses fewer than 20 trials, where a GAN simply memorises. Needs PyTorch. Requires PyTorch — the block refuses with the install command when it is absent.

Settings

Diffusion Generator

DDPM over trial features: a noise schedule forward and a learned denoiser back. Slower to sample than a GAN and far more stable to train, which on a 200-trial cohort is usually the trade that matters. Conditional on the class when Labels are wired. Ships the same three-part audit as GAN Trainer — memorisation distance, classifier two-sample test, and train-on-synthetic/test-on-real utility — from the same shared implementation, because two copies of an audit drift and the drift always goes in the flattering direction. Requires PyTorch — the block refuses with the install command when it is absent.

Settings

Reinforcement Learning

The closed half of the loop: the decoder chooses, the user reacts, and the reaction is the training signal. The environment is a contextual bandit over the trial stream — the one a BCI lab has, rather than a simulator this application cannot honestly provide.

RL Agent Trainer

A BCI is a closed loop and the suite could only describe the open half. This learns online over the trial stream as a contextual bandit — deliberately the environment a BCI lab has, not a simulator: each row is a state, the agent picks an action, and the reward comes from the Rewards port (a real logged interaction) or is derived from the labels for a simulation. Three floors make the reward readable: the random policy's reward, the oracle's, and the agent's position between them. States are z-scored inside the block and the Q update is normalised-LMS, so learning_rate means a fraction of the step to the exact fit rather than something that depends on whether the features are microvolts or band-power ratios. Warns when the policy collapses to one action, which still beats random on an unbalanced stream.

Settings

Offline Policy Trainer

Learns a policy from LOGGED interactions with no ability to try anything new — the setting every retrospective BCI dataset is in. Behaviour cloning reproduces the logging policy and ignores the rewards, which is the honest baseline; conservative_q adds the CQL penalty that pushes down the value of actions the log never took in that state, which is the whole reason offline RL fails without it. The evaluation is the hard part: 'what would the new policy have earned' is an importance-weighted average whose variance explodes when the new policy disagrees with the logging one. So the block reports the effective sample size (Kish's, routinely single digits) and a bootstrap confidence interval beside the estimate, and declares the estimate unusable when it collapses. Without logged propensities it substitutes the empirical action frequency and says loudly that every off-policy number is then biased.

Settings

Multi-Agent Arena

Several policies acting on the same stream with an arbiter, and the question that makes it worth having: does the group beat its best member? Reports per-agent reward, the joint reward, the lift over the best single agent, and the mean pairwise agreement — because combining policies pays only when they make DIFFERENT mistakes, and agents that agree on 95% of steps are one policy with different seeds. The reward-weighted and best-agent arbiters judge on a recent window rather than the whole history, so they can notice an agent that became the good one halfway through the session.

Settings

Need a library that is not on this page? Extensions covers turning any Python package — Cedalion, or anything on the curated shelf — into blocks that wire into these same canvases.