Preview This is a draft of the public start-kit. Baseline numbers and dataset entries are placeholder values until the warm-up split opens on Jul 1, 2026.
K · search GitHub Register
Get started · 15 minutes from clone to leaderboard

Start-kit & baselines.

One pip install, one neuralbench command, one submission file. The start-kit ships the same evaluation harness the organizers use, every baseline reported on the leaderboard, and a deterministic toy split you can iterate on before the warm-up opens.

Python ≥ 3.10 PyTorch ≥ 2.2 CUDA optional BIDS-first MIT licensed
bash · install + smoke-test
1# 1. Install the start-kit
2$ pip install neuralbench[full]
3
4# 2. Run the toy split end-to-end
5$ neuralbench demo --track bci --model eegnet
6 ↳ trained · scored · submission.parquet written
Five steps · clone → submit

From a fresh clone to a leaderboard entry.

The path is identical for every track. Change the track flag, swap the model, and the rest of the pipeline stays the same.

First clone to first submission~ 15 minutes (toy split)
Full warm-up training run2 – 6 GPU-hours
Minimum hardwareCPU works · 8 GB GPU recommended
  1. Step 01 INSTALL

    Install neuralbench.

    ~ 60 seconds · pip

    pip install neuralbench[full] pulls in eegdash, braindecode, MNE, and the evaluator. Use [lite] if you only want the data loaders without the model zoo.

    Python≥ 3.10
    PyTorch≥ 2.2 (CUDA optional)
    Disk~ 4 GB for [full] extras
  2. Step 02 DATA

    Pull a track's warm-up split.

    ~ 5 minutes · streamed BIDS

    EEGDash streams the BIDS layout — only the recordings you reference are downloaded. The warm-up split for every track lives under ~/.cache/eegdash/ after the first call.

    Track 1 (EEG-to-IMG)14 GB
    Track 2 (BCI)2.3 GB
    Track 3 (Sleep)11 GB
    Track 4 (EMG)9 GB
  3. Step 03 TRAIN

    Train a baseline.

    2 – 6 GPU-hours · warm-up split

    Every track ships at least one baseline you can train with a single neuralbench train call. Configs are plain YAML — copy one, edit the model, keep the same data + scoring blocks.

    Default modelEEGNet · 0.4 M params
    OptimizerAdamW · cosine schedule
    SeedFixed by config
  4. Step 04 SCORE

    Score against the held-out split.

    ~ 1 minute · local

    The evaluator is the exact code we run on Codabench. Run it locally first — neuralbench score writes a submission.parquet with predictions, hyperparameters, and the git SHA of your model code for the audit phase.

    Metric (T1)Top-5 retrieval accuracy
    Metric (T2)Balanced accuracy
    Metric (T3)MAE on onset (s)
    Metric (T4)Character error rate
  5. Step 05 SUBMIT

    Upload to Codabench.

    ~ 30 seconds · web UI or API

    Drop the submission.parquet on the Codabench page for your track. Five submissions per team per day during the sealed phase. Final ranking is the best of your last five submissions.

    PlatformCodabench
    Daily cap (final phase)5 / team / day
    Audit at top-of-leaderboardReproducibility check
End-to-end Python · BCI track

A baseline from scratch, in twenty lines.

The same pattern works for every track: load with EEGDash, train with Braindecode, score with NeuralBench. Swap the dataset id and the model — the rest of the pipeline stays the same.

python · train_baseline.py
1from eegdash import EEGDashDataset
2from braindecode.models import EEGNetv4
3from neuralbench import Trainer, Evaluator
4
5ds = EEGDashDataset(track="bci", split="warmup")
6train, val = ds.split(by="subject", ratio="4:1")
7
8model = EEGNetv4(
9 n_chans=ds.n_chans,
10 n_classes=ds.n_classes,
11 input_window=2.0,
12)
13
14trainer = Trainer(model, epochs=100, lr=1e-3)
15trainer.fit(train, val)
16
17# Identical scoring to Codabench
18sub = Evaluator("bci").predict(model, ds.test)
19sub.to_parquet("submission.parquet")
bash · same flow, no Python file
1# Pull the BCI warm-up split
2$ neuralbench data bci --split warmup
3
4# Train the EEGNet baseline
5$ neuralbench train bci -m eegnet --epochs 100
6
7# Score and write submission file
8$ neuralbench score bci --out submission.parquet
9 ↳ bal. acc 0.586 · 20 subjects · 120 sessions
10
11# Reproduce a previous run from its config
12$ neuralbench replay configs/bci/eegnet.yaml
Baselines · what to beat placeholder scores

