Release SenuaLab patient-independent EEG IED models v1.0.0

Five reviewed checkpoints, safetensors, aggregate vEpiSet results, provenance, hashes, and EEGAnnotationTool model pack. No private hospital data.

MANIFEST.json

@@ -0,0 +1,247 @@
+{
+  "files": [
+    {
+      "bytes": 1069,
+      "path": "eegannotationtool/senua_eegdino_medium/manifest.json",
+      "sha256": "c73c5997c96a0f7b46ad885348f443b82a8a078b59a6731d8664750563660d47"
+    },
+    {
+      "bytes": 137840831,
+      "path": "eegannotationtool/senua_eegdino_medium/model.pth",
+      "sha256": "e80ee1f66edcac1059b6e68c7458d8aa171167fbc9d50495daaafdc20e358491"
+    },
+    {
+      "bytes": 2712,
+      "path": "eegannotationtool/senua_eegdino_medium/model.py",
+      "sha256": "1bda5a0ee0fc8e58835eec379294659a02f804cf37a3227d056807553f3a497a"
+    },
+    {
+      "bytes": 2040,
+      "path": "eegannotationtool/senua_eegdino_medium/preprocessing.py",
+      "sha256": "1b39acec0d87439763009017a60614dda25a0605241c2563c8d1cf2c0c45ca44"
+    },
+    {
+      "bytes": 1062,
+      "path": "eegannotationtool/senua_eegpt/manifest.json",
+      "sha256": "aaa71a18f34e62ab9a0fc7dac718b23b0508d730bc93ce61921a7b1d68cc90a0"
+    },
+    {
+      "bytes": 102394167,
+      "path": "eegannotationtool/senua_eegpt/model.pth",
+      "sha256": "9a0a55ed656049b4109d0e923ee0d461151a8a793995a24438717efecd2f24d5"
+    },
+    {
+      "bytes": 4422,
+      "path": "eegannotationtool/senua_eegpt/model.py",
+      "sha256": "ed238c01a7c275f4ccc5315af11a2fc1694b497843f120bfa5a40d9f560c7a7f"
+    },
+    {
+      "bytes": 2040,
+      "path": "eegannotationtool/senua_eegpt/preprocessing.py",
+      "sha256": "1b39acec0d87439763009017a60614dda25a0605241c2563c8d1cf2c0c45ca44"
+    },
+    {
+      "bytes": 1073,
+      "path": "eegannotationtool/senua_eegpt_linear_probe/manifest.json",
+      "sha256": "8c7474f782ef8089fe03eb307b61d9c324c79e4ec979245bd1fab898a6617dff"
+    },
+    {
+      "bytes": 101312967,
+      "path": "eegannotationtool/senua_eegpt_linear_probe/model.pth",
+      "sha256": "a51fd32505d51d80677ed6504b94d0b8a6718cb1de21a07cd3253ed1e1a3405a"
+    },
+    {
+      "bytes": 2681,
+      "path": "eegannotationtool/senua_eegpt_linear_probe/model.py",
+      "sha256": "e788f854165481d594b5727a3c080e76a52286113cdcab0057a305ff451dc5f9"
+    },
+    {
+      "bytes": 2040,
+      "path": "eegannotationtool/senua_eegpt_linear_probe/preprocessing.py",
+      "sha256": "1b39acec0d87439763009017a60614dda25a0605241c2563c8d1cf2c0c45ca44"
+    },
+    {
+      "bytes": 1074,
+      "path": "eegannotationtool/senua_iednet_lite/manifest.json",
+      "sha256": "9dabb0feb431ff763b804c0435363ad443351177e58355c4399e7572f10b7cfe"
+    },
+    {
+      "bytes": 1041083,
+      "path": "eegannotationtool/senua_iednet_lite/model.pth",
+      "sha256": "383fe1de4aa8cf01b5f1c0a6734d92214ec0e7f96a6cd18a50fa52c52ccb210c"
+    },
+    {
+      "bytes": 4388,
+      "path": "eegannotationtool/senua_iednet_lite/model.py",
+      "sha256": "1a221ee13a67fb51cf26915e049a2eccfc4250d1df1adb150e312d6c677feab0"
+    },
+    {
+      "bytes": 2040,
+      "path": "eegannotationtool/senua_iednet_lite/preprocessing.py",
+      "sha256": "1b39acec0d87439763009017a60614dda25a0605241c2563c8d1cf2c0c45ca44"
+    },
+    {
+      "bytes": 1079,
+      "path": "eegannotationtool/senua_resnet_attention/manifest.json",
+      "sha256": "a1ef046db3b2edcd752d1b93e0a540508b620f1d1a4b6f76cb20d2a64cac1784"
+    },
+    {
+      "bytes": 20037039,
+      "path": "eegannotationtool/senua_resnet_attention/model.pth",
+      "sha256": "df088c4fd087b453ef3aca76f54a975a69f015324f8d862d2d4ba5316cb91e1a"
+    },
+    {
+      "bytes": 24358,
+      "path": "eegannotationtool/senua_resnet_attention/model.py",
+      "sha256": "f3be755ac6c0e3b95e1f48db9fe7af0df88aeda5f36d7d7d793fdf51c6355290"
+    },
+    {
+      "bytes": 2040,
+      "path": "eegannotationtool/senua_resnet_attention/preprocessing.py",
+      "sha256": "1b39acec0d87439763009017a60614dda25a0605241c2563c8d1cf2c0c45ca44"
+    },
+    {
+      "bytes": 627,
+      "path": "ensembles/ensemble.json",
+      "sha256": "793881c7515f44ae70e77a1ba599f606c15b0fbd551318fbf6e4ea5b18a7ebf2"
+    },
+    {
+      "bytes": 1390,
+      "path": "ensembles/ensemble_4model.json",
+      "sha256": "e44924fde4bc43d8cd9305f2a8a0e1727c0164a31d8e1ca494c5af55b90eba74"
+    },
+    {
+      "bytes": 1425,
+      "path": "ensembles/ensemble_eegdino.json",
+      "sha256": "0d2f9c2d9ac605423d47a9739ea9466cfd19544553ab233db34d0db09cc57172"
+    },
+    {
+      "bytes": 1326,
+      "path": "ensembles/ensemble_eegpt.json",
+      "sha256": "813ac3a4bcfa50c6c4ae81a79ac8faec9ae2e8dc5bfdab454a98572fd5698dd9"
+    },
+    {
+      "bytes": 1646,
+      "path": "MODEL_LICENSE.md",
+      "sha256": "747884c797383451a74c7444148d0fd1182245960aca48582df35f758a8c3831"
+    },
+    {
+      "bytes": 3165,
+      "path": "models/eegdino_medium/config.json",
+      "sha256": "e53ddd10b026440bed401b4b1c3468aaf9b43e4e5f9074655cf56389848a66f2"
+    },
+    {
+      "bytes": 137804848,
+      "path": "models/eegdino_medium/model.safetensors",
+      "sha256": "72320fedeed09b66508afaa79ce0ca114273673f6ce36adccedce87c8ce0ea1d"
+    },
+    {
+      "bytes": 2811,
+      "path": "models/eegpt/config.json",
+      "sha256": "fd8db52c30918c858c1924edfeb513388685e00cc662d920b027d8900f04e1d7"
+    },
+    {
+      "bytes": 102373540,
+      "path": "models/eegpt/model.safetensors",
+      "sha256": "e91757b80c98dd7325ea1068bff9dfe72bac577195f5b25b2570ce4d9f357226"
+    },
+    {
+      "bytes": 2824,
+      "path": "models/eegpt_linear_probe/config.json",
+      "sha256": "267732d264b787020c3e2b4285e56798bf644e8a26876645e31cff0ad273b2e7"
+    },
+    {
+      "bytes": 101295352,
+      "path": "models/eegpt_linear_probe/model.safetensors",
+      "sha256": "24ec011a90388079df98322244b96e076eeebf6b0671fe987a7d0d5cf66f9579"
+    },
+    {
+      "bytes": 2019,
+      "path": "models/iednet_lite/config.json",
+      "sha256": "9fc65e9684a39fe22ea8660bd56526319965704d5968c66309be350d6b743b38"
+    },
+    {
+      "bytes": 1014056,
+      "path": "models/iednet_lite/model.safetensors",
+      "sha256": "7c5dc3c8e40050b69a07a7cf6a1ce7bbd2b12347f1b50d7feaf1fdfdd108b082"
+    },
+    {
+      "bytes": 2030,
+      "path": "models/resnet_attention/config.json",
+      "sha256": "d85aa13650584b0c0489dc2aaec89b4007d2aa61cf25ff55ad73cca621fac651"
+    },
+    {
+      "bytes": 20011088,
+      "path": "models/resnet_attention/model.safetensors",
+      "sha256": "971fa0d2b38f0cc76ca479931872ae957123aeb51263de59b11098be1531b1e1"
+    },
+    {
+      "bytes": 3165,
+      "path": "pytorch/eegdino_medium/config.json",
+      "sha256": "e53ddd10b026440bed401b4b1c3468aaf9b43e4e5f9074655cf56389848a66f2"
+    },
+    {
+      "bytes": 137840831,
+      "path": "pytorch/eegdino_medium/model.pth",
+      "sha256": "e80ee1f66edcac1059b6e68c7458d8aa171167fbc9d50495daaafdc20e358491"
+    },
+    {
+      "bytes": 2811,
+      "path": "pytorch/eegpt/config.json",
+      "sha256": "fd8db52c30918c858c1924edfeb513388685e00cc662d920b027d8900f04e1d7"
+    },
+    {
+      "bytes": 102394167,
+      "path": "pytorch/eegpt/model.pth",
+      "sha256": "9a0a55ed656049b4109d0e923ee0d461151a8a793995a24438717efecd2f24d5"
+    },
+    {
+      "bytes": 2824,
+      "path": "pytorch/eegpt_linear_probe/config.json",
+      "sha256": "267732d264b787020c3e2b4285e56798bf644e8a26876645e31cff0ad273b2e7"
+    },
+    {
+      "bytes": 101312967,
+      "path": "pytorch/eegpt_linear_probe/model.pth",
+      "sha256": "a51fd32505d51d80677ed6504b94d0b8a6718cb1de21a07cd3253ed1e1a3405a"
+    },
+    {
+      "bytes": 2019,
+      "path": "pytorch/iednet_lite/config.json",
+      "sha256": "9fc65e9684a39fe22ea8660bd56526319965704d5968c66309be350d6b743b38"
+    },
+    {
+      "bytes": 1041083,
+      "path": "pytorch/iednet_lite/model.pth",
+      "sha256": "383fe1de4aa8cf01b5f1c0a6734d92214ec0e7f96a6cd18a50fa52c52ccb210c"
+    },
+    {
+      "bytes": 2030,
+      "path": "pytorch/resnet_attention/config.json",
+      "sha256": "d85aa13650584b0c0489dc2aaec89b4007d2aa61cf25ff55ad73cca621fac651"
+    },
+    {
+      "bytes": 20037039,
+      "path": "pytorch/resnet_attention/model.pth",
+      "sha256": "df088c4fd087b453ef3aca76f54a975a69f015324f8d862d2d4ba5316cb91e1a"
+    },
+    {
+      "bytes": 5952,
+      "path": "README.md",
+      "sha256": "f4b252478ceba9980edc00f5edcd7bb8550bb0e758a9a9f7274a4b2445b5077b"
+    },
+    {
+      "bytes": 1839,
+      "path": "results/benchmark_results.csv",
+      "sha256": "4c09b55325f8571ce374aa274a6ed395a4fc69346e333ae1a884247cb5fa2f08"
+    },
+    {
+      "bytes": 76548,
+      "path": "results/model_comparison.png",
+      "sha256": "8af73e7c56b761565ec67badab0f456ed69ba0c9c88724b2e5c9d65c7d07e0d3"
+    }
+  ],
+  "privacy_review": "public vEpiSet metadata and aggregate results only; no hospital data",
+  "repository": "SenuaLab/EEG-IED-Detection",
+  "schema_version": 1
+}

MODEL_LICENSE.md

@@ -0,0 +1,37 @@
+# Model artifact terms and provenance
+
+There is no single license covering every artifact in this multi-model
+repository. The SenuaLab source repository is MIT licensed. vEpiSet is CC BY
+4.0. Upstream foundation-model code and checkpoints retain their respective
+terms.
+
+## From-scratch checkpoints
+
+`iednet_lite` and `resnet_attention` are SenuaLab architectures/checkpoints
+trained on vEpiSet. SenuaLab makes its contribution available under CC BY 4.0,
+with required attribution to SenuaLab and the vEpiSet publication.
+
+## EEGPT checkpoints
+
+`eegpt` and `eegpt_linear_probe` contain encoder parameters derived from
+`braindecode/eegpt-pretrained`. The original EEGPT code is Apache-2.0 and the
+curated Braindecode model card identifies BSD-3-Clause. SenuaLab's downstream
+head/configuration is made available under CC BY 4.0. Upstream notices and
+attribution must be retained.
+
+## EEG-DINO Medium checkpoint
+
+`eegdino_medium` contains encoder parameters derived from
+`braindecode/eegdino-medium-pretrained`. The curated model code is identified as
+BSD-3-Clause. SenuaLab's downstream task head and fine-tuning contribution are
+made available under CC BY 4.0. The upstream model card warns that pretraining
+corpus terms may add restrictions; users must independently verify eligibility,
+especially for commercial deployment.
+
+## No clinical warranty
+
+Artifacts are provided as-is for research and engineering evaluation. They are
+not medical devices, have no warranty of clinical fitness, and require expert
+review. These terms do not override applicable upstream licenses, dataset
+terms, law, institutional policy, or regulatory requirements.
+

README.md

