# Spikeinterface

> SpikeInterface

- Skill: `hughyau/spikeinterface` (Agent Skill, multi-file: 775 files)
- Install (CLI): `npx skillmds@latest add hughyau/spikeinterface`
- Raw SKILL.md: https://api.skillmd.com/api/skills/hughyau/spikeinterface/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: HughYau (https://skillmd.com/u/hughyau)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/hughyau/spikeinterface

---


# SpikeInterface

SpikeInterface provides a modular API to move from raw extracellular recordings to sorted, analyzed, curated, and visualized units.

## Version

Built against: `spikeinterface==0.103.3`
Python: `3.13.5`
> Runtime import/execution status in this build: `[UNVERIFIED: install denied in selected environment]` (see `assets/version.txt`).

## Environment Gate

Before any install command, confirm environment + permission and record in `assets/version.txt`:

```text
environment: <env name/path>
python_executable: <path or `python`>
install_permission: yes|no
install_scope: none|current-env|named-env|new-env
package_manager: pip|conda|mamba|uv|other
coverage_profile: workflow|dictionary|hybrid
```

Current build metadata is already captured in `assets/version.txt`.

## Installation

```bash
# Requires install_permission: yes
pip install spikeinterface

# Optional extras are task-dependent and not enforced in this skill build:
# [REQUIRES: sorter-specific external binaries/containers for some spikeinterface.sorters workflows]
# [REQUIRES: plotting backend dependencies for some spikeinterface.widgets backends]
```

---

## Core I/O and Synthetic Data

```python
import numpy as np
import spikeinterface as si

# tested against spikeinterface==0.103.3
# Build an in-memory recording and query traces
traces = np.random.normal(0, 5, size=(3000, 4)).astype("float32")
rec = si.NumpyRecording([traces], sampling_frequency=30000.0)
print(rec.get_num_channels(), rec.get_num_segments())

# Generate toy ground truth pair
recording, sorting = si.generate_ground_truth_recording(num_channels=4, num_units=6, durations=[2.0], seed=0)
print(recording.get_num_channels(), sorting.get_num_units())
```

See `references/core-io-and-synthetic.md` for signatures and pitfalls around `NumpyRecording`, binary I/O, `load_extractor`, and synthetic generators.

---

## Preprocessing and Motion

```python
import spikeinterface.preprocessing as spre
import spikeinterface as si

# tested against spikeinterface==0.103.3
recording, _ = si.generate_ground_truth_recording(num_channels=4, durations=[2.0], seed=0)
rec_bp = spre.bandpass_filter(recording, freq_min=300.0, freq_max=6000.0)
print(rec_bp.get_num_channels())

# [VERSION: changed in 0.103.x — unsigned data is not auto-cast; use unsigned_to_signed() explicitly]
```

See `references/preprocessing-and-motion.md` for preprocessing pipelines, motion correction entry points, and version-sensitive behavior.

---

## SortingAnalyzer and Metrics

```python
import spikeinterface as si

# tested against spikeinterface==0.103.3
recording, sorting = si.generate_ground_truth_recording(num_channels=4, num_units=8, durations=[3.0], seed=0)
analyzer = si.create_sorting_analyzer(sorting=sorting, recording=recording, format="memory", return_in_uV=True)
analyzer.compute("random_spikes", max_spikes_per_unit=200)
analyzer.compute("waveforms", ms_before=1.0, ms_after=2.0)
qm = analyzer.compute("quality_metrics", metric_names=["snr", "presence_ratio"]).get_data()
print(qm.shape)

# [VERSION: changed in 0.103.x — prefer return_in_uV over return_scaled]
```

See `references/sorting-analyzer-and-metrics.md` for extension dependencies, signature details, and metrics workflow patterns.

---

## Running Sorters

```python
import spikeinterface as si
import spikeinterface.sorters as ss

# tested against spikeinterface==0.103.3
recording, _ = si.generate_ground_truth_recording(num_channels=4, durations=[1.0], seed=0)
print("available", ss.available_sorters())
print("installed", ss.installed_sorters())

# [REQUIRES: sorter backends and optional external installations]
# sorting = ss.run_sorter("kilosort2_5", recording, folder="sorter_out", with_output=True)
```