Each track ships at least one trained baseline.

Numbers below are the warm-up split — the public split you'll use for development. The sealed test set is held out by the organizers and only opens Aug 1, 2026.

Baselines releasedJul 1, 2026 (warm-up)
Hosted weightsHuggingFace · neural-interfaces26
LicenseMIT
Track Baseline model Family Params Train (GPU-h) Warm-up score Code Headroom
T1 · EEG-to-IMG EEGNet + DINOv2 head CNN 0.4 M 2.1 Top-5 28.1 configs/img/eegnet.yaml
T1 · EEG-to-IMG REVE (frozen) Foundation 52 M 0.6 (probe only) Top-5 71.4 configs/img/reve_frozen.yaml
T2 · BCI EEGNet-baseline CNN 0.4 M 0.9 Bal. Acc 58.6 configs/bci/eegnet.yaml
T2 · BCI EEGConformer Hybrid 1.2 M 1.8 Bal. Acc 62.4 configs/bci/conformer.yaml
T3 · Sleep EEGNet-sleep Sleep 0.4 M 3.4 MAE 143.3 s configs/sleep/eegnet.yaml
T3 · Sleep LaBraM (linear probe) Foundation 47 M 0.4 (probe only) MAE 134.9 s configs/sleep/labram_probe.yaml
T4 · EMG EMG2QwertyNet EMG 2.7 M 4.6 CER 25.1% configs/emg/qwerty.yaml
T5 · Foundation BIOT-large (shared encoder) Foundation 24 M 2.0 (per head) Mean rank 82.1 configs/foundation/biot.yaml
Headroom bar = baseline vs. best-known prior-work number on a comparable split See live leaderboard →
Submission format · same for every track

A single Parquet file. No Docker. No build step.

You don't upload code during the public phase — you upload predictions. Top entries are pulled for a reproducibility audit at test-freeze: we re-run your neuralbench replay against the sealed split. The submission file's schema is fixed and validated client-side before upload.

FormatApache Parquet · snappy
Max size200 MB / submission
Daily cap (final phase)5 / team / day
Final scoreBest of last 5 submissions
Column Type Per track Required Notes
trial_id string all yes Matches sealed-split index
prediction float[] / int / str all yes Embedding for T1, label for T2, seconds for T3, text for T4
confidence float T1, T2 optional Used for tie-breaking on equal accuracy
model_sha string (40 hex) all yes Git SHA of your model code · used for audit
hparams JSON string all yes Auto-filled by neuralbench score
Validate locally: neuralbench check submission.parquet Schema spec on GitHub →
Rules of the road

Compute, external data, and what counts as "your model".

Compute ALLOWED

Train on whatever you have.

There is no compute cap during training. The sealed-test inference budget is the only constraint — your scoring container must finish a full test pass in under 60 minutes on a single A100. AWS gives finalists complimentary instance hours; details land in the awards page.

Inference budget60 min · A100
No capon training
External data ALLOWED

Pretrain on anything public.

Public, redistributable datasets are fair game. Closed datasets and the sealed test split are not. Declare every external corpus you used in the 2-page methods note that ships with your final submission — the audit cross-checks this against your neuralbench replay.

OKOpenNeuro · MOABB · public BIDS
Not OKSealed test · private clinical
Reproducibility AUDITED

The top-of-board has to replay.

Top-3 per track go through a reproducibility audit on Oct 1, 2026. We re-run your training pipeline from the committed config, then score the resulting weights against the sealed test split. If the score is within tolerance of your submission, you stay on the board. If not, you drop.

Tolerance±2 σ on metric
Audit leadArnaud Delorme (EEGLAB)
Foundation track CONSTRAINT

One encoder, three tracks.

Track 5 requires a single shared EEG encoder reused across the EEG-to-IMG, BCI, and Sleep tracks. Heads can be track-specific. Encoders fine-tuned on the sealed test set or trained per-track separately are rejected at audit.

EncoderShared · frozen or fine-tuned
HeadsPer-track allowed
Warm-up opens Jul 1, 2026

Ready to run your first baseline?

Clone the start-kit, run the toy split, and you're on the leaderboard in fifteen minutes. Everything is MIT-licensed — fork freely, but please cite the white paper and the 2025 challenge that this work continues.

bash · clone & smoke-test
1$ git clone https://github.com/neural-interfaces26/neuralbench
2$ cd neuralbench
3$ pip install -e ".[full]"
4
5# 30-second sanity check
6$ neuralbench demo --track bci --toy