@@ -0,0 +1,164 @@
+---
+license: other
+library_name: pytorch
+pipeline_tag: audio-classification
+tags:
+  - eeg
+  - epilepsy
+  - interictal-epileptiform-discharge
+  - neuroscience
+  - eegpt
+  - eeg-dino
+  - braindecode
+datasets:
+  - vEpiSet
+base_model:
+  - braindecode/eegpt-pretrained
+  - braindecode/eegdino-medium-pretrained
+---
+
+# SenuaLab EEG IED Detection
+
+Five patient-independent binary IED checkpoints, aggregate benchmark artifacts,
+and an app-ready model pack for
+[SenuaLab EEG Annotation Tool](https://github.com/SenuaLab/EEGAnnotationTool).
+Training and evaluation use only the public
+[vEpiSet](https://doi.org/10.6084/m9.figshare.28069568) dataset.
+
+> **Research use only.** These models are not medical devices and must not be
+> used as the sole basis for diagnosis or treatment. Every candidate requires
+> review by a qualified EEG professional against the original recording.
+
+> **Privacy.** No private hospital recording, patient identifier, physician
+> annotation, local path, or hospital-derived patient result is included. The
+> model parameters, public configuration metadata, and aggregate vEpiSet
+> results were reviewed before upload.
+
+Source, methodology, and reproducibility documentation:
+[github.com/SenuaLab/EEG-IED-Detection](https://github.com/SenuaLab/EEG-IED-Detection)
+
+## Models
+
+| Folder | Model | Params | Rate | Window | Test AUROC | Test AUPRC | Test F1 |
+|---|---|---:|---:|---:|---:|---:|---:|
+| `iednet_lite` | IEDNet-Lite | 0.25M | 250 Hz | 4 s | 0.8793 | 0.6848 | 0.6372 |
+| `resnet_attention` | ResNet-Attention | 4.99M | 250 Hz | 4 s | 0.8998 | 0.7018 | 0.6667 |
+| `eegpt` | EEGPT + temporal head | 25.59M | 250 Hz | 4 s | 0.8641 | 0.6532 | 0.6139 |
+| `eegpt_linear_probe` | EEGPT linear probe | 25.32M | 250 Hz | 4 s | 0.7519 | 0.3722 | 0.3227 |
+| `eegdino_medium` | EEG-DINO Medium | 34.45M | 200 Hz | 4 s | **0.9363** | **0.8020** | **0.7415** |
+
+All test thresholds were selected on validation subjects and then frozen. The
+test split contains 3,908 windows from 13 held-out vEpiSet subjects. Results are
+single-dataset, four-second window metrics, not prospective clinical claims.
+
+## Files
+
+```text
+models/<name>/
+├── model.safetensors     # tensor-only weights (preferred)
+└── config.json           # reviewed input/provenance/metric contract
+
+pytorch/<name>/
+├── model.pth             # sanitized checkpoint for the Python runner
+└── config.json
+
+eegannotationtool/senua_<name>/
+├── model.py              # executable architecture adapter
+├── preprocessing.py      # released preprocessing contract
+├── model.pth             # app-compatible sanitized checkpoint
+└── manifest.json
+
+ensembles/                # validation-selected ensemble definitions
+results/                  # aggregate benchmark table and figure
+MANIFEST.json             # SHA-256 and byte size for every release file
+```
+
+PyTorch `.pth` is included because the current EEG Annotation Tool model
+discovery contract supports `.pth/.pt/.ckpt`. Prefer `safetensors` elsewhere and
+load executable/model files only from this official repository.
+
+## Input contract
+
+- 19 standard 10-20 channels in this order:
+  `Fp1, Fp2, F3, F4, C3, C4, P3, P4, O1, O2, F7, F8, T3, T4, T5, T6, Fz, Cz, Pz`.
+- Four-second full windows.
+- Fourth-order zero-phase 1-45 Hz Butterworth band-pass.
+- Common-average reference across the 19 channels.
+- Resampling to the rate listed in the table.
+- One global z-score over the complete channel-time window, clipped to `[-8,8]`.
+- Binary output order: `[Non-IED, IED]`.
+
+Legacy temporal aliases T7/T8/P7/P8 map to T3/T4/T5/T6.
+
+## Download
+
+```bash
+hf download SenuaLab/EEG-IED-Detection \
+  pytorch/iednet_lite/model.pth \
+  --local-dir ./weights
+```
+
+Or from Python:
+
+```python
+from huggingface_hub import hf_hub_download
+
+path = hf_hub_download(
+    repo_id="SenuaLab/EEG-IED-Detection",
+    filename="pytorch/iednet_lite/model.pth",
+)
+```
+
+The source repository runner accepts model short names and handles the download:
+
+```bash
+python -m eeg_ied_detector.robust_predict \
+  --data-dir /path/to/brainvision-recordings \
+  --model-paths iednet_lite resnet_attention \
+  --output-dir ./predictions \
+  --no-label-comparison
+```
+
+EEGPT and EEG-DINO require `braindecode[hub]==1.6.1`.
+
+## EEG Annotation Tool
+
+Use the installer from the source repository:
+
+```bash
+python scripts/install_eeg_annotation_models.py \
+  --models iednet_lite resnet_attention
+```
+
+IED Finder discovers the installed folders, validates channels and the declared
+input contract, and uses the validation-selected threshold as its starting
+point. Foundation-model adapters are included but need Braindecode in the
+application's Python environment.
+
+## Evaluation limitations
+
+- One public dataset and one fixed internal held-out split.
+- No prospective, external multi-center, or medical-device validation.
+- Four-second window metrics do not equal continuous event-level sensitivity.
+- Performance can shift with montage, hardware, preprocessing, age, disease
+  mix, artifacts, prevalence, and annotation policy.
+- Threshold changes require a prospectively defined validation protocol and
+  must not use the final evaluation cohort.
+- Automated output is a review candidate, never a diagnosis.
+
+## Model and data provenance
+
+- vEpiSet: Lin et al., Scientific Data 12, 229 (2025),
+  https://doi.org/10.1038/s41597-025-04523-8, CC BY 4.0.
+- EEGPT: NeurIPS 2024, upstream code
+  [BINE022/EEGPT](https://github.com/BINE022/EEGPT), encoder checkpoint
+  [braindecode/eegpt-pretrained](https://huggingface.co/braindecode/eegpt-pretrained).
+- EEG-DINO: MICCAI 2025,
+  [paper](https://papers.miccai.org/miccai-2025/paper/3347_paper.pdf), encoder
+  checkpoint
+  [braindecode/eegdino-medium-pretrained](https://huggingface.co/braindecode/eegdino-medium-pretrained)
+  at revision `191f73eb50d68a184b4cabb623938df914235d3c`.
+
+See `MODEL_LICENSE.md` for the per-artifact licensing boundary and upstream
+conditions.
+

eegannotationtool/senua_eegdino_medium/manifest.json

@@ -0,0 +1,48 @@
+{
+  "finder_defaults": {
+    "pad_policy": "skip",
+    "step_ms": 500.0,
+    "threshold": 0.619140625
+  },
+  "important": "Research screening model; every candidate requires expert review. Threshold selected on public vEpiSet validation subjects.",
+  "input": {
+    "channel_aliases": {
+      "P7": "T5",
+      "P8": "T6",
+      "T7": "T3",
+      "T8": "T4"
+    },
+    "channel_names": [
+      "Fp1",
+      "Fp2",
+      "F3",
+      "F4",
+      "C3",
+      "C4",
+      "P3",
+      "P4",
+      "O1",
+      "O2",
+      "F7",
+      "F8",
+      "T3",
+      "T4",
+      "T5",
+      "T6",
+      "Fz",
+      "Cz",
+      "Pz"
+    ],
+    "input_samples": 800,
+    "normalization": "global four-second window z-score clipped to [-8,8]",
+    "reference": "common average",
+    "required_filters": [
+      "1-45 Hz zero-phase Butterworth"
+    ],
+    "sampling_rate_hz": 200.0,
+    "window_seconds": 4.0
+  },
+  "name": "SenuaLab eegdino_medium",
+  "schema_version": 1,
+  "source": "https://huggingface.co/SenuaLab/EEG-IED-Detection"
+}

eegannotationtool/senua_eegdino_medium/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e80ee1f66edcac1059b6e68c7458d8aa171167fbc9d50495daaafdc20e358491
+size 137840831

eegannotationtool/senua_eegdino_medium/model.py

@@ -0,0 +1,73 @@
+"""EEG Annotation Tool adapter for SenuaLab EEG-DINO Medium."""
+
+from __future__ import annotations
+
+try:
+    from braindecode.models import EEGDINO
+except ImportError as exc:
+    raise ImportError("This model requires braindecode[hub]==1.6.1") from exc
+
+from .preprocessing import INTERNATIONAL_10_20_CHANNELS, preprocess_batch as _preprocess
+
+
+MODEL_CHANNELS = INTERNATIONAL_10_20_CHANNELS
+MODEL_INPUT_SAMPLES = 800
+MODEL_SAMPLING_RATE_HZ = 200.0
+MODEL_WINDOW_SECONDS = 4.0
+MODEL_ENTRY_CLASS = "SenuaEEGDINOMedium"
+MODEL_NUM_CLASSES = 2
+MODEL_CLASS_LABELS = ["Non-IED", "IED"]
+MODEL_NON_IED_CLASS_INDEX = 0
+MODEL_IED_CLASS_INDICES = [1]
+MODEL_DESCRIPTION = "SenuaLab partially fine-tuned EEG-DINO Medium binary IED detector"
+MODEL_BATCH_PREPROCESSOR = "preprocess_batch"
+MODEL_REQUIRED_REFERENCE = "common average (applied by model adapter)"
+MODEL_REQUIRED_FILTERS = ["1-45 Hz zero-phase Butterworth (applied by model adapter)"]
+MODEL_REQUIRED_NORMALIZATION = "global four-second window z-score, clipped to [-8,8]"
+MODEL_INPUT_UNIT = "scale-invariant after window z-score"
+MODEL_SOURCE_SIGNAL_POLICY = "raw"
+MODEL_REQUIRES_FULL_WINDOW = True
+MODEL_REQUIRES_ALL_CHANNELS = True
+MODEL_DEFAULT_THRESHOLD = 0.619140625
+MODEL_DEFAULT_STEP_MS = 500.0
+MODEL_DEFAULT_PAD_POLICY = "skip"
+MODEL_DEFAULT_BATCH_SIZE = 8
+MODEL_DEFAULT_BATCH_MEMORY_MB = 384.0
+MODEL_VALIDATION_NOTE = "Threshold selected on vEpiSet validation subjects; requires Braindecode 1.6.1 and is not externally validated."
+MODEL_PREPROCESSING_NOTE = "The adapter applies the released 1-45 Hz, common-average, 200 Hz resampling, and global-window z-score pipeline."
+
+
+def preprocess_batch(batch, source_sfreq=None, channel_names=None):
+    return _preprocess(
+        batch,
+        source_sfreq=source_sfreq,
+        target_sfreq=200,
+        target_samples=800,
+        channel_names=channel_names,
+    )
+
+
+class SenuaEEGDINOMedium(EEGDINO):
+    def __init__(self, num_channels: int = 19, num_classes: int = 2, input_length: int = 800):
+        if num_channels != 19 or input_length != 800:
+            raise ValueError("SenuaEEGDINOMedium requires 19 channels and 800 samples")
+        super().__init__(
+            n_outputs=num_classes,
+            n_chans=19,
+            n_times=800,
+            sfreq=200,
+            patch_size=200,
+            n_layer=16,
+            nhead=8,
+            dim_feedforward=1024,
+            channels_kernel_stride_padding_norm=(
+                (64, 49, 25, 24, (8, 64)),
+                (128, 3, 1, 1, (8, 128)),
+                (64, 3, 1, 1, (8, 64)),
+            ),
+            n_channel_embeddings=19,
+            n_global_tokens=1,
+            global_token_layer=1,
+            drop_prob=0.1,
+        )
+

eegannotationtool/senua_eegdino_medium/preprocessing.py

@@ -0,0 +1,58 @@
+"""Exact four-second preprocessing used by the released SenuaLab models."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from scipy.signal import butter, resample, resample_poly, sosfiltfilt
+
+
+NUM_CHANNELS = 19
+INTERNATIONAL_10_20_CHANNELS = [
+    "Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
+    "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz",
+]
+DATASET_29_CHANNEL_ORDER = INTERNATIONAL_10_20_CHANNELS
+
+
+def normalize_sample(sample):
+    x = np.asarray(sample, dtype=np.float32)
+    mean = x.mean()
+    std = x.std()
+    return np.clip((x - mean) / max(float(std), 1e-7), -8.0, 8.0).astype(np.float32)
+
+
+def preprocess_batch(
+    batch,
+    *,
+    source_sfreq=None,
+    target_sfreq=250,
+    target_samples=1000,
+    channel_names=None,
+):
+    """Filter, average-reference, resample, and globally normalize `[B,C,T]`."""
+
+    del channel_names  # IED Finder has already arranged the declared channel order.
+    x = np.asarray(batch, dtype=np.float32)
+    if x.ndim == 2:
+        x = x[None]
+    if x.ndim != 3 or x.shape[1] != NUM_CHANNELS:
+        raise ValueError(f"Expected [batch,19,time], received {x.shape}")
+    sfreq = float(source_sfreq or target_sfreq)
+    if sfreq <= 90.0:
+        raise ValueError(f"Sampling rate must be above the 45 Hz cutoff; received {sfreq}")
+    sos = butter(4, [1.0, 45.0], btype="bandpass", fs=sfreq, output="sos")
+    x = sosfiltfilt(sos, x, axis=-1).astype(np.float32, copy=False)
+    x -= x.mean(axis=1, keepdims=True)
+    if not math.isclose(sfreq, float(target_sfreq)):
+        up = int(target_sfreq)
+        down = int(round(sfreq))
+        common = math.gcd(up, down)
+        x = resample_poly(x, up // common, down // common, axis=-1).astype(np.float32)
+    if x.shape[-1] != int(target_samples):
+        x = resample(x, int(target_samples), axis=-1).astype(np.float32)
+    mean = x.mean(axis=(1, 2), keepdims=True)
+    std = x.std(axis=(1, 2), keepdims=True)
+    return np.clip((x - mean) / np.maximum(std, 1e-7), -8.0, 8.0).astype(np.float32)
+

eegannotationtool/senua_eegpt/manifest.json

@@ -0,0 +1,48 @@
+{
+  "finder_defaults": {
+    "pad_policy": "skip",
+    "step_ms": 500.0,
+    "threshold": 0.8916015625
+  },
+  "important": "Research screening model; every candidate requires expert review. Threshold selected on public vEpiSet validation subjects.",
+  "input": {
+    "channel_aliases": {
+      "P7": "T5",
+      "P8": "T6",
+      "T7": "T3",
+      "T8": "T4"
+    },
+    "channel_names": [
+      "Fp1",
+      "Fp2",
+      "F3",
+      "F4",
+      "C3",
+      "C4",
+      "P3",
+      "P4",
+      "O1",
+      "O2",
+      "F7",
+      "F8",
+      "T3",
+      "T4",
+      "T5",
+      "T6",
+      "Fz",
+      "Cz",
+      "Pz"
+    ],
+    "input_samples": 1000,
+    "normalization": "global four-second window z-score clipped to [-8,8]",
+    "reference": "common average",
+    "required_filters": [
+      "1-45 Hz zero-phase Butterworth"
+    ],
+    "sampling_rate_hz": 250.0,
+    "window_seconds": 4.0
+  },
+  "name": "SenuaLab eegpt",
+  "schema_version": 1,
+  "source": "https://huggingface.co/SenuaLab/EEG-IED-Detection"
+}

eegannotationtool/senua_eegpt/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a0a55ed656049b4109d0e923ee0d461151a8a793995a24438717efecd2f24d5
+size 102394167

eegannotationtool/senua_eegpt/model.py

@@ -0,0 +1,116 @@
+"""EEG Annotation Tool adapter for the SenuaLab EEGPT temporal-head model."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import mne
+import torch
+from torch import nn
+
+try:
+    from braindecode.models import EEGPT
+except ImportError as exc:  # imported by EEG Annotation Tool during discovery
+    raise ImportError("This model requires braindecode[hub]==1.6.1") from exc
+
+from .preprocessing import INTERNATIONAL_10_20_CHANNELS, preprocess_batch as _preprocess
+
+
+EEGPT_CHANNELS = [
+    "Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
+    "F7", "F8", "T7", "T8", "P7", "P8", "Fz", "Cz", "Pz",
+]
+MODEL_CHANNELS = INTERNATIONAL_10_20_CHANNELS
+MODEL_CHANNEL_ALIASES = {"T3": "T7", "T4": "T8", "T5": "P7", "T6": "P8"}
+MODEL_INPUT_SAMPLES = 1000
+MODEL_SAMPLING_RATE_HZ = 250.0
+MODEL_WINDOW_SECONDS = 4.0
+MODEL_ENTRY_CLASS = "SenuaEEGPT"
+MODEL_NUM_CLASSES = 2
+MODEL_CLASS_LABELS = ["Non-IED", "IED"]
+MODEL_NON_IED_CLASS_INDEX = 0
+MODEL_IED_CLASS_INDICES = [1]
+MODEL_DESCRIPTION = "SenuaLab EEGPT encoder with an IED-specific temporal head"
+MODEL_BATCH_PREPROCESSOR = "preprocess_batch"
+MODEL_REQUIRED_REFERENCE = "common average (applied by model adapter)"
+MODEL_REQUIRED_FILTERS = ["1-45 Hz zero-phase Butterworth (applied by model adapter)"]
+MODEL_REQUIRED_NORMALIZATION = "global four-second window z-score, clipped to [-8,8]"
+MODEL_INPUT_UNIT = "scale-invariant after window z-score"
+MODEL_SOURCE_SIGNAL_POLICY = "raw"
+MODEL_REQUIRES_FULL_WINDOW = True
+MODEL_REQUIRES_ALL_CHANNELS = True
+MODEL_DEFAULT_THRESHOLD = 0.8916015625
+MODEL_DEFAULT_STEP_MS = 500.0
+MODEL_DEFAULT_PAD_POLICY = "skip"
+MODEL_DEFAULT_BATCH_SIZE = 16
+MODEL_DEFAULT_BATCH_MEMORY_MB = 256.0
+MODEL_VALIDATION_NOTE = "Threshold selected on vEpiSet validation subjects; requires Braindecode 1.6.1 and is not externally validated."
+MODEL_PREPROCESSING_NOTE = "The adapter applies the released 1-45 Hz, common-average, resampling, and global-window z-score pipeline."
+
+
+def preprocess_batch(batch, source_sfreq=None, channel_names=None):
+    return _preprocess(
+        batch,
+        source_sfreq=source_sfreq,
+        target_sfreq=250,
+        target_samples=1000,
+        channel_names=channel_names,
+    )
+
+
+def _chs_info() -> list[dict[str, Any]]:
+    info = mne.create_info(EEGPT_CHANNELS, sfreq=250.0, ch_types="eeg")
+    info.set_montage("standard_1020")
+    return info["chs"]
+
+
+class EEGPTIEDHead(nn.Module):
+    def __init__(self, hidden: int = 128, n_outputs: int = 2):
+        super().__init__()
+        flattened_embedding = 4 * 512
+        self.input_norm = nn.LayerNorm(flattened_embedding)
+        self.patch_projection = nn.Sequential(
+            nn.Linear(flattened_embedding, hidden), nn.GELU(), nn.Dropout(0.20)
+        )
+        self.temporal = nn.Sequential(
+            nn.Conv1d(hidden, hidden, 5, padding=2, groups=hidden, bias=False),
+            nn.BatchNorm1d(hidden),
+            nn.Conv1d(hidden, hidden, 1, bias=False),
+            nn.GELU(),
+            nn.Dropout(0.20),
+            nn.Conv1d(hidden, hidden, 3, padding=2, dilation=2, groups=hidden, bias=False),
+            nn.BatchNorm1d(hidden),
+            nn.Conv1d(hidden, hidden, 1, bias=False),
+            nn.GELU(),
+        )
+        self.attention = nn.Conv1d(hidden, 1, 1)
+        self.classifier = nn.Sequential(
+            nn.LayerNorm(hidden * 3), nn.Dropout(0.35), nn.Linear(hidden * 3, n_outputs)
+        )
+
+    def forward(self, z: torch.Tensor) -> torch.Tensor:
+        patches = self.input_norm(z.flatten(2))
+        patches = self.patch_projection(patches).transpose(1, 2)
+        patches = patches + self.temporal(patches)
+        weights = self.attention(patches).softmax(dim=-1)
+        pooled = torch.cat(
+            [(patches * weights).sum(-1), patches.mean(-1), patches.amax(-1)], dim=1
+        )
+        return self.classifier(pooled)
+
+
+class SenuaEEGPT(EEGPT):
+    def __init__(self, num_channels: int = 19, num_classes: int = 2, input_length: int = 1000):
+        if num_channels != 19 or input_length != 1000:
+            raise ValueError("SenuaEEGPT requires 19 channels and 1,000 samples")
+        super().__init__(
+            n_outputs=num_classes,
+            n_chans=19,
+            chs_info=_chs_info(),
+            n_times=1000,
+            sfreq=250.0,
+            chan_proj_type="none",
+            return_encoder_output=False,
+        )
+        self.final_layer = EEGPTIEDHead(n_outputs=num_classes)
+

eegannotationtool/senua_eegpt/preprocessing.py

@@ -0,0 +1,58 @@
+"""Exact four-second preprocessing used by the released SenuaLab models."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from scipy.signal import butter, resample, resample_poly, sosfiltfilt
+
+
+NUM_CHANNELS = 19
+INTERNATIONAL_10_20_CHANNELS = [
+    "Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
+    "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz",
+]
+DATASET_29_CHANNEL_ORDER = INTERNATIONAL_10_20_CHANNELS
+
+
+def normalize_sample(sample):
+    x = np.asarray(sample, dtype=np.float32)
+    mean = x.mean()
+    std = x.std()
+    return np.clip((x - mean) / max(float(std), 1e-7), -8.0, 8.0).astype(np.float32)
+
+
+def preprocess_batch(
+    batch,
+    *,
+    source_sfreq=None,
+    target_sfreq=250,
+    target_samples=1000,
+    channel_names=None,
+):
+    """Filter, average-reference, resample, and globally normalize `[B,C,T]`."""
+
+    del channel_names  # IED Finder has already arranged the declared channel order.
+    x = np.asarray(batch, dtype=np.float32)
+    if x.ndim == 2:
+        x = x[None]
+    if x.ndim != 3 or x.shape[1] != NUM_CHANNELS:
+        raise ValueError(f"Expected [batch,19,time], received {x.shape}")
+    sfreq = float(source_sfreq or target_sfreq)
+    if sfreq <= 90.0:
+        raise ValueError(f"Sampling rate must be above the 45 Hz cutoff; received {sfreq}")
+    sos = butter(4, [1.0, 45.0], btype="bandpass", fs=sfreq, output="sos")
+    x = sosfiltfilt(sos, x, axis=-1).astype(np.float32, copy=False)
+    x -= x.mean(axis=1, keepdims=True)
+    if not math.isclose(sfreq, float(target_sfreq)):
+        up = int(target_sfreq)
+        down = int(round(sfreq))
+        common = math.gcd(up, down)
+        x = resample_poly(x, up // common, down // common, axis=-1).astype(np.float32)
+    if x.shape[-1] != int(target_samples):
+        x = resample(x, int(target_samples), axis=-1).astype(np.float32)
+    mean = x.mean(axis=(1, 2), keepdims=True)
+    std = x.std(axis=(1, 2), keepdims=True)
+    return np.clip((x - mean) / np.maximum(std, 1e-7), -8.0, 8.0).astype(np.float32)
+

eegannotationtool/senua_eegpt_linear_probe/manifest.json

@@ -0,0 +1,48 @@
+{
+  "finder_defaults": {
+    "pad_policy": "skip",
+    "step_ms": 500.0,
+    "threshold": 0.40234375
+  },
+  "important": "Research screening model; every candidate requires expert review. Threshold selected on public vEpiSet validation subjects.",
+  "input": {
+    "channel_aliases": {
+      "P7": "T5",
+      "P8": "T6",
+      "T7": "T3",
+      "T8": "T4"
+    },
+    "channel_names": [
+      "Fp1",
+      "Fp2",
+      "F3",
+      "F4",
+      "C3",
+      "C4",
+      "P3",
+      "P4",
+      "O1",
+      "O2",
+      "F7",
+      "F8",
+      "T3",
+      "T4",
+      "T5",
+      "T6",
+      "Fz",
+      "Cz",
+      "Pz"
+    ],
+    "input_samples": 1000,
+    "normalization": "global four-second window z-score clipped to [-8,8]",
+    "reference": "common average",
+    "required_filters": [
+      "1-45 Hz zero-phase Butterworth"
+    ],
+    "sampling_rate_hz": 250.0,
+    "window_seconds": 4.0
+  },
+  "name": "SenuaLab eegpt_linear_probe",
+  "schema_version": 1,
+  "source": "https://huggingface.co/SenuaLab/EEG-IED-Detection"
+}

eegannotationtool/senua_eegpt_linear_probe/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a51fd32505d51d80677ed6504b94d0b8a6718cb1de21a07cd3253ed1e1a3405a
+size 101312967

eegannotationtool/senua_eegpt_linear_probe/model.py

@@ -0,0 +1,77 @@
+"""EEG Annotation Tool adapter for the experimental SenuaLab EEGPT linear probe."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import mne
+
+try:
+    from braindecode.models import EEGPT
+except ImportError as exc:
+    raise ImportError("This model requires braindecode[hub]==1.6.1") from exc
+
+from .preprocessing import INTERNATIONAL_10_20_CHANNELS, preprocess_batch as _preprocess
+
+
+EEGPT_CHANNELS = [
+    "Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
+    "F7", "F8", "T7", "T8", "P7", "P8", "Fz", "Cz", "Pz",
+]
+MODEL_CHANNELS = INTERNATIONAL_10_20_CHANNELS
+MODEL_CHANNEL_ALIASES = {"T3": "T7", "T4": "T8", "T5": "P7", "T6": "P8"}
+MODEL_INPUT_SAMPLES = 1000
+MODEL_SAMPLING_RATE_HZ = 250.0
+MODEL_WINDOW_SECONDS = 4.0
+MODEL_ENTRY_CLASS = "SenuaEEGPTLinearProbe"
+MODEL_NUM_CLASSES = 2
+MODEL_CLASS_LABELS = ["Non-IED", "IED"]
+MODEL_NON_IED_CLASS_INDEX = 0
+MODEL_IED_CLASS_INDICES = [1]
+MODEL_DESCRIPTION = "Experimental SenuaLab EEGPT frozen-encoder linear probe"
+MODEL_BATCH_PREPROCESSOR = "preprocess_batch"
+MODEL_REQUIRED_REFERENCE = "common average (applied by model adapter)"
+MODEL_REQUIRED_FILTERS = ["1-45 Hz zero-phase Butterworth (applied by model adapter)"]
+MODEL_REQUIRED_NORMALIZATION = "global four-second window z-score, clipped to [-8,8]"
+MODEL_INPUT_UNIT = "scale-invariant after window z-score"
+MODEL_SOURCE_SIGNAL_POLICY = "raw"
+MODEL_REQUIRES_FULL_WINDOW = True
+MODEL_REQUIRES_ALL_CHANNELS = True
+MODEL_DEFAULT_THRESHOLD = 0.40234375
+MODEL_DEFAULT_STEP_MS = 500.0
+MODEL_DEFAULT_PAD_POLICY = "skip"
+MODEL_DEFAULT_BATCH_SIZE = 16
+MODEL_DEFAULT_BATCH_MEMORY_MB = 256.0
+MODEL_VALIDATION_NOTE = "Experimental ablation; not recommended for deployment and not externally validated."
+
+
+def preprocess_batch(batch, source_sfreq=None, channel_names=None):
+    return _preprocess(
+        batch,
+        source_sfreq=source_sfreq,
+        target_sfreq=250,
+        target_samples=1000,
+        channel_names=channel_names,
+    )
+
+
+def _chs_info() -> list[dict[str, Any]]:
+    info = mne.create_info(EEGPT_CHANNELS, sfreq=250.0, ch_types="eeg")
+    info.set_montage("standard_1020")
+    return info["chs"]
+
+
+class SenuaEEGPTLinearProbe(EEGPT):
+    def __init__(self, num_channels: int = 19, num_classes: int = 2, input_length: int = 1000):
+        if num_channels != 19 or input_length != 1000:
+            raise ValueError("SenuaEEGPTLinearProbe requires 19 channels and 1,000 samples")
+        super().__init__(
+            n_outputs=num_classes,
+            n_chans=19,
+            chs_info=_chs_info(),
+            n_times=1000,
+            sfreq=250.0,
+            chan_proj_type="none",
+            return_encoder_output=False,
+        )
+

eegannotationtool/senua_eegpt_linear_probe/preprocessing.py

@@ -0,0 +1,58 @@
+"""Exact four-second preprocessing used by the released SenuaLab models."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from scipy.signal import butter, resample, resample_poly, sosfiltfilt
+
+
+NUM_CHANNELS = 19
+INTERNATIONAL_10_20_CHANNELS = [
+    "Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
+    "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz",
+]
+DATASET_29_CHANNEL_ORDER = INTERNATIONAL_10_20_CHANNELS
+
+
+def normalize_sample(sample):
+    x = np.asarray(sample, dtype=np.float32)
+    mean = x.mean()
+    std = x.std()
+    return np.clip((x - mean) / max(float(std), 1e-7), -8.0, 8.0).astype(np.float32)
+
+
+def preprocess_batch(
+    batch,
+    *,
+    source_sfreq=None,
+    target_sfreq=250,
+    target_samples=1000,
+    channel_names=None,
+):
+    """Filter, average-reference, resample, and globally normalize `[B,C,T]`."""
+
+    del channel_names  # IED Finder has already arranged the declared channel order.
+    x = np.asarray(batch, dtype=np.float32)
+    if x.ndim == 2:
+        x = x[None]
+    if x.ndim != 3 or x.shape[1] != NUM_CHANNELS:
+        raise ValueError(f"Expected [batch,19,time], received {x.shape}")
+    sfreq = float(source_sfreq or target_sfreq)
+    if sfreq <= 90.0:
+        raise ValueError(f"Sampling rate must be above the 45 Hz cutoff; received {sfreq}")
+    sos = butter(4, [1.0, 45.0], btype="bandpass", fs=sfreq, output="sos")
+    x = sosfiltfilt(sos, x, axis=-1).astype(np.float32, copy=False)
+    x -= x.mean(axis=1, keepdims=True)
+    if not math.isclose(sfreq, float(target_sfreq)):
+        up = int(target_sfreq)
+        down = int(round(sfreq))
+        common = math.gcd(up, down)
+        x = resample_poly(x, up // common, down // common, axis=-1).astype(np.float32)
+    if x.shape[-1] != int(target_samples):
+        x = resample(x, int(target_samples), axis=-1).astype(np.float32)
+    mean = x.mean(axis=(1, 2), keepdims=True)
+    std = x.std(axis=(1, 2), keepdims=True)
+    return np.clip((x - mean) / np.maximum(std, 1e-7), -8.0, 8.0).astype(np.float32)
+

eegannotationtool/senua_iednet_lite/manifest.json

@@ -0,0 +1,48 @@
+{
+  "finder_defaults": {
+    "pad_policy": "skip",
+    "step_ms": 500.0,
+    "threshold": 0.6004377007484436
+  },
+  "important": "Research screening model; every candidate requires expert review. Threshold selected on public vEpiSet validation subjects.",
+  "input": {
+    "channel_aliases": {
+      "P7": "T5",
+      "P8": "T6",
+      "T7": "T3",
+      "T8": "T4"
+    },
+    "channel_names": [
+      "Fp1",
+      "Fp2",
+      "F3",
+      "F4",
+      "C3",
+      "C4",
+      "P3",
+      "P4",
+      "O1",
+      "O2",
+      "F7",
+      "F8",
+      "T3",
+      "T4",
+      "T5",
+      "T6",
+      "Fz",
+      "Cz",
+      "Pz"
+    ],
+    "input_samples": 1000,
+    "normalization": "global four-second window z-score clipped to [-8,8]",
+    "reference": "common average",
+    "required_filters": [
+      "1-45 Hz zero-phase Butterworth"
+    ],
+    "sampling_rate_hz": 250.0,
+    "window_seconds": 4.0
+  },
+  "name": "SenuaLab iednet_lite",
+  "schema_version": 1,
+  "source": "https://huggingface.co/SenuaLab/EEG-IED-Detection"
+}

eegannotationtool/senua_iednet_lite/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:383fe1de4aa8cf01b5f1c0a6734d92214ec0e7f96a6cd18a50fa52c52ccb210c
+size 1041083

eegannotationtool/senua_iednet_lite/model.py

@@ -0,0 +1,119 @@
+"""EEG Annotation Tool adapter for SenuaLab IEDNet-Lite."""
+
+from __future__ import annotations
+
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+from .preprocessing import INTERNATIONAL_10_20_CHANNELS, preprocess_batch as _preprocess
+
+
+MODEL_CHANNELS = INTERNATIONAL_10_20_CHANNELS
+MODEL_INPUT_SAMPLES = 1000
+MODEL_SAMPLING_RATE_HZ = 250.0
+MODEL_WINDOW_SECONDS = 4.0
+MODEL_ENTRY_CLASS = "IEDNetLite"
+MODEL_NUM_CLASSES = 2
+MODEL_CLASS_LABELS = ["Non-IED", "IED"]
+MODEL_NON_IED_CLASS_INDEX = 0
+MODEL_IED_CLASS_INDICES = [1]
+MODEL_DESCRIPTION = "SenuaLab patient-independent IEDNet-Lite binary IED detector"
+MODEL_BATCH_PREPROCESSOR = "preprocess_batch"
+MODEL_REQUIRED_REFERENCE = "common average (applied by model adapter)"
+MODEL_REQUIRED_FILTERS = ["1-45 Hz zero-phase Butterworth (applied by model adapter)"]
+MODEL_REQUIRED_NORMALIZATION = "global four-second window z-score, clipped to [-8,8]"
+MODEL_INPUT_UNIT = "scale-invariant after window z-score"
+MODEL_SOURCE_SIGNAL_POLICY = "raw"
+MODEL_REQUIRES_FULL_WINDOW = True
+MODEL_REQUIRES_ALL_CHANNELS = True
+MODEL_DEFAULT_THRESHOLD = 0.6004377007484436
+MODEL_DEFAULT_STEP_MS = 500.0
+MODEL_DEFAULT_PAD_POLICY = "skip"
+MODEL_DEFAULT_BATCH_SIZE = 64
+MODEL_DEFAULT_BATCH_MEMORY_MB = 64.0
+MODEL_VALIDATION_NOTE = "Threshold selected on the vEpiSet validation subjects; not externally validated."
+MODEL_PREPROCESSING_NOTE = "The adapter applies the exact released 1-45 Hz, common-average, resampling, and global-window z-score pipeline."
+
+
+def preprocess_batch(batch, source_sfreq=None, channel_names=None):
+    return _preprocess(
+        batch,
+        source_sfreq=source_sfreq,
+        target_sfreq=250,
+        target_samples=1000,
+        channel_names=channel_names,
+    )
+
+
+class SqueezeExcitation(nn.Module):
+    def __init__(self, channels: int, reduction: int = 8):
+        super().__init__()
+        hidden = max(8, channels // reduction)
+        self.net = nn.Sequential(
+            nn.AdaptiveAvgPool1d(1),
+            nn.Conv1d(channels, hidden, 1),
+            nn.GELU(),
+            nn.Conv1d(hidden, channels, 1),
+            nn.Sigmoid(),
+        )
+
+    def forward(self, x):
+        return x * self.net(x)
+
+
+class DSResidual(nn.Module):
+    def __init__(self, in_ch: int, out_ch: int, kernel: int, stride: int = 1, dilation: int = 1):
+        super().__init__()
+        pad = dilation * (kernel - 1) // 2
+        self.body = nn.Sequential(
+            nn.Conv1d(in_ch, in_ch, kernel, stride=stride, padding=pad, dilation=dilation, groups=in_ch, bias=False),
+            nn.BatchNorm1d(in_ch),
+            nn.GELU(),
+            nn.Conv1d(in_ch, out_ch, 1, bias=False),
+            nn.BatchNorm1d(out_ch),
+            SqueezeExcitation(out_ch),
+        )
+        self.skip = (
+            nn.Identity()
+            if in_ch == out_ch and stride == 1
+            else nn.Sequential(nn.Conv1d(in_ch, out_ch, 1, stride=stride, bias=False), nn.BatchNorm1d(out_ch))
+        )
+
+    def forward(self, x):
+        return F.gelu(self.body(x) + self.skip(x))
+
+
+class IEDNetLite(nn.Module):
+    def __init__(self, num_channels: int = 19, num_classes: int = 2, input_length: int = 1000, subtypes: int = 5):
+        super().__init__()
+        del input_length
+        branches = []
+        for kernel in (7, 15, 31):
+            branches.append(
+                nn.Sequential(
+                    nn.Conv1d(num_channels, 24, kernel, stride=2, padding=kernel // 2, bias=False),
+                    nn.BatchNorm1d(24),
+                    nn.GELU(),
+                )
+            )
+        self.stem = nn.ModuleList(branches)
+        self.backbone = nn.Sequential(
+            DSResidual(72, 72, 9, stride=2),
+            DSResidual(72, 96, 7, stride=2),
+            DSResidual(96, 96, 7, dilation=2),
+            DSResidual(96, 144, 5, stride=2),
+            DSResidual(144, 144, 5, dilation=2),
+            DSResidual(144, 192, 3, stride=2),
+            DSResidual(192, 192, 3, dilation=2),
+        )
+        self.dropout = nn.Dropout(0.35)
+        self.binary_head = nn.Linear(384, num_classes)
+        self.subtype_head = nn.Linear(384, subtypes)
+
+    def forward(self, x):
+        x = torch.cat([branch(x) for branch in self.stem], dim=1)
+        x = self.backbone(x)
+        features = self.dropout(torch.cat([x.mean(-1), x.amax(-1)], dim=1))
+        return self.binary_head(features), self.subtype_head(features)
+

eegannotationtool/senua_iednet_lite/preprocessing.py

@@ -0,0 +1,58 @@
+"""Exact four-second preprocessing used by the released SenuaLab models."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from scipy.signal import butter, resample, resample_poly, sosfiltfilt
+
+
+NUM_CHANNELS = 19
+INTERNATIONAL_10_20_CHANNELS = [
+    "Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
+    "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz",
+]
+DATASET_29_CHANNEL_ORDER = INTERNATIONAL_10_20_CHANNELS
+
+
+def normalize_sample(sample):
+    x = np.asarray(sample, dtype=np.float32)
+    mean = x.mean()
+    std = x.std()
+    return np.clip((x - mean) / max(float(std), 1e-7), -8.0, 8.0).astype(np.float32)
+
+
+def preprocess_batch(
+    batch,
+    *,
+    source_sfreq=None,
+    target_sfreq=250,
+    target_samples=1000,
+    channel_names=None,
+):
+    """Filter, average-reference, resample, and globally normalize `[B,C,T]`."""
+
+    del channel_names  # IED Finder has already arranged the declared channel order.
+    x = np.asarray(batch, dtype=np.float32)
+    if x.ndim == 2:
+        x = x[None]
+    if x.ndim != 3 or x.shape[1] != NUM_CHANNELS:
+        raise ValueError(f"Expected [batch,19,time], received {x.shape}")
+    sfreq = float(source_sfreq or target_sfreq)
+    if sfreq <= 90.0:
+        raise ValueError(f"Sampling rate must be above the 45 Hz cutoff; received {sfreq}")
+    sos = butter(4, [1.0, 45.0], btype="bandpass", fs=sfreq, output="sos")
+    x = sosfiltfilt(sos, x, axis=-1).astype(np.float32, copy=False)
+    x -= x.mean(axis=1, keepdims=True)
+    if not math.isclose(sfreq, float(target_sfreq)):
+        up = int(target_sfreq)
+        down = int(round(sfreq))
+        common = math.gcd(up, down)
+        x = resample_poly(x, up // common, down // common, axis=-1).astype(np.float32)
+    if x.shape[-1] != int(target_samples):
+        x = resample(x, int(target_samples), axis=-1).astype(np.float32)
+    mean = x.mean(axis=(1, 2), keepdims=True)
+    std = x.std(axis=(1, 2), keepdims=True)
+    return np.clip((x - mean) / np.maximum(std, 1e-7), -8.0, 8.0).astype(np.float32)
+

eegannotationtool/senua_resnet_attention/manifest.json

@@ -0,0 +1,48 @@
+{
+  "finder_defaults": {
+    "pad_policy": "skip",
+    "step_ms": 500.0,
+    "threshold": 0.6944227814674377
+  },
+  "important": "Research screening model; every candidate requires expert review. Threshold selected on public vEpiSet validation subjects.",
+  "input": {
+    "channel_aliases": {
+      "P7": "T5",
+      "P8": "T6",
+      "T7": "T3",
+      "T8": "T4"
+    },
+    "channel_names": [
+      "Fp1",
+      "Fp2",
+      "F3",
+      "F4",
+      "C3",
+      "C4",
+      "P3",
+      "P4",
+      "O1",
+      "O2",
+      "F7",
+      "F8",
+      "T3",
+      "T4",
+      "T5",
+      "T6",
+      "Fz",
+      "Cz",
+      "Pz"
+    ],
+    "input_samples": 1000,
+    "normalization": "global four-second window z-score clipped to [-8,8]",
+    "reference": "common average",
+    "required_filters": [
+      "1-45 Hz zero-phase Butterworth"
+    ],
+    "sampling_rate_hz": 250.0,
+    "window_seconds": 4.0
+  },
+  "name": "SenuaLab resnet_attention",
+  "schema_version": 1,
+  "source": "https://huggingface.co/SenuaLab/EEG-IED-Detection"
+}

eegannotationtool/senua_resnet_attention/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df088c4fd087b453ef3aca76f54a975a69f015324f8d862d2d4ba5316cb91e1a
+size 20037039

eegannotationtool/senua_resnet_attention/model.py

@@ -0,0 +1,677 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+
+# Import preprocessing constants
+from .preprocessing import INTERNATIONAL_10_20_CHANNELS, NUM_CHANNELS, preprocess_batch as _preprocess
+
+
+MODEL_CHANNELS = INTERNATIONAL_10_20_CHANNELS
+MODEL_INPUT_SAMPLES = 1000
+MODEL_SAMPLING_RATE_HZ = 250.0
+MODEL_WINDOW_SECONDS = 4.0
+MODEL_ENTRY_CLASS = "EEGResNetAttention"
+MODEL_NUM_CLASSES = 2
+MODEL_CLASS_LABELS = ["Non-IED", "IED"]
+MODEL_NON_IED_CLASS_INDEX = 0
+MODEL_IED_CLASS_INDICES = [1]
+MODEL_DESCRIPTION = "SenuaLab patient-independent ResNet-Attention binary IED detector"
+MODEL_BATCH_PREPROCESSOR = "preprocess_batch"
+MODEL_REQUIRED_REFERENCE = "common average (applied by model adapter)"
+MODEL_REQUIRED_FILTERS = ["1-45 Hz zero-phase Butterworth (applied by model adapter)"]
+MODEL_REQUIRED_NORMALIZATION = "global four-second window z-score, clipped to [-8,8]"
+MODEL_INPUT_UNIT = "scale-invariant after window z-score"
+MODEL_SOURCE_SIGNAL_POLICY = "raw"
+MODEL_REQUIRES_FULL_WINDOW = True
+MODEL_REQUIRES_ALL_CHANNELS = True
+MODEL_DEFAULT_THRESHOLD = 0.6944227814674377
+MODEL_DEFAULT_STEP_MS = 500.0
+MODEL_DEFAULT_PAD_POLICY = "skip"
+MODEL_DEFAULT_BATCH_SIZE = 32
+MODEL_DEFAULT_BATCH_MEMORY_MB = 96.0
+MODEL_VALIDATION_NOTE = "Threshold selected on the vEpiSet validation subjects; not externally validated."
+MODEL_PREPROCESSING_NOTE = "The adapter applies the exact released 1-45 Hz, common-average, resampling, and global-window z-score pipeline."
+
+
+def preprocess_batch(batch, source_sfreq=None, channel_names=None):
+    return _preprocess(
+        batch,
+        source_sfreq=source_sfreq,
+        target_sfreq=250,
+        target_samples=1000,
+        channel_names=channel_names,
+    )
+
+
+class Simple1DCNN(nn.Module):
+    """
+    Simple 1D CNN for EEG IED classification.
+    
+    Architecture:
+    - 4 convolutional blocks with BatchNorm, ReLU, and MaxPool
+    - Fully connected classifier with dropout
+    
+    Default configuration uses 19 channels (standard 10-20) to match
+    the vEpiSet preprocessing pipeline.
+    """
+    
+    def __init__(self, num_channels=NUM_CHANNELS, num_classes=2, input_length=2000):
+        """
+        Args:
+            num_channels: Number of EEG channels (default 19 for standard 10-20)
+            num_classes: Number of output classes (default 2: IED vs Non-IED)
+            input_length: Number of time samples (default 2000 = 4 seconds at 500 Hz)
+        """
+        super(Simple1DCNN, self).__init__()
+        
+        self.num_channels = num_channels
+        self.input_length = input_length
+        
+        self.features = nn.Sequential(
+            # Block 1
+            nn.Conv1d(in_channels=num_channels, out_channels=32, kernel_size=5, stride=1, padding=2),
+            nn.BatchNorm1d(32),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2, stride=2),
+            
+            # Block 2
+            nn.Conv1d(in_channels=32, out_channels=64, kernel_size=5, stride=1, padding=2),
+            nn.BatchNorm1d(64),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2, stride=2),
+            
+            # Block 3
+            nn.Conv1d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm1d(128),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2, stride=2),
+            
+            # Block 4
+            nn.Conv1d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1),
+            nn.BatchNorm1d(256),
+            nn.ReLU(),
+            nn.MaxPool1d(kernel_size=2, stride=2),
+        )
+        
+        # Calculate size after convolutions
+        # Input: 2000
+        # Pool 1: 1000
+        # Pool 2: 500
+        # Pool 3: 250
+        # Pool 4: 125
+        self.flatten_size = 256 * (input_length // 16)  # 16 = 2^4 (4 pooling layers)
+        
+        self.classifier = nn.Sequential(
+            nn.Linear(self.flatten_size, 512),
+            nn.ReLU(),
+            nn.Dropout(0.5),
+            nn.Linear(512, num_classes)
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), -1)
+        x = self.classifier(x)
+        return x
+
+
+# ============================================================================
+# Advanced Model Architectures for Better IED Detection
+# ============================================================================
+
+class SqueezeExcitation1D(nn.Module):
+    """Squeeze-and-Excitation block for channel attention."""
+    
+    def __init__(self, channels, reduction=16):
+        super().__init__()
+        self.avg_pool = nn.AdaptiveAvgPool1d(1)
+        self.fc = nn.Sequential(
+            nn.Linear(channels, channels // reduction, bias=False),
+            nn.ReLU(inplace=True),
+            nn.Linear(channels // reduction, channels, bias=False),
+            nn.Sigmoid()
+        )
+    
+    def forward(self, x):
+        b, c, _ = x.size()
+        y = self.avg_pool(x).view(b, c)
+        y = self.fc(y).view(b, c, 1)
+        return x * y.expand_as(x)
+
+
+class ResidualBlock1D(nn.Module):
+    """Residual block with optional squeeze-excitation."""
+    
+    def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, 
+                 downsample=None, use_se=True):
+        super().__init__()
+        padding = kernel_size // 2
+        
+        self.conv1 = nn.Conv1d(in_channels, out_channels, kernel_size, 
+                               stride=stride, padding=padding, bias=False)
+        self.bn1 = nn.BatchNorm1d(out_channels)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv1d(out_channels, out_channels, kernel_size, 
+                               stride=1, padding=padding, bias=False)
+        self.bn2 = nn.BatchNorm1d(out_channels)
+        
+        self.downsample = downsample
+        self.se = SqueezeExcitation1D(out_channels) if use_se else nn.Identity()
+        
+    def forward(self, x):
+        identity = x
+        
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+        
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.se(out)
+        
+        if self.downsample is not None:
+            identity = self.downsample(x)
+        
+        out += identity
+        out = self.relu(out)
+        return out
+
+
+class TemporalAttention(nn.Module):
+    """Self-attention mechanism for temporal patterns."""
+    
+    def __init__(self, channels, num_heads=4):
+        super().__init__()
+        self.num_heads = num_heads
+        self.head_dim = channels // num_heads
+        self.scale = self.head_dim ** -0.5
+        
+        self.qkv = nn.Linear(channels, channels * 3, bias=False)
+        self.proj = nn.Linear(channels, channels)
+        self.norm = nn.LayerNorm(channels)
+        
+    def forward(self, x):
+        # x: [B, C, T] -> [B, T, C]
+        x = x.permute(0, 2, 1)
+        B, T, C = x.shape
+        
+        # Residual connection
+        residual = x
+        x = self.norm(x)
+        
+        # Multi-head attention
+        qkv = self.qkv(x).reshape(B, T, 3, self.num_heads, self.head_dim)
+        qkv = qkv.permute(2, 0, 3, 1, 4)  # [3, B, heads, T, head_dim]
+        q, k, v = qkv[0], qkv[1], qkv[2]
+        
+        attn = (q @ k.transpose(-2, -1)) * self.scale
+        attn = attn.softmax(dim=-1)
+        
+        x = (attn @ v).transpose(1, 2).reshape(B, T, C)
+        x = self.proj(x)
+        x = x + residual
+        
+        # Back to [B, C, T]
+        return x.permute(0, 2, 1)
+
+
+class MultiScaleConv(nn.Module):
+    """Multi-scale convolution for capturing different frequency patterns."""
+    
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.branch1 = nn.Sequential(
+            nn.Conv1d(in_channels, out_channels // 4, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm1d(out_channels // 4),
+            nn.ReLU(inplace=True)
+        )
+        self.branch2 = nn.Sequential(
+            nn.Conv1d(in_channels, out_channels // 4, kernel_size=5, padding=2, bias=False),
+            nn.BatchNorm1d(out_channels // 4),
+            nn.ReLU(inplace=True)
+        )
+        self.branch3 = nn.Sequential(
+            nn.Conv1d(in_channels, out_channels // 4, kernel_size=7, padding=3, bias=False),
+            nn.BatchNorm1d(out_channels // 4),
+            nn.ReLU(inplace=True)
+        )
+        self.branch4 = nn.Sequential(
+            nn.Conv1d(in_channels, out_channels // 4, kernel_size=11, padding=5, bias=False),
+            nn.BatchNorm1d(out_channels // 4),
+            nn.ReLU(inplace=True)
+        )
+        
+    def forward(self, x):
+        return torch.cat([
+            self.branch1(x),
+            self.branch2(x),
+            self.branch3(x),
+            self.branch4(x)
+        ], dim=1)
+
+
+class EEGResNetAttention(nn.Module):
+    """
+    Advanced EEG IED Detector with ResNet backbone and Attention.
+    
+    Features:
+    - Multi-scale initial convolution for capturing different EEG frequencies
+    - Residual blocks with Squeeze-and-Excitation attention
+    - Temporal self-attention for capturing long-range dependencies
+    - Global average pooling for robust feature aggregation
+    """
+    
+    def __init__(self, num_channels=NUM_CHANNELS, num_classes=2, input_length=2000):
+        super().__init__()
+        
+        self.num_channels = num_channels
+        self.input_length = input_length
+        
+        # Multi-scale initial convolution
+        self.stem = MultiScaleConv(num_channels, 64)
+        self.stem_pool = nn.MaxPool1d(kernel_size=2, stride=2)
+        
+        # Residual blocks
+        self.layer1 = self._make_layer(64, 64, num_blocks=2, stride=1)
+        self.layer2 = self._make_layer(64, 128, num_blocks=2, stride=2)
+        self.layer3 = self._make_layer(128, 256, num_blocks=2, stride=2)
+        self.layer4 = self._make_layer(256, 512, num_blocks=2, stride=2)
+        
+        # Temporal attention
+        self.temporal_attn = TemporalAttention(512, num_heads=8)
+        
+        # Global pooling and classifier
+        self.global_pool = nn.AdaptiveAvgPool1d(1)
+        self.dropout = nn.Dropout(0.5)
+        self.fc = nn.Linear(512, num_classes)
+        
+        # Initialize weights
+        self._init_weights()
+        
+    def _make_layer(self, in_channels, out_channels, num_blocks, stride):
+        downsample = None
+        if stride != 1 or in_channels != out_channels:
+            downsample = nn.Sequential(
+                nn.Conv1d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm1d(out_channels)
+            )
+        
+        layers = [ResidualBlock1D(in_channels, out_channels, stride=stride, downsample=downsample)]
+        for _ in range(1, num_blocks):
+            layers.append(ResidualBlock1D(out_channels, out_channels))
+        
+        return nn.Sequential(*layers)
+    
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv1d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm1d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+    
+    def forward(self, x):
+        # Multi-scale stem
+        x = self.stem(x)
+        x = self.stem_pool(x)
+        
+        # Residual blocks
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        
+        # Temporal attention
+        x = self.temporal_attn(x)
+        
+        # Global pooling and classification
+        x = self.global_pool(x).squeeze(-1)
+        x = self.dropout(x)
+        x = self.fc(x)
+        
+        return x
+
+
+class EEGTransformer(nn.Module):
+    """
+    Transformer-based EEG IED Detector.
+    
+    Uses a CNN backbone for initial feature extraction followed by
+    Transformer encoder layers for capturing complex temporal patterns.
+    """
+    
+    def __init__(self, num_channels=NUM_CHANNELS, num_classes=2, input_length=2000,
+                 d_model=256, nhead=8, num_layers=4, dim_feedforward=512):
+        super().__init__()
+        
+        self.num_channels = num_channels
+        self.input_length = input_length
+        
+        # CNN backbone for initial feature extraction
+        self.conv_backbone = nn.Sequential(
+            nn.Conv1d(num_channels, 64, kernel_size=7, stride=2, padding=3, bias=False),
+            nn.BatchNorm1d(64),
+            nn.ReLU(inplace=True),
+            nn.MaxPool1d(kernel_size=3, stride=2, padding=1),
+            
+            nn.Conv1d(64, 128, kernel_size=5, stride=2, padding=2, bias=False),
+            nn.BatchNorm1d(128),
+            nn.ReLU(inplace=True),
+            
+            nn.Conv1d(128, d_model, kernel_size=3, stride=2, padding=1, bias=False),
+            nn.BatchNorm1d(d_model),
+            nn.ReLU(inplace=True),
+        )
+        
+        # Calculate sequence length after CNN
+        # 2000 -> 1000 -> 500 -> 250 -> 125
+        self.seq_len = input_length // 16
+        
+        # Positional encoding
+        self.pos_encoding = self._create_positional_encoding(self.seq_len, d_model)
+        
+        # Transformer encoder
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=d_model, 
+            nhead=nhead, 
+            dim_feedforward=dim_feedforward,
+            dropout=0.1,
+            activation='gelu',
+            batch_first=True
+        )
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        
+        # Classification head
+        self.global_pool = nn.AdaptiveAvgPool1d(1)
+        self.classifier = nn.Sequential(
+            nn.Linear(d_model, d_model // 2),
+            nn.GELU(),
+            nn.Dropout(0.3),
+            nn.Linear(d_model // 2, num_classes)
+        )
+        
+    def _create_positional_encoding(self, seq_len, d_model):
+        pe = torch.zeros(seq_len, d_model)
+        position = torch.arange(0, seq_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        return nn.Parameter(pe.unsqueeze(0), requires_grad=False)
+        
+    def forward(self, x):
+        # CNN backbone: [B, C, T] -> [B, d_model, T']
+        x = self.conv_backbone(x)
+        
+        # Reshape for transformer: [B, d_model, T'] -> [B, T', d_model]
+        x = x.permute(0, 2, 1)
+        
+        # Add positional encoding
+        x = x + self.pos_encoding[:, :x.size(1), :]
+        
+        # Transformer encoder
+        x = self.transformer(x)
+        
+        # Back to [B, d_model, T'] for pooling
+        x = x.permute(0, 2, 1)
+        
+        # Global pooling and classification
+        x = self.global_pool(x).squeeze(-1)
+        x = self.classifier(x)
+        
+        return x
+
+
+class EEGInceptionNet(nn.Module):
+    """
+    Inception-style network for EEG IED detection.
+    
+    Uses parallel convolutions with different kernel sizes to capture
+    multi-scale temporal patterns characteristic of IEDs.
+    """
+    
+    def __init__(self, num_channels=NUM_CHANNELS, num_classes=2, input_length=2000):
+        super().__init__()
+        
+        self.num_channels = num_channels
+        self.input_length = input_length
+        
+        # Initial convolution
+        self.conv1 = nn.Sequential(
+            nn.Conv1d(num_channels, 32, kernel_size=7, stride=2, padding=3, bias=False),
+            nn.BatchNorm1d(32),
+            nn.ReLU(inplace=True),
+            nn.MaxPool1d(kernel_size=3, stride=2, padding=1)
+        )
+        
+        # Inception blocks
+        self.inception1 = InceptionBlock(32, 64)
+        self.inception2 = InceptionBlock(64, 128)
+        self.inception3 = InceptionBlock(128, 256)
+        
+        # Pooling between inception blocks
+        self.pool = nn.MaxPool1d(kernel_size=2, stride=2)
+        
+        # Channel attention
+        self.channel_attn = SqueezeExcitation1D(256)
+        
+        # Global pooling and classifier
+        self.global_pool = nn.AdaptiveAvgPool1d(1)
+        self.dropout = nn.Dropout(0.5)
+        self.fc = nn.Linear(256, num_classes)
+        
+    def forward(self, x):
+        x = self.conv1(x)
+        
+        x = self.inception1(x)
+        x = self.pool(x)
+        
+        x = self.inception2(x)
+        x = self.pool(x)
+        
+        x = self.inception3(x)
+        x = self.channel_attn(x)
+        
+        x = self.global_pool(x).squeeze(-1)
+        x = self.dropout(x)
+        x = self.fc(x)
+        
+        return x
+
+
+class EEGResNetTransformer(nn.Module):
+    """Hybrid model: multi-scale ResNet backbone + Transformer encoder.
+
+    Rationale:
+    - CNN/ResNet extracts local, frequency-like patterns efficiently.
+    - Transformer models longer-range temporal dependencies after downsampling.
+    - Outputs raw logits suitable for nn.CrossEntropyLoss.
+    """
+
+    def __init__(
+        self,
+        num_channels=NUM_CHANNELS,
+        num_classes=2,
+        input_length=2000,
+        d_model=512,
+        nhead=8,
+        num_layers=4,
+        dim_feedforward=1024,
+        dropout=0.2,
+    ):
+        super().__init__()
+
+        self.num_channels = num_channels
+        self.input_length = input_length
+
+        # ResNet-ish backbone (same stem idea as EEGResNetAttention)
+        self.stem = MultiScaleConv(num_channels, 64)
+        self.stem_pool = nn.MaxPool1d(kernel_size=2, stride=2)
+
+        self.layer1 = self._make_layer(64, 64, num_blocks=2, stride=1)
+        self.layer2 = self._make_layer(64, 128, num_blocks=2, stride=2)
+        self.layer3 = self._make_layer(128, 256, num_blocks=2, stride=2)
+        self.layer4 = self._make_layer(256, d_model, num_blocks=2, stride=2)
+
+        # Transformer encoder over time (after downsampling)
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=d_model,
+            nhead=nhead,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout,
+            activation='gelu',
+            batch_first=True,
+            norm_first=True,
+        )
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+
+        # Learnable positional embeddings (sequence length depends on input length)
+        # Downsampling: stem_pool(/2) + layer2(/2) + layer3(/2) + layer4(/2) => /16 total
+        self.seq_len = max(1, input_length // 16)
+        self.pos_embed = nn.Parameter(torch.zeros(1, self.seq_len, d_model))
+
+        self.pre_head_norm = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(dropout)
+        self.head = nn.Linear(d_model, num_classes)
+
+        self._init_weights()
+
+    def _make_layer(self, in_channels, out_channels, num_blocks, stride):
+        downsample = None
+        if stride != 1 or in_channels != out_channels:
+            downsample = nn.Sequential(
+                nn.Conv1d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm1d(out_channels),
+            )
+
+        layers = [ResidualBlock1D(in_channels, out_channels, stride=stride, downsample=downsample)]
+        for _ in range(1, num_blocks):
+            layers.append(ResidualBlock1D(out_channels, out_channels))
+        return nn.Sequential(*layers)
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv1d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm1d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.Linear):
+                nn.init.trunc_normal_(m.weight, std=0.02)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+        nn.init.trunc_normal_(self.pos_embed, std=0.02)
+
+    def forward(self, x):
+        # x: [B, C, T]
+        x = self.stem(x)
+        x = self.stem_pool(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)  # [B, d_model, T']
+
+        # [B, d_model, T'] -> [B, T', d_model]
+        x = x.permute(0, 2, 1)
+
+        # Handle dynamic T' (e.g. if input_length differs)
+        if x.size(1) != self.pos_embed.size(1):
+            # Simple interpolate positional embeddings along time
+            pos = self.pos_embed.transpose(1, 2)  # [1, d_model, seq]
+            pos = F.interpolate(pos, size=x.size(1), mode='linear', align_corners=False)
+            pos = pos.transpose(1, 2)
+        else:
+            pos = self.pos_embed
+
+        x = x + pos
+        x = self.transformer(x)
+
+        # Mean pool over time
+        x = x.mean(dim=1)
+        x = self.pre_head_norm(x)
+        x = self.dropout(x)
+        return self.head(x)
+
+
+class InceptionBlock(nn.Module):
+    """Inception block with multiple parallel convolutions."""
+    
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        branch_channels = out_channels // 4
+        
+        # 1x1 conv
+        self.branch1 = nn.Sequential(
+            nn.Conv1d(in_channels, branch_channels, kernel_size=1, bias=False),
+            nn.BatchNorm1d(branch_channels),
+            nn.ReLU(inplace=True)
+        )
+        
+        # 1x1 -> 3x3 conv
+        self.branch2 = nn.Sequential(
+            nn.Conv1d(in_channels, branch_channels, kernel_size=1, bias=False),
+            nn.BatchNorm1d(branch_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv1d(branch_channels, branch_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm1d(branch_channels),
+            nn.ReLU(inplace=True)
+        )
+        
+        # 1x1 -> 5x5 conv
+        self.branch3 = nn.Sequential(
+            nn.Conv1d(in_channels, branch_channels, kernel_size=1, bias=False),
+            nn.BatchNorm1d(branch_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv1d(branch_channels, branch_channels, kernel_size=5, padding=2, bias=False),
+            nn.BatchNorm1d(branch_channels),
+            nn.ReLU(inplace=True)
+        )
+        
+        # MaxPool -> 1x1 conv
+        self.branch4 = nn.Sequential(
+            nn.MaxPool1d(kernel_size=3, stride=1, padding=1),
+            nn.Conv1d(in_channels, branch_channels, kernel_size=1, bias=False),
+            nn.BatchNorm1d(branch_channels),
+            nn.ReLU(inplace=True)
+        )
+        
+    def forward(self, x):
+        return torch.cat([
+            self.branch1(x),
+            self.branch2(x),
+            self.branch3(x),
+            self.branch4(x)
+        ], dim=1)
+
+
+# Model factory function
+def get_model(model_name='resnet_attention', num_channels=NUM_CHANNELS, num_classes=2, input_length=2000):
+    """
+    Factory function to get model by name.
+    
+    Args:
+        model_name: One of 'simple_cnn', 'resnet_attention', 'transformer', 'inception', 'resnet_transformer'
+        num_channels: Number of input channels
+        num_classes: Number of output classes
+        input_length: Input sequence length
+        
+    Returns:
+        Model instance
+    """
+    models = {
+        'simple_cnn': Simple1DCNN,
+        'resnet_attention': EEGResNetAttention,
+        'transformer': EEGTransformer,
+        'inception': EEGInceptionNet,
+        'resnet_transformer': EEGResNetTransformer,
+    }
+    
+    if model_name not in models:
+        raise ValueError(f"Unknown model: {model_name}. Choose from {list(models.keys())}")
+    
+    return models[model_name](num_channels=num_channels, num_classes=num_classes, input_length=input_length)

eegannotationtool/senua_resnet_attention/preprocessing.py

@@ -0,0 +1,58 @@
+"""Exact four-second preprocessing used by the released SenuaLab models."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+from scipy.signal import butter, resample, resample_poly, sosfiltfilt
+
+
+NUM_CHANNELS = 19
+INTERNATIONAL_10_20_CHANNELS = [
+    "Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
+    "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz",
+]
+DATASET_29_CHANNEL_ORDER = INTERNATIONAL_10_20_CHANNELS
+
+
+def normalize_sample(sample):
+    x = np.asarray(sample, dtype=np.float32)
+    mean = x.mean()
+    std = x.std()
+    return np.clip((x - mean) / max(float(std), 1e-7), -8.0, 8.0).astype(np.float32)
+
+
+def preprocess_batch(
+    batch,
+    *,
+    source_sfreq=None,
+    target_sfreq=250,
+    target_samples=1000,
+    channel_names=None,
+):
+    """Filter, average-reference, resample, and globally normalize `[B,C,T]`."""
+
+    del channel_names  # IED Finder has already arranged the declared channel order.
+    x = np.asarray(batch, dtype=np.float32)
+    if x.ndim == 2:
+        x = x[None]
+    if x.ndim != 3 or x.shape[1] != NUM_CHANNELS:
+        raise ValueError(f"Expected [batch,19,time], received {x.shape}")
+    sfreq = float(source_sfreq or target_sfreq)
+    if sfreq <= 90.0:
+        raise ValueError(f"Sampling rate must be above the 45 Hz cutoff; received {sfreq}")
+    sos = butter(4, [1.0, 45.0], btype="bandpass", fs=sfreq, output="sos")
+    x = sosfiltfilt(sos, x, axis=-1).astype(np.float32, copy=False)
+    x -= x.mean(axis=1, keepdims=True)
+    if not math.isclose(sfreq, float(target_sfreq)):
+        up = int(target_sfreq)
+        down = int(round(sfreq))
+        common = math.gcd(up, down)
+        x = resample_poly(x, up // common, down // common, axis=-1).astype(np.float32)
+    if x.shape[-1] != int(target_samples):
+        x = resample(x, int(target_samples), axis=-1).astype(np.float32)
+    mean = x.mean(axis=(1, 2), keepdims=True)
+    std = x.std(axis=(1, 2), keepdims=True)
+    return np.clip((x - mean) / np.maximum(std, 1e-7), -8.0, 8.0).astype(np.float32)
+

ensembles/ensemble.json

@@ -0,0 +1,25 @@
+{
+  "models": [
+    "iednet_lite",
+    "resnet_attention"
+  ],
+  "test_metrics": {
+    "accuracy": 0.93014329580348,
+    "auprc": 0.7211157678062519,
+    "auroc": 0.8995878534153646,
+    "balanced_accuracy": 0.8135185936874053,
+    "f1": 0.6784452296819788,
+    "false_positives_per_minute": 0.5483592400690847,
+    "fn": 146,
+    "fp": 127,
+    "n": 3908,
+    "precision": 0.6939759036144578,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.663594470046083,
+    "specificity": 0.9634427173287277,
+    "threshold": 0.51321724,
+    "tn": 3347,
+    "tp": 288
+  },
+  "threshold": 0.51321724
+}

ensembles/ensemble_4model.json

@@ -0,0 +1,53 @@
+{
+  "aggregation": "equal_probability_mean",
+  "models": [
+    "iednet_lite",
+    "resnet_attention",
+    "eegpt",
+    "eegdino_medium"
+  ],
+  "selection_score_validation_auprc_plus_025_f1": 0.8335915544686525,
+  "test_metrics": {
+    "accuracy": 0.9483111566018424,
+    "auprc": 0.7888269120699914,
+    "auroc": 0.9200864088462283,
+    "balanced_accuracy": 0.8600306689058151,
+    "f1": 0.7623529411764706,
+    "false_positives_per_minute": 0.39723661485319517,
+    "fn": 110,
+    "fp": 92,
+    "n": 3908,
+    "precision": 0.7788461538461539,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.7465437788018433,
+    "specificity": 0.973517559009787,
+    "threshold": 0.5273836475,
+    "tn": 3382,
+    "tp": 324
+  },
+  "threshold": 0.5273836475,
+  "validation_metrics": {
+    "accuracy": 0.9512570548999487,
+    "auprc": 0.6725428653300758,
+    "auroc": 0.8953611234795638,
+    "balanced_accuracy": 0.7657309048759975,
+    "f1": 0.6441947565543071,
+    "false_positives_per_minute": 0.19262981574539362,
+    "fn": 144,
+    "fp": 46,
+    "n": 3898,
+    "precision": 0.7889908256880734,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.5443037974683544,
+    "specificity": 0.9871580122836404,
+    "threshold": 0.5273836475,
+    "tn": 3536,
+    "tp": 172
+  },
+  "weights": [
+    0.25,
+    0.25,
+    0.25,
+    0.25
+  ]
+}

ensembles/ensemble_eegdino.json

@@ -0,0 +1,51 @@
+{
+  "aggregation": "equal_probability_mean",
+  "models": [
+    "iednet_lite",
+    "resnet_attention",
+    "eegdino_medium"
+  ],
+  "selection_score_validation_auprc_plus_025_f1": 0.8454267628396437,
+  "test_metrics": {
+    "accuracy": 0.9437052200614124,
+    "auprc": 0.7895565635533457,
+    "auroc": 0.9261677928734589,
+    "balanced_accuracy": 0.8463503736778014,
+    "f1": 0.7399527186761229,
+    "false_positives_per_minute": 0.4274611398963731,
+    "fn": 121,
+    "fp": 99,
+    "n": 3908,
+    "precision": 0.7597087378640777,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.7211981566820277,
+    "specificity": 0.9715025906735751,
+    "threshold": 0.5274549233333333,
+    "tn": 3375,
+    "tp": 313
+  },
+  "threshold": 0.5274549233333333,
+  "validation_metrics": {
+    "accuracy": 0.9510005130836326,
+    "auprc": 0.6860339734658296,
+    "auroc": 0.9016363462884041,
+    "balanced_accuracy": 0.7598205514209585,
+    "f1": 0.6375711574952562,
+    "false_positives_per_minute": 0.18006700167504186,
+    "fn": 148,
+    "fp": 43,
+    "n": 3898,
+    "precision": 0.7962085308056872,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.5316455696202531,
+    "specificity": 0.9879955332216639,
+    "threshold": 0.5274549233333333,
+    "tn": 3539,
+    "tp": 168
+  },
+  "weights": [
+    0.3333333333333333,
+    0.3333333333333333,
+    0.3333333333333333
+  ]
+}

ensembles/ensemble_eegpt.json

@@ -0,0 +1,50 @@
+{
+  "aggregation": "equal_probability_mean",
+  "models": [
+    "iednet_lite",
+    "resnet_attention",
+    "eegpt"
+  ],
+  "test_metrics": {
+    "accuracy": 0.936028659160696,
+    "auprc": 0.7451331821970812,
+    "auroc": 0.9004447787249058,
+    "balanced_accuracy": 0.8248940781950977,
+    "f1": 0.7030878859857482,
+    "false_positives_per_minute": 0.4835924006908463,
+    "fn": 138,
+    "fp": 112,
+    "n": 3908,
+    "precision": 0.7254901960784313,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.6820276497695853,
+    "specificity": 0.9677605066206102,
+    "threshold": 0.5290762755,
+    "tn": 3362,
+    "tp": 296
+  },
+  "threshold": 0.5290762755,
+  "validation_metrics": {
+    "accuracy": 0.9499743458183684,
+    "auprc": 0.6261332028552472,
+    "auroc": 0.8396483118829026,
+    "balanced_accuracy": 0.7578195124709342,
+    "f1": 0.6313799621928167,
+    "false_positives_per_minute": 0.19262981574539362,
+    "fn": 149,
+    "fp": 46,
+    "n": 3898,
+    "precision": 0.784037558685446,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.5284810126582279,
+    "specificity": 0.9871580122836404,
+    "threshold": 0.5290762755,
+    "tn": 3536,
+    "tp": 167
+  },
+  "weights": [
+    0.3333333333333333,
+    0.3333333333333333,
+    0.3333333333333333
+  ]
+}

models/eegdino_medium/config.json

@@ -0,0 +1,130 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "eegdino_channel_names": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 11,
+  "format_version": 2,
+  "model_name": "eegdino_medium",
+  "parameters": 34445250,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "pretrained": {
+    "intentionally_not_loaded": [
+      "final_layer.* (new downstream binary IED head)"
+    ],
+    "loaded_tensors": 227,
+    "loaded_values": 33755456,
+    "missing_after_load": [
+      "final_layer.token_proj.0.weight",
+      "final_layer.token_proj.0.bias",
+      "final_layer.time_proj.0.weight",
+      "final_layer.time_proj.0.bias",
+      "final_layer.classifier.0.weight",
+      "final_layer.classifier.0.bias",
+      "final_layer.classifier.3.weight",
+      "final_layer.classifier.3.bias",
+      "final_layer.classifier.6.weight",
+      "final_layer.classifier.6.bias"
+    ],
+    "repo_id": "braindecode/eegdino-medium-pretrained",
+    "requested_revision": "191f73eb50d68a184b4cabb623938df914235d3c",
+    "resolved_revision": "191f73eb50d68a184b4cabb623938df914235d3c",
+    "unexpected_after_load": [],
+    "weights_file": "model.safetensors",
+    "weights_sha256": "17a73d056afde262d1be0cc21434ca751855691726a0500b3f3c809e2eecdf9e"
+  },
+  "release_name": "eegdino_medium",
+  "sfreq": 200,
+  "split_seed": 2026,
+  "subtype_labels": [],
+  "test_metrics": {
+    "accuracy": 0.9398669396110543,
+    "auprc": 0.8019567240287226,
+    "auroc": 0.9362860777493904,
+    "balanced_accuracy": 0.8683870171836076,
+    "f1": 0.7414741474147415,
+    "false_positives_per_minute": 0.5958549222797928,
+    "fn": 97,
+    "fp": 138,
+    "n": 3908,
+    "precision": 0.7094736842105264,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.7764976958525346,
+    "specificity": 0.9602763385146805,
+    "threshold": 0.619140625,
+    "tn": 3336,
+    "tp": 337
+  },
+  "training_strategy": "partial_last_2",
+  "validation_metrics": {
+    "accuracy": 0.9461262185736276,
+    "auprc": 0.6916968240811774,
+    "auroc": 0.8983352946165426,
+    "balanced_accuracy": 0.7903503099180855,
+    "f1": 0.6452702702702703,
+    "false_positives_per_minute": 0.35594639865996647,
+    "fn": 125,
+    "fp": 85,
+    "n": 3898,
+    "precision": 0.6920289855072463,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.6044303797468354,
+    "specificity": 0.9762702400893356,
+    "threshold": 0.619140625,
+    "tn": 3497,
+    "tp": 191
+  },
+  "validation_threshold_f1": 0.619140625,
+  "validation_threshold_sensitivity80": 0.056121826171875,
+  "window_samples": 800,
+  "window_seconds": 4.0
+}

models/eegdino_medium/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72320fedeed09b66508afaa79ce0ca114273673f6ce36adccedce87c8ce0ea1d
+size 137804848

models/eegpt/config.json

@@ -0,0 +1,122 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "eegpt_channel_names": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T7",
+    "T8",
+    "P7",
+    "P8",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 28,
+  "format_version": 2,
+  "model_name": "eegpt",
+  "parameters": 25589507,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "pretrained": {
+    "intentionally_not_loaded": [
+      "chans_id (downstream 19-channel identity buffer)",
+      "final_layer.* (new binary IED classification head)"
+    ],
+    "loaded_tensors": 102,
+    "loaded_values": 25287168,
+    "missing_after_load": [
+      "chans_id"
+    ],
+    "repo_id": "braindecode/eegpt-pretrained",
+    "resolved_revision": "e41cb3ae2ce4fd9eb736862292c91f8128d15618",
+    "unexpected_after_load": [],
+    "weights_file": "model.safetensors",
+    "weights_sha256": "fb34c20609983324679b9534f9d17a2289a232d0276dd2b8b7d5b088f876f621"
+  },
+  "release_name": "eegpt",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [],
+  "test_metrics": {
+    "accuracy": 0.9201637666325486,
+    "auprc": 0.65324809994628,
+    "auroc": 0.8640698911466086,
+    "balanced_accuracy": 0.767579570688379,
+    "f1": 0.6138613861386139,
+    "false_positives_per_minute": 0.5440414507772021,
+    "fn": 186,
+    "fp": 126,
+    "n": 3908,
+    "precision": 0.6631016042780749,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.5714285714285714,
+    "specificity": 0.9637305699481865,
+    "threshold": 0.8916015625,
+    "tn": 3348,
+    "tp": 248
+  },
+  "trainable_probe_parameters": 302339,
+  "training_strategy": "pretrained_encoder_frozen_ied_temporal_head",
+  "validation_metrics": {
+    "accuracy": 0.9420215495125706,
+    "auprc": 0.5628674715868012,
+    "auroc": 0.8119094063849486,
+    "balanced_accuracy": 0.7289665627716642,
+    "f1": 0.5703422053231939,
+    "false_positives_per_minute": 0.25125628140703515,
+    "fn": 166,
+    "fp": 60,
+    "n": 3898,
+    "precision": 0.7142857142857143,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.47468354430379744,
+    "specificity": 0.983249581239531,
+    "threshold": 0.8916015625,
+    "tn": 3522,
+    "tp": 150
+  },
+  "validation_threshold_f1": 0.8916015625,
+  "validation_threshold_sensitivity80": 0.007965087890625,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

models/eegpt/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e91757b80c98dd7325ea1068bff9dfe72bac577195f5b25b2570ce4d9f357226
+size 102373540

models/eegpt_linear_probe/config.json

@@ -0,0 +1,122 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "eegpt_channel_names": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T7",
+    "T8",
+    "P7",
+    "P8",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 19,
+  "format_version": 2,
+  "model_name": "eegpt_linear",
+  "parameters": 25320946,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "pretrained": {
+    "intentionally_not_loaded": [
+      "chans_id (downstream 19-channel identity buffer)",
+      "final_layer.* (new binary IED classification head)"
+    ],
+    "loaded_tensors": 102,
+    "loaded_values": 25287168,
+    "missing_after_load": [
+      "chans_id"
+    ],
+    "repo_id": "braindecode/eegpt-pretrained",
+    "resolved_revision": "e41cb3ae2ce4fd9eb736862292c91f8128d15618",
+    "unexpected_after_load": [],
+    "weights_file": "model.safetensors",
+    "weights_sha256": "fb34c20609983324679b9534f9d17a2289a232d0276dd2b8b7d5b088f876f621"
+  },
+  "release_name": "eegpt_linear_probe",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [],
+  "test_metrics": {
+    "accuracy": 0.7131525076765609,
+    "auprc": 0.3722106087915067,
+    "auroc": 0.7519221126525154,
+    "balanced_accuracy": 0.6702979871540794,
+    "f1": 0.32265861027190335,
+    "false_positives_per_minute": 4.119170984455959,
+    "fn": 167,
+    "fp": 954,
+    "n": 3908,
+    "precision": 0.21867321867321868,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.6152073732718893,
+    "specificity": 0.7253886010362695,
+    "threshold": 0.40234375,
+    "tn": 2520,
+    "tp": 267
+  },
+  "trainable_probe_parameters": 33778,
+  "training_strategy": "pretrained_encoder_frozen_linear_probe",
+  "validation_metrics": {
+    "accuracy": 0.8496664956387892,
+    "auprc": 0.23998456130581225,
+    "auroc": 0.7217963940659697,
+    "balanced_accuracy": 0.6715018482002135,
+    "f1": 0.3310502283105023,
+    "false_positives_per_minute": 1.7378559463986598,
+    "fn": 171,
+    "fp": 415,
+    "n": 3898,
+    "precision": 0.25892857142857145,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.4588607594936709,
+    "specificity": 0.884142936906756,
+    "threshold": 0.40234375,
+    "tn": 3167,
+    "tp": 145
+  },
+  "validation_threshold_f1": 0.40234375,
+  "validation_threshold_sensitivity80": 0.049224853515625,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

models/eegpt_linear_probe/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24ec011a90388079df98322244b96e076eeebf6b0671fe987a7d0d5cf66f9579
+size 101295352

models/iednet_lite/config.json

@@ -0,0 +1,89 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 13,
+  "format_version": 1,
+  "model_name": "iednet_lite",
+  "parameters": 245260,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "release_name": "iednet_lite",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [
+    "Centro-Parietal-IED",
+    "Frontal-IED",
+    "Generalized-IED",
+    "Occipital-IED",
+    "Temporal-IED"
+  ],
+  "test_metrics": {
+    "accuracy": 0.9201637666325486,
+    "auprc": 0.6847588452968619,
+    "auroc": 0.8793068455863041,
+    "balanced_accuracy": 0.7937914036861053,
+    "f1": 0.6372093023255814,
+    "false_positives_per_minute": 0.6563039723661486,
+    "fn": 160,
+    "fp": 152,
+    "n": 3908,
+    "precision": 0.6431924882629108,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.631336405529954,
+    "specificity": 0.9562464018422567,
+    "threshold": 0.6004377007484436,
+    "tn": 3322,
+    "tp": 274
+  },
+  "validation_metrics": {
+    "accuracy": 0.9502308876346844,
+    "auprc": 0.6136477369244443,
+    "auroc": 0.8519717080479754,
+    "balanced_accuracy": 0.752188332661903,
+    "f1": 0.6269230769230769,
+    "false_positives_per_minute": 0.17169179229480735,
+    "fn": 153,
+    "fp": 41,
+    "n": 3898,
+    "precision": 0.7990196078431373,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.5158227848101266,
+    "specificity": 0.9885538805136795,
+    "threshold": 0.6004377007484436,
+    "tn": 3541,
+    "tp": 163
+  },
+  "validation_threshold_f1": 0.6004377007484436,
+  "validation_threshold_sensitivity80": 0.017428677529096603,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

models/iednet_lite/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c5dc3c8e40050b69a07a7cf6a1ce7bbd2b12347f1b50d7feaf1fdfdd108b082
+size 1014056

models/resnet_attention/config.json

@@ -0,0 +1,89 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 11,
+  "format_version": 1,
+  "model_name": "resnet_attention",
+  "parameters": 4989538,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "release_name": "resnet_attention",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [
+    "Centro-Parietal-IED",
+    "Frontal-IED",
+    "Generalized-IED",
+    "Occipital-IED",
+    "Temporal-IED"
+  ],
+  "test_metrics": {
+    "accuracy": 0.932446264073695,
+    "auprc": 0.7018171290865336,
+    "auroc": 0.8998458595650639,
+    "balanced_accuracy": 0.7906183923232226,
+    "f1": 0.6666666666666666,
+    "false_positives_per_minute": 0.4058721934369603,
+    "fn": 170,
+    "fp": 94,
+    "n": 3908,
+    "precision": 0.7374301675977654,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.6082949308755761,
+    "specificity": 0.9729418537708693,
+    "threshold": 0.6944227814674377,
+    "tn": 3380,
+    "tp": 264
+  },
+  "validation_metrics": {
+    "accuracy": 0.9461262185736276,
+    "auprc": 0.5585556572790095,
+    "auroc": 0.7953542324845042,
+    "balanced_accuracy": 0.741298793545788,
+    "f1": 0.5992366412213741,
+    "false_positives_per_minute": 0.21356783919597988,
+    "fn": 159,
+    "fp": 51,
+    "n": 3898,
+    "precision": 0.7548076923076923,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.49683544303797467,
+    "specificity": 0.9857621440536013,
+    "threshold": 0.6944227814674377,
+    "tn": 3531,
+    "tp": 157
+  },
+  "validation_threshold_f1": 0.6944227814674377,
+  "validation_threshold_sensitivity80": 0.007963554933667183,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

models/resnet_attention/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:971fa0d2b38f0cc76ca479931872ae957123aeb51263de59b11098be1531b1e1
+size 20011088

pytorch/eegdino_medium/config.json

@@ -0,0 +1,130 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "eegdino_channel_names": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 11,
+  "format_version": 2,
+  "model_name": "eegdino_medium",
+  "parameters": 34445250,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "pretrained": {
+    "intentionally_not_loaded": [
+      "final_layer.* (new downstream binary IED head)"
+    ],
+    "loaded_tensors": 227,
+    "loaded_values": 33755456,
+    "missing_after_load": [
+      "final_layer.token_proj.0.weight",
+      "final_layer.token_proj.0.bias",
+      "final_layer.time_proj.0.weight",
+      "final_layer.time_proj.0.bias",
+      "final_layer.classifier.0.weight",
+      "final_layer.classifier.0.bias",
+      "final_layer.classifier.3.weight",
+      "final_layer.classifier.3.bias",
+      "final_layer.classifier.6.weight",
+      "final_layer.classifier.6.bias"
+    ],
+    "repo_id": "braindecode/eegdino-medium-pretrained",
+    "requested_revision": "191f73eb50d68a184b4cabb623938df914235d3c",
+    "resolved_revision": "191f73eb50d68a184b4cabb623938df914235d3c",
+    "unexpected_after_load": [],
+    "weights_file": "model.safetensors",
+    "weights_sha256": "17a73d056afde262d1be0cc21434ca751855691726a0500b3f3c809e2eecdf9e"
+  },
+  "release_name": "eegdino_medium",
+  "sfreq": 200,
+  "split_seed": 2026,
+  "subtype_labels": [],
+  "test_metrics": {
+    "accuracy": 0.9398669396110543,
+    "auprc": 0.8019567240287226,
+    "auroc": 0.9362860777493904,
+    "balanced_accuracy": 0.8683870171836076,
+    "f1": 0.7414741474147415,
+    "false_positives_per_minute": 0.5958549222797928,
+    "fn": 97,
+    "fp": 138,
+    "n": 3908,
+    "precision": 0.7094736842105264,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.7764976958525346,
+    "specificity": 0.9602763385146805,
+    "threshold": 0.619140625,
+    "tn": 3336,
+    "tp": 337
+  },
+  "training_strategy": "partial_last_2",
+  "validation_metrics": {
+    "accuracy": 0.9461262185736276,
+    "auprc": 0.6916968240811774,
+    "auroc": 0.8983352946165426,
+    "balanced_accuracy": 0.7903503099180855,
+    "f1": 0.6452702702702703,
+    "false_positives_per_minute": 0.35594639865996647,
+    "fn": 125,
+    "fp": 85,
+    "n": 3898,
+    "precision": 0.6920289855072463,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.6044303797468354,
+    "specificity": 0.9762702400893356,
+    "threshold": 0.619140625,
+    "tn": 3497,
+    "tp": 191
+  },
+  "validation_threshold_f1": 0.619140625,
+  "validation_threshold_sensitivity80": 0.056121826171875,
+  "window_samples": 800,
+  "window_seconds": 4.0
+}

pytorch/eegdino_medium/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e80ee1f66edcac1059b6e68c7458d8aa171167fbc9d50495daaafdc20e358491
+size 137840831

pytorch/eegpt/config.json

@@ -0,0 +1,122 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "eegpt_channel_names": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T7",
+    "T8",
+    "P7",
+    "P8",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 28,
+  "format_version": 2,
+  "model_name": "eegpt",
+  "parameters": 25589507,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "pretrained": {
+    "intentionally_not_loaded": [
+      "chans_id (downstream 19-channel identity buffer)",
+      "final_layer.* (new binary IED classification head)"
+    ],
+    "loaded_tensors": 102,
+    "loaded_values": 25287168,
+    "missing_after_load": [
+      "chans_id"
+    ],
+    "repo_id": "braindecode/eegpt-pretrained",
+    "resolved_revision": "e41cb3ae2ce4fd9eb736862292c91f8128d15618",
+    "unexpected_after_load": [],
+    "weights_file": "model.safetensors",
+    "weights_sha256": "fb34c20609983324679b9534f9d17a2289a232d0276dd2b8b7d5b088f876f621"
+  },
+  "release_name": "eegpt",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [],
+  "test_metrics": {
+    "accuracy": 0.9201637666325486,
+    "auprc": 0.65324809994628,
+    "auroc": 0.8640698911466086,
+    "balanced_accuracy": 0.767579570688379,
+    "f1": 0.6138613861386139,
+    "false_positives_per_minute": 0.5440414507772021,
+    "fn": 186,
+    "fp": 126,
+    "n": 3908,
+    "precision": 0.6631016042780749,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.5714285714285714,
+    "specificity": 0.9637305699481865,
+    "threshold": 0.8916015625,
+    "tn": 3348,
+    "tp": 248
+  },
+  "trainable_probe_parameters": 302339,
+  "training_strategy": "pretrained_encoder_frozen_ied_temporal_head",
+  "validation_metrics": {
+    "accuracy": 0.9420215495125706,
+    "auprc": 0.5628674715868012,
+    "auroc": 0.8119094063849486,
+    "balanced_accuracy": 0.7289665627716642,
+    "f1": 0.5703422053231939,
+    "false_positives_per_minute": 0.25125628140703515,
+    "fn": 166,
+    "fp": 60,
+    "n": 3898,
+    "precision": 0.7142857142857143,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.47468354430379744,
+    "specificity": 0.983249581239531,
+    "threshold": 0.8916015625,
+    "tn": 3522,
+    "tp": 150
+  },
+  "validation_threshold_f1": 0.8916015625,
+  "validation_threshold_sensitivity80": 0.007965087890625,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

pytorch/eegpt/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a0a55ed656049b4109d0e923ee0d461151a8a793995a24438717efecd2f24d5
+size 102394167

pytorch/eegpt_linear_probe/config.json

@@ -0,0 +1,122 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "eegpt_channel_names": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T7",
+    "T8",
+    "P7",
+    "P8",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 19,
+  "format_version": 2,
+  "model_name": "eegpt_linear",
+  "parameters": 25320946,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "pretrained": {
+    "intentionally_not_loaded": [
+      "chans_id (downstream 19-channel identity buffer)",
+      "final_layer.* (new binary IED classification head)"
+    ],
+    "loaded_tensors": 102,
+    "loaded_values": 25287168,
+    "missing_after_load": [
+      "chans_id"
+    ],
+    "repo_id": "braindecode/eegpt-pretrained",
+    "resolved_revision": "e41cb3ae2ce4fd9eb736862292c91f8128d15618",
+    "unexpected_after_load": [],
+    "weights_file": "model.safetensors",
+    "weights_sha256": "fb34c20609983324679b9534f9d17a2289a232d0276dd2b8b7d5b088f876f621"
+  },
+  "release_name": "eegpt_linear_probe",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [],
+  "test_metrics": {
+    "accuracy": 0.7131525076765609,
+    "auprc": 0.3722106087915067,
+    "auroc": 0.7519221126525154,
+    "balanced_accuracy": 0.6702979871540794,
+    "f1": 0.32265861027190335,
+    "false_positives_per_minute": 4.119170984455959,
+    "fn": 167,
+    "fp": 954,
+    "n": 3908,
+    "precision": 0.21867321867321868,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.6152073732718893,
+    "specificity": 0.7253886010362695,
+    "threshold": 0.40234375,
+    "tn": 2520,
+    "tp": 267
+  },
+  "trainable_probe_parameters": 33778,
+  "training_strategy": "pretrained_encoder_frozen_linear_probe",
+  "validation_metrics": {
+    "accuracy": 0.8496664956387892,
+    "auprc": 0.23998456130581225,
+    "auroc": 0.7217963940659697,
+    "balanced_accuracy": 0.6715018482002135,
+    "f1": 0.3310502283105023,
+    "false_positives_per_minute": 1.7378559463986598,
+    "fn": 171,
+    "fp": 415,
+    "n": 3898,
+    "precision": 0.25892857142857145,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.4588607594936709,
+    "specificity": 0.884142936906756,
+    "threshold": 0.40234375,
+    "tn": 3167,
+    "tp": 145
+  },
+  "validation_threshold_f1": 0.40234375,
+  "validation_threshold_sensitivity80": 0.049224853515625,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

pytorch/eegpt_linear_probe/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a51fd32505d51d80677ed6504b94d0b8a6718cb1de21a07cd3253ed1e1a3405a
+size 101312967

pytorch/iednet_lite/config.json

@@ -0,0 +1,89 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 13,
+  "format_version": 1,
+  "model_name": "iednet_lite",
+  "parameters": 245260,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "release_name": "iednet_lite",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [
+    "Centro-Parietal-IED",
+    "Frontal-IED",
+    "Generalized-IED",
+    "Occipital-IED",
+    "Temporal-IED"
+  ],
+  "test_metrics": {
+    "accuracy": 0.9201637666325486,
+    "auprc": 0.6847588452968619,
+    "auroc": 0.8793068455863041,
+    "balanced_accuracy": 0.7937914036861053,
+    "f1": 0.6372093023255814,
+    "false_positives_per_minute": 0.6563039723661486,
+    "fn": 160,
+    "fp": 152,
+    "n": 3908,
+    "precision": 0.6431924882629108,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.631336405529954,
+    "specificity": 0.9562464018422567,
+    "threshold": 0.6004377007484436,
+    "tn": 3322,
+    "tp": 274
+  },
+  "validation_metrics": {
+    "accuracy": 0.9502308876346844,
+    "auprc": 0.6136477369244443,
+    "auroc": 0.8519717080479754,
+    "balanced_accuracy": 0.752188332661903,
+    "f1": 0.6269230769230769,
+    "false_positives_per_minute": 0.17169179229480735,
+    "fn": 153,
+    "fp": 41,
+    "n": 3898,
+    "precision": 0.7990196078431373,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.5158227848101266,
+    "specificity": 0.9885538805136795,
+    "threshold": 0.6004377007484436,
+    "tn": 3541,
+    "tp": 163
+  },
+  "validation_threshold_f1": 0.6004377007484436,
+  "validation_threshold_sensitivity80": 0.017428677529096603,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

pytorch/iednet_lite/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:383fe1de4aa8cf01b5f1c0a6734d92214ec0e7f96a6cd18a50fa52c52ccb210c
+size 1041083

pytorch/resnet_attention/config.json

@@ -0,0 +1,89 @@
+{
+  "binary_labels": [
+    "Non-IED",
+    "IED"
+  ],
+  "channels": [
+    "Fp1",
+    "Fp2",
+    "F3",
+    "F4",
+    "C3",
+    "C4",
+    "P3",
+    "P4",
+    "O1",
+    "O2",
+    "F7",
+    "F8",
+    "T3",
+    "T4",
+    "T5",
+    "T6",
+    "Fz",
+    "Cz",
+    "Pz"
+  ],
+  "epoch": 11,
+  "format_version": 1,
+  "model_name": "resnet_attention",
+  "parameters": 4989538,
+  "preprocessing": {
+    "bandpass_hz": [
+      1.0,
+      45.0
+    ],
+    "normalization": "global_window_zscore_clip8",
+    "reference": "average"
+  },
+  "release_name": "resnet_attention",
+  "sfreq": 250,
+  "split_seed": 2026,
+  "subtype_labels": [
+    "Centro-Parietal-IED",
+    "Frontal-IED",
+    "Generalized-IED",
+    "Occipital-IED",
+    "Temporal-IED"
+  ],
+  "test_metrics": {
+    "accuracy": 0.932446264073695,
+    "auprc": 0.7018171290865336,
+    "auroc": 0.8998458595650639,
+    "balanced_accuracy": 0.7906183923232226,
+    "f1": 0.6666666666666666,
+    "false_positives_per_minute": 0.4058721934369603,
+    "fn": 170,
+    "fp": 94,
+    "n": 3908,
+    "precision": 0.7374301675977654,
+    "prevalence": 0.11105424769703173,
+    "sensitivity": 0.6082949308755761,
+    "specificity": 0.9729418537708693,
+    "threshold": 0.6944227814674377,
+    "tn": 3380,
+    "tp": 264
+  },
+  "validation_metrics": {
+    "accuracy": 0.9461262185736276,
+    "auprc": 0.5585556572790095,
+    "auroc": 0.7953542324845042,
+    "balanced_accuracy": 0.741298793545788,
+    "f1": 0.5992366412213741,
+    "false_positives_per_minute": 0.21356783919597988,
+    "fn": 159,
+    "fp": 51,
+    "n": 3898,
+    "precision": 0.7548076923076923,
+    "prevalence": 0.08106721395587481,
+    "sensitivity": 0.49683544303797467,
+    "specificity": 0.9857621440536013,
+    "threshold": 0.6944227814674377,
+    "tn": 3531,
+    "tp": 157
+  },
+  "validation_threshold_f1": 0.6944227814674377,
+  "validation_threshold_sensitivity80": 0.007963554933667183,
+  "window_samples": 1000,
+  "window_seconds": 4.0
+}

pytorch/resnet_attention/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df088c4fd087b453ef3aca76f54a975a69f015324f8d862d2d4ba5316cb91e1a
+size 20037039

results/benchmark_results.csv

@@ -0,0 +1,8 @@
+model,threshold,n,prevalence,auroc,auprc,accuracy,balanced_accuracy,f1,precision,sensitivity,specificity,false_positives_per_minute,tn,fp,fn,tp
+iednet_lite,0.6004377007484436,3908,0.11105424769703173,0.8793068455863041,0.6847588452968619,0.9201637666325486,0.7937914036861053,0.6372093023255814,0.6431924882629108,0.631336405529954,0.9562464018422567,0.6563039723661486,3322,152,160,274
+resnet_attention,0.6944227814674377,3908,0.11105424769703173,0.8998458595650639,0.7018171290865336,0.932446264073695,0.7906183923232226,0.6666666666666666,0.7374301675977654,0.6082949308755761,0.9729418537708693,0.4058721934369603,3380,94,170,264
+eegpt,0.8916015625,3908,0.11105424769703173,0.8640698911466086,0.65324809994628,0.9201637666325486,0.767579570688379,0.6138613861386139,0.6631016042780749,0.5714285714285714,0.9637305699481865,0.5440414507772021,3348,126,186,248
+eegdino_medium,0.619140625,3908,0.11105424769703173,0.9362860777493904,0.8019567240287226,0.9398669396110543,0.8683870171836076,0.7414741474147415,0.7094736842105264,0.7764976958525346,0.9602763385146805,0.5958549222797928,3336,138,97,337
+ensemble_eegpt,0.5290762755,3908,0.11105424769703173,0.9004447787249058,0.7451331821970812,0.936028659160696,0.8248940781950977,0.7030878859857482,0.7254901960784313,0.6820276497695853,0.9677605066206102,0.4835924006908463,3362,112,138,296
+ensemble_eegdino,0.5274549233333333,3908,0.11105424769703173,0.9261677928734589,0.7895565635533457,0.9437052200614124,0.8463503736778014,0.7399527186761229,0.7597087378640777,0.7211981566820277,0.9715025906735751,0.4274611398963731,3375,99,121,313
+ensemble_4model,0.5273836475,3908,0.11105424769703173,0.9200864088462283,0.7888269120699914,0.9483111566018424,0.8600306689058151,0.7623529411764706,0.7788461538461539,0.7465437788018433,0.973517559009787,0.39723661485319517,3382,92,110,324