See `references/sorters-and-execution.md` for local/container runner signatures and safe execution patterns.

---

## Comparison, Curation, and Widgets

```python
import spikeinterface as si
import spikeinterface.comparison as scmp
import spikeinterface.curation as scur

# tested against spikeinterface==0.103.3
recording, gt_sorting = si.generate_ground_truth_recording(num_channels=4, num_units=6, durations=[2.0], seed=0)
comp = scmp.compare_sorter_to_ground_truth(gt_sorting, gt_sorting, exhaustive_gt=True)
print(comp.count_well_detected_units(well_detected_score=0.8))

analyzer = si.create_sorting_analyzer(gt_sorting, recording, format="memory")
analyzer.compute("random_spikes", max_spikes_per_unit=200)
analyzer.compute("waveforms", ms_before=1.0, ms_after=2.0)
analyzer.compute("templates")
analyzer.compute("noise_levels")
metrics = analyzer.compute("quality_metrics", metric_names=["snr", "presence_ratio"]).get_data()
labels = scur.threshold_metrics_label_units(metrics, thresholds={"snr": (">=", 5)})
print(labels.columns)
```

See `references/comparison-curation-widgets.md` for comparison classes, curation model APIs, and widget function aliases.

---

## Verification (Medium+)

```bash
python opensci-skill/scripts/verify-snippets.py --root spikeinterface --fail-fast
```

`[UNVERIFIED: verify against installed runtime in an environment where spikeinterface and runtime deps are available]`.

## API Dictionary (Dictionary/Hybrid)

- `assets/symbol-index.md` - module-level dictionary navigation
- `assets/symbol-index.jsonl` - machine-readable symbol lookup
- `assets/symbol-cards/` - per-module symbol cards with signatures and source anchors

## Quick Reference

| Function / Class | Purpose |
|-----------------|---------|
| `NumpyRecording(...)` | Create an in-memory `Recording` from NumPy arrays. |
| `generate_ground_truth_recording(...)` | Produce synthetic recording/sorting pairs for testing and tutorials. |
| `create_sorting_analyzer(...)` | Pair recording+sorting and orchestrate extension computations. |
| `run_sorter(...)` | Execute a sorter backend (local or container depending on config). |
| `compare_sorter_to_ground_truth(...)` | Score sorter output against reference sorting. |
| `threshold_metrics_label_units(...)` | Apply metric thresholds to produce curation labels. |

## Module Map

| Submodule | Contents | Notes |
|-----------|----------|-------|
| `spikeinterface.core` | Base recording/sorting classes, I/O, synthetic generation, sorting analyzer | large API surface |
| `spikeinterface.preprocessing` | Filtering, scaling, bad-channel handling, motion correction, pipeline API | mixed eager export + deprecation `__getattr__` |
| `spikeinterface.sorters` | Sorter registry and execution wrappers | external tool dependencies for many sorters |
| `spikeinterface.metrics` | Quality/template/spiketrain metrics via analyzer extensions | top-level star exports |
| `spikeinterface.comparison` | Pairwise and multi-sorter comparisons | agreement/confusion/performance tooling |
| `spikeinterface.curation` | Merge/split/threshold/model-based curation helpers | model workflows use pydantic/skops integrations |
| `spikeinterface.widgets` | Plotting widgets + `plot_*` aliases | backend-dependent behavior |

Import style: mixed (eager star imports in several `__init__.py`, plus lazy/deprecation `__getattr__` in `extractors` and `preprocessing`).

See `assets/module-map.md` for full submodule inventory.

## References

- `references/core-io-and-synthetic.md` - in-memory/binary I/O and synthetic data generation.
- `references/preprocessing-and-motion.md` - preprocessing wrappers, pipelines, and motion correction.
- `references/sorting-analyzer-and-metrics.md` - analyzer lifecycle, extension dependencies, metrics retrieval.
- `references/sorters-and-execution.md` - sorter registry, local/container execution, and result loading.
- `references/comparison-curation-widgets.md` - comparison classes, curation APIs, and plotting aliases.