sparxml 0.1.0__py3-none-any.whl

sparx/__init__.py

@@ -0,0 +1,69 @@
+"""Sparx: spiking neural networks in JAX and Flax, trained, simulated and served through dew.
+
+Networks are Flax linen modules over time-major spike trains `[T, ...]`.
+
+Deep spiking networks:
+
+- `sparx.nn`: Flax layers over the neuron models, parallel spiking neurons and delayed synapses.
+- `sparx.models`: architectures built from them (`SEWResNet`, `SpikingMLP`).
+- `sparx.surrogate`: the spike and its surrogate gradients.
+- `sparx.encode`: the encoders that turn data into spike trains.
+- `sparx.losses` and `sparx.rates`: losses over time, firing-rate readouts and penalties.
+- `sparx.learn`: rules beyond backpropagation through time (e-prop, OTTT, EventProp, conversion).
+
+Circuits in physical units:
+
+- `sparx.dynamics`: neuron, synapse and plasticity models as pure JAX, the dimensionless family deep
+  networks train with and the physical one, and `run`, which scans any of them over time.
+- `sparx.graph`: populations and projections wired into a `Network`, `simulate`, and connectomes.
+- `sparx.spiketrains`: statistics of and distances between recorded spike trains.
+
+Around them:
+
+- `sparx.objectives`: the objectives that train spiking networks under dew's `Trainer`, with
+  `sparx.metrics` (their accuracy), `sparx.tasks` (the trained classifier `dew.pipeline` loads) and
+  `sparx.config` (`SNNRunConfig`, the run a recipe trains and `run.json` records).
+- `sparx.datasets`: spiking datasets as dew datasets (SHD).
+- `sparx.serve`: `StreamServer`, many streaming sessions in one batch.
+- `sparx.nir`: exchange through the Neuromorphic Intermediate Representation.
+
+`sparx.graph`, `sparx.learn`, `sparx.objectives`, `sparx.metrics`,
+`sparx.tasks`, `sparx.config`, `sparx.datasets`, `sparx.serve` and
+`sparx.nir` load on first access (`sparx.graph.Network` after `import
+sparx`). The graph, the objectives and the datasets import dew's trainer
+and data stack, about 0.9 s on a 4-core CPU, which a script that only
+trains a network in its own loop does not need.
+"""
+
+from __future__ import annotations
+
+import importlib
+from types import ModuleType
+from typing import TYPE_CHECKING
+
+from sparx import dynamics, encode, losses, models, nn, rates, spiketrains, surrogate
+from sparx.dynamics import run
+from sparx.rates import firing_rates, rate_penalty
+from sparx.surrogate import spike
+
+if TYPE_CHECKING:
+    from sparx import config, datasets, graph, learn, metrics, nir, objectives, serve, tasks
+
+__version__ = "0.1.0"
+
+_LAZY = ("config", "datasets", "graph", "learn", "metrics", "nir", "objectives", "serve", "tasks")
+
+__all__ = ["__version__", "config", "datasets", "dynamics", "encode", "firing_rates", "graph", "learn",
+           "losses", "metrics", "models", "nir", "nn", "objectives", "rate_penalty", "rates", "run", "serve",
+           "spike", "spiketrains", "surrogate", "tasks"]
+
+
+def __getattr__(name: str) -> ModuleType:
+    # PEP 562: importing the submodule binds it on the package, so this runs once per name.
+    if name in _LAZY:
+        return importlib.import_module(f"sparx.{name}")
+    raise AttributeError(f"module 'sparx' has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(_LAZY))

sparx/config.py

@@ -0,0 +1,102 @@
+"""The run a spiking classifier trains as, one typed record that `run.json` holds.
+
+    python recipes/snn/train.py --data.channels 140 --trainer.batch-size 64 --trainer.steps 3000 \\
+        --model.hidden 128 --model.classes 20 --model.delays 15 \\
+        --objective.schedules '{"sigma": {"class": "linear", "fields": {"peak": 7.5, "end": 0.5}}}'
+    dew train runs/<name>/run.json --trust sparx --set trainer.steps=6000   # the same run, trained on
+
+`SNNRunConfig` is dew's `RunConfig` with the data, encoder and sample field
+a spiking classifier reads. Its model is any spiking model over `[T, B,
+channels]` by import path (`--model my_package.models:Net`), each of its
+fields a flag and the neuron template a record (`--model.neuron '{"class":
+"sparx.nn.neurons:LIF", "fields": {"tau": 3.0}}'`). The objective is
+`SpikingClassifierObjective`, each of its keyword arguments a flag
+(`--objective.readout max`), and `prepare` builds it around the model, the
+sample field and the encoder. Parameter groups with optimizers of their own
+are dew's (`--optim.param-groups`).
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from dew.config import ModelConfig, ObjectiveConfig, OptimConfig, Prepared, RunConfig
+from dew.data import Loading
+from dew.inputs import Field
+from dew.registry import import_path
+
+from sparx.datasets import SHD, write_synthetic_shd
+from sparx.encode import EventsEncoder, SpikeEncoder
+from sparx.metrics import Accuracy
+from sparx.models import SpikingMLP
+from sparx.nn.neurons import ALIF
+from sparx.objectives import SpikingClassifierObjective
+from sparx.registry import spike_encoders
+
+if TYPE_CHECKING:
+    # tyro reads the runtime annotation, a union of the encoders, and a type
+    # checker cannot read a variable in a type expression, so both get what
+    # they need, as dew.config's DataSpec does.
+    type EncoderSpec = SpikeEncoder
+else:
+    EncoderSpec = spike_encoders.union
+
+__all__ = ["SNNRunConfig"]
+
+
+@dataclasses.dataclass(frozen=True)
+class SNNRunConfig(RunConfig):
+    """A run of `SpikingClassifierObjective` on SHD, with the encoder and the field it reads."""
+
+    objective: ObjectiveConfig = dataclasses.field(default_factory=lambda: ObjectiveConfig(
+        import_path(SpikingClassifierObjective), {"readout": "max", "rates": {"lower": 0.01, "upper": 0.3}}))
+    """The objective and its keyword arguments (`--objective.readout mean`)."""
+    model: ModelConfig = dataclasses.field(default_factory=lambda: ModelConfig(import_path(SpikingMLP), {
+        "hidden": [128], "classes": 20, "dtype": "float32",
+        "neuron": {"class": import_path(ALIF), "fields": {
+            "tau": 5.0, "tau_adapt": 20.0, "beta": 0.2, "learn_tau": True, "detach_reset": True}}}))
+    data: SHD = dataclasses.field(default_factory=SHD)
+    optim: OptimConfig = dataclasses.field(default_factory=lambda: OptimConfig(learning_rate=2e-3,
+                                                                                clip_grads=1.0))
+    encoder: EncoderSpec = dataclasses.field(default_factory=EventsEncoder)
+    """How a batch field becomes spikes; `encoder:rate --encoder.steps 8` for static data."""
+    sample: str = "spikes"
+    """The batch field the encoder reads."""
+    smoke: bool = False
+    """Train a small network for a few steps on synthetic SHD-layout recordings; nothing is downloaded."""
+
+    def smoked(self) -> SNNRunConfig:
+        """This run shrunk to a few seconds on CPU, reading synthetic recordings.
+
+        The recordings go under the checkpoint directory, so the run reads
+        them there and leaves nothing elsewhere. The run it returns is no
+        longer a smoke run: it records the small run as it trains, so its
+        `run.json` trains that run again.
+        """
+        cache = write_synthetic_shd(Path(self.trainer.checkpoint_dir) / "synthetic-shd")
+        synthetic = SHD(steps=20, channels=70, cache=str(cache),
+                        loading=Loading(workers=0, threads=1, read_buffer=1))
+        model = dataclasses.replace(self.model, fields={**self.model.fields, "hidden": [16], "classes": 2})
+        trainer = dataclasses.replace(self.trainer, batch_size=16, steps=8, log_every=4, eval_every=8,
+                                      checkpoint_every=8)
+        return dataclasses.replace(self, data=synthetic, model=model, trainer=trainer, smoke=False)
+
+    def sample_field(self) -> Field:
+        """The batch field the encoder reads, at the per-record shape the dataset writes."""
+        return Field(self.sample, (self.data.steps, self.data.channels))
+
+    def prepare(self) -> Prepared:
+        """The objective the run names, around its model, the sample field and the encoder, on SHD.
+
+        Its schedules run over the run's steps unless the run states
+        `schedule_steps`.
+        """
+        run = self.smoked() if self.smoke else self
+        dataset = run.data.load(batch=run.trainer.batch_size)
+        derived = ({} if "schedule_steps" in run.objective.fields
+                   else {"schedule_steps": run.trainer.total_steps(dataset)})
+        objective = run.objective.build(model=run.model.build(), sample=run.sample_field(),
+                                        encoder=run.encoder, **derived)
+        return Prepared(run, lambda name: run.train(objective, dataset, name=name, metrics=[Accuracy()]))

sparx/datasets.py

@@ -0,0 +1,246 @@
+"""Neuromorphic datasets as dense, binned spike counts.
+
+`shd` reads the Spiking Heidelberg Digits (Cramer et al., "The Heidelberg
+Spiking Data Sets for the Systematic Evaluation of Spiking Neural Networks",
+IEEE TNNLS 2020): spoken digits 0-9 in English and German, 20 classes,
+rendered as spikes on 700 cochlear channels. Each record becomes a
+`[steps, channels]` array of spike counts, batch-major as dew's loaders
+expect; `sparx.encode.EventsEncoder()` moves the time axis to the front. `SHD` is the
+same data as a dew dataset spec, which a run's `data` holds (`--data.channels
+140` on the recipe's command line). `write_synthetic_shd` writes small files
+in SHD's layout, which smoke runs and tests read in its place.
+
+`mnist` reads MNIST (LeCun et al. 1998) or Fashion-MNIST (Xiao et al. 2017)
+as uint8 images and labels.
+
+`holdout` splits records into a part to train on and a part to validate on.
+
+Reading the files needs h5py (`pip install "sparxml[datasets]"`).
+"""
+
+from __future__ import annotations
+
+import gzip
+import shutil
+import urllib.request
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+import numpy as np
+from dew.data import Dataset, DatasetSpec
+from dew.data.dataset import Tokenize
+from dew.files import replacing
+from numpy.typing import ArrayLike
+
+__all__ = ["MNIST_URLS", "SHD", "SHD_URL", "Binning", "bin_events", "holdout", "mnist", "shd",
+           "write_synthetic_shd"]
+
+SHD_URL = "https://zenkelab.org/datasets/shd/{split}.h5.gz"
+MNIST_URLS = {
+    "mnist": "https://storage.googleapis.com/cvdf-datasets/mnist/{name}.gz",
+    "fashion": "https://raw.githubusercontent.com/zalandoresearch/fashion-mnist/master/data/fashion/{name}.gz",
+}
+"""Where `mnist` fetches each IDX file: the MNIST mirror and Zalando's Fashion-MNIST repository."""
+_CHANNELS = 700
+
+
+type Binning = Literal["grid", "events"]
+"""How `bin_events` cuts time into steps.
+
+- `grid`: equal bins from time 0, the usual binning.
+- `events`: SpikingJelly's SHD frames by duration, in the releases SNN-delays
+  (Hammouamri et al., ICLR 2024) trained on: each step opens at the first
+  event not yet counted and holds every event within one step's duration of
+  it. Silences longer than a step are dropped, so a recording is shorter
+  than on the grid and its timing is compressed; times are scaled to
+  milliseconds in the file's own float16, as theirs are.
+"""
+
+
+def bin_events(times: ArrayLike, units: ArrayLike, steps: int, max_time: float, channels: int,
+               source_channels: int = _CHANNELS, binning: Binning = "grid") -> np.ndarray:
+    """Count one record's spikes into `[steps, channels]` uint8 bins.
+
+    A step lasts `max_time / steps`. On the `grid`, time `[0, max_time)` is
+    cut into `steps` equal bins and events at or after `max_time` are
+    dropped; with `binning="events"` steps open at events (`Binning`) and
+    steps past the `steps`-th are dropped. `channels` must divide
+    `source_channels`; adjacent source channels are pooled into each output
+    channel. Counts saturate at 255.
+    """
+    if source_channels % channels:
+        raise ValueError(f"channels must divide {source_channels}, not {channels}")
+    if binning == "grid":
+        step = np.floor(np.asarray(times, np.float64) / max_time * steps).astype(np.int64)
+    elif binning == "events":
+        step = _event_frames(np.asarray(times), round(1000 * max_time / steps, 9))
+    else:
+        raise ValueError(f"binning must be grid or events, not {binning!r}")
+    kept = step < steps
+    counts = np.zeros((steps, channels), np.int64)
+    np.add.at(counts, (step[kept], np.asarray(units, np.int64)[kept] // (source_channels // channels)), 1)
+    return np.minimum(counts, 255).astype(np.uint8)
+
+
+def _event_frames(times: np.ndarray, duration: float) -> np.ndarray:
+    """Each event's frame under `Binning`'s `events`, `duration` in ms.
+
+    SpikingJelly's `integrate_events_by_fixed_duration_shd` scans the events
+    once: a frame starts at event `l` and takes every following event `r`
+    while `t[r] - t[l] <= duration`. Its arithmetic is kept, `1000 * t` in
+    the times' dtype, so the frames are theirs exactly.
+    """
+    t = 1000 * times
+    if t.size == 0:
+        return np.zeros(0, np.int64)
+    starts = [0]
+    while True:
+        start = starts[-1]
+        beyond = t[start:] - t[start] > duration
+        if not beyond.any():
+            break
+        starts.append(start + int(np.argmax(beyond)))
+    return np.searchsorted(np.asarray(starts), np.arange(t.size), side="right") - 1
+
+
+def _fetched(url: str, path: Path) -> Path:
+    """`path`, downloaded from `url` the first time and published whole (`dew.files.replacing`), so an
+    interrupted download leaves nothing a later call would read."""
+    if not path.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with replacing(path) as partial:
+            urllib.request.urlretrieve(url, str(partial))
+    return path
+
+
+def _download(split: str, cache: Path) -> Path:
+    """The decompressed `{split}.h5` in `cache`, fetched and decompressed once."""
+    path = cache / f"{split}.h5"
+    if not path.exists():
+        archive = _fetched(SHD_URL.format(split=split), cache / f"{split}.h5.gz")
+        with gzip.open(archive) as source, replacing(path) as partial, open(partial, "wb") as target:
+            shutil.copyfileobj(source, target)
+    return path
+
+
+def mnist(split: Literal["train", "test"], *, fashion: bool = False,
+          cache: str | Path | None = None) -> dict[str, np.ndarray]:
+    """MNIST `split`, or Fashion-MNIST's with `fashion=True`: uint8 images `[N, 28, 28]` under `"image"`
+    and int32 labels `[N]` under `"label"`.
+
+    The gzipped IDX files download once to `cache`, `~/.cache/sparx` by
+    default, Fashion-MNIST's under `fashion/`.
+    """
+    root = Path(cache) if cache is not None else Path.home() / ".cache" / "sparx"
+    root = root / "fashion" if fashion else root
+    prefix = "train" if split == "train" else "t10k"
+    arrays = []
+    for name, header in ((f"{prefix}-images-idx3-ubyte", 16), (f"{prefix}-labels-idx1-ubyte", 8)):
+        path = _fetched(MNIST_URLS["fashion" if fashion else "mnist"].format(name=name), root / f"{name}.gz")
+        with gzip.open(path) as file:
+            arrays.append(np.frombuffer(file.read(), np.uint8, offset=header))
+    images, labels = arrays
+    return {"image": images.reshape(-1, 28, 28), "label": labels.astype(np.int32)}
+
+
+def shd(split: Literal["train", "test"], steps: int = 100, max_time: float = 1.4, channels: int = 700,
+        cache: str | Path | None = None, path: str | Path | None = None,
+        binning: Binning = "grid") -> dict[str, np.ndarray]:
+    """The SHD `split` as `{"spikes": uint8 [N, steps, channels], "label": int32 [N]}`.
+
+    `steps` bins over the first `max_time` seconds. Every spike of the train
+    split falls before 1.37 s, and 100 steps of 14 ms is the binning of
+    Zenke's SpyTorch SHD tutorial. `binning="events"` is SNN-delays' binning
+    (`Binning`); at 10 ms its recordings last at most 124 steps (train) and
+    105 (test), so `steps=124, max_time=1.24` keeps every event.
+    The file is read from `path` when given, otherwise downloaded once into
+    `cache` (default `~/.cache/sparx`; 131 MB for train, 38 MB for test) and
+    decompressed beside it.
+    """
+    import h5py
+
+    if path is None:
+        path = _download(f"shd_{split}", Path.home() / ".cache" / "sparx" if cache is None else Path(cache))
+    with h5py.File(path, "r") as file:
+        nodes = [file.get(name) for name in ("spikes/times", "spikes/units", "labels")]
+        times, units, labels = nodes
+        if not (isinstance(times, h5py.Dataset) and isinstance(units, h5py.Dataset)
+                and isinstance(labels, h5py.Dataset)):
+            raise ValueError(f"{path} lacks SHD's spikes/times, spikes/units and labels datasets")
+        spikes = np.stack([bin_events(times[i], units[i], steps, max_time, channels, binning=binning)
+                           for i in range(len(times))])
+        return {"spikes": spikes, "label": np.asarray(labels, np.int32)}
+
+
+@dataclass(frozen=True)
+class SHD(DatasetSpec):
+    """The Spiking Heidelberg Digits as a dew dataset: the train split to train on, the test
+    split to validate on (SHD has no separate validation split), binned by `shd`.
+
+    Records are `{"spikes": uint8 [steps, channels], "label": int32}`; `sparx.encode.EventsEncoder()`
+    turns a batch into the network's time-major input. Both splits are held in memory
+    (about 700 MB at 100 steps over 700 channels), shuffled from `seed` every epoch, and
+    each process reads its share of every batch.
+    """
+
+    steps: int = 100
+    max_time: float = 1.4
+    channels: int = 700
+    cache: str | None = None
+    binning: Binning = "grid"
+
+    def load(self, *, batch: int, tokenize: Tokenize | None = None) -> Dataset:
+        self.uncaptioned(tokenize)
+        train = shd("train", self.steps, self.max_time, self.channels, self.cache, binning=self.binning)
+        test = shd("test", self.steps, self.max_time, self.channels, self.cache, binning=self.binning)
+        return Dataset.from_records(train, batch=batch, seed=self.seed, validation=test, loading=self.loading)
+
+
+def write_synthetic_shd(directory: str | Path, records: int = 64, seed: int = 0) -> Path:
+    """Write `shd_train.h5` and `shd_test.h5` in SHD's layout into `directory`, and return it.
+
+    Each split holds `records` recordings of 60 spikes over 1.4 s, labelled 0
+    or 1 by which half of the 700 channels fires, so a network learns them in
+    a few steps. `shd(split, cache=directory)` and `SHD(cache=directory)` read
+    them as they read SHD's own files, which lets a smoke run or a test
+    exercise the whole path without the 169 MB download.
+    """
+    import h5py
+
+    directory = Path(directory)
+    directory.mkdir(parents=True, exist_ok=True)
+    rng = np.random.default_rng(seed)
+    half = _CHANNELS // 2
+    for split in ("train", "test"):
+        labels = rng.integers(0, 2, records).astype(np.uint16)
+        with h5py.File(directory / f"shd_{split}.h5", "w") as file:
+            times = file.create_dataset("spikes/times", (records,), dtype=h5py.vlen_dtype(np.float32))
+            units = file.create_dataset("spikes/units", (records,), dtype=h5py.vlen_dtype(np.uint16))
+            for i, label in enumerate(labels):
+                times[i] = np.sort(rng.uniform(0, 1.4, 60)).astype(np.float32)
+                units[i] = (rng.integers(0, half, 60) + half * int(label)).astype(np.uint16)
+            file.create_dataset("labels", data=labels)
+    return directory
+
+
+def holdout(records: Mapping[str, np.ndarray], fraction: float,
+            seed: int = 0) -> tuple[dict[str, np.ndarray], dict[str, np.ndarray]]:
+    """Split `records` (columns of equal length) into a random `1 - fraction` and `fraction`.
+
+    SHD has no validation split, and SNN-delays selects its epochs on the
+    test set; holding out part of the training set gives a validation set
+    to select on, so the test accuracy stays an estimate.
+    """
+    sizes = {len(column) for column in records.values()}
+    if len(sizes) != 1:
+        raise ValueError(f"columns of one length split together, not lengths {sorted(sizes)}")
+    total = sizes.pop()
+    held = round(fraction * total)
+    if not 0 < held < total:
+        raise ValueError(f"holding out {fraction} of {total} records leaves one side empty")
+    order = np.random.default_rng(seed).permutation(total)
+    kept, out = np.sort(order[held:]), np.sort(order[:held])
+    return ({name: column[kept] for name, column in records.items()},
+            {name: column[out] for name, column in records.items()})

sparx/dynamics/__init__.py

@@ -0,0 +1,178 @@
+"""Neuron, synapse and plasticity models, and the runner that scans them over time.
+
+Every neuron model meets one contract (`sparx.dynamics.core`):
+`init_state(shape, dtype)` and `step(state, SynapticInput, dt) -> (state,
+Output)`, and `run(model, inputs)` scans one over time. A model's output is
+its spikes, or a graded value each step when the model is `graded`. Two families meet
+it. `sparx.dynamics.ml` holds the dimensionless, one-step-is-one-unit
+models deep spiking networks train with: soft resets, detached resets,
+learnable decays, input as a jump of the membrane. `sparx.dynamics.neurons`
+holds models of neurons as biology measures them: membrane equations in mV
+and ms with conductances, refractoriness and reversal potentials. Synapses
+with receptor kinetics and plasticity rules complete them; `sparx.nn` builds
+layers from these models and `sparx.graph` builds circuits and connectomes
+(design.md sections 4 and 5).
+
+This package exports the models and the contract. The arithmetic the
+models share (`fire`, `exact_linear`, `rk4`, `substeps` and the rest), which
+a new model is written with, stays in `sparx.dynamics.core`.
+"""
+
+from sparx.dynamics.core import Gap, Model, NeuronModel, Output, Reset, SynapticInput, Term, decay, run
+from sparx.dynamics.homeostasis import IntrinsicPlasticity, IntrinsicState
+from sparx.dynamics.ml import (
+    ACTIVATIONS,
+    ALIFCell,
+    ALIFState,
+    BernoulliCell,
+    BernoulliState,
+    DecayingHebb,
+    Dense,
+    EligibleHebb,
+    FastWeights,
+    HebbianRule,
+    LICell,
+    LIFCell,
+    MembraneState,
+    ModulatedHebb,
+    OjaHebb,
+    PulseCell,
+    RateCell,
+    RateState,
+    RecurrentCell,
+    RecurrentState,
+    RetroactiveHebb,
+    Serial,
+    Sparse,
+    Wiring,
+)
+from sparx.dynamics.neurons import (
+    IZHIKEVICH_2003,
+    IZHIKEVICH_2004,
+    RECEPTORS,
+    AdEx,
+    AdExState,
+    GradedPotential,
+    GradedPotentialState,
+    HodgkinHuxley,
+    HodgkinHuxleyState,
+    Izhikevich,
+    IzhikevichState,
+    LeakyIntegrateAndFire,
+    LeakyIntegrateAndFireState,
+    MgBlock,
+    izhikevich_2003,
+    izhikevich_2004,
+)
+from sparx.dynamics.plasticity import (
+    DopamineSTDP,
+    DopamineTraces,
+    PairSTDP,
+    Plasticity,
+    Rules,
+    ScalingTraces,
+    STDPTraces,
+    SynapticScaling,
+    TripletSTDP,
+    TripletTraces,
+    TsodyksMarkram,
+    TsodyksMarkramState,
+)
+from sparx.dynamics.synapses import (
+    Alpha,
+    AlphaState,
+    Arrivals,
+    BiExponential,
+    BiExponentialState,
+    Delta,
+    Exponential,
+    Graded,
+    GradedState,
+    Landing,
+    PointNeuron,
+    PointNeuronState,
+    Receptor,
+    StochasticRelease,
+    SynapseModel,
+)
+
+__all__ = [
+    "ACTIVATIONS",
+    "IZHIKEVICH_2003",
+    "IZHIKEVICH_2004",
+    "RECEPTORS",
+    "ALIFCell",
+    "ALIFState",
+    "AdEx",
+    "AdExState",
+    "Alpha",
+    "AlphaState",
+    "Arrivals",
+    "BernoulliCell",
+    "BernoulliState",
+    "BiExponential",
+    "BiExponentialState",
+    "DecayingHebb",
+    "Delta",
+    "Dense",
+    "DopamineSTDP",
+    "DopamineTraces",
+    "EligibleHebb",
+    "Exponential",
+    "FastWeights",
+    "Gap",
+    "Graded",
+    "GradedPotential",
+    "GradedPotentialState",
+    "GradedState",
+    "HebbianRule",
+    "HodgkinHuxley",
+    "HodgkinHuxleyState",
+    "IntrinsicPlasticity",
+    "IntrinsicState",
+    "Izhikevich",
+    "IzhikevichState",
+    "LICell",
+    "LIFCell",
+    "Landing",
+    "LeakyIntegrateAndFire",
+    "LeakyIntegrateAndFireState",
+    "MembraneState",
+    "MgBlock",
+    "Model",
+    "ModulatedHebb",
+    "NeuronModel",
+    "OjaHebb",
+    "Output",
+    "PairSTDP",
+    "Plasticity",
+    "PointNeuron",
+    "PointNeuronState",
+    "PulseCell",
+    "RateCell",
+    "RateState",
+    "Receptor",
+    "RecurrentCell",
+    "RecurrentState",
+    "Reset",
+    "RetroactiveHebb",
+    "Rules",
+    "STDPTraces",
+    "ScalingTraces",
+    "Serial",
+    "Sparse",
+    "StochasticRelease",
+    "SynapseModel",
+    "SynapticInput",
+    "SynapticScaling",
+    "Term",
+    "TripletSTDP",
+    "TripletTraces",
+    "TsodyksMarkram",
+    "TsodyksMarkramState",
+    "Wiring",
+    "decay",
+    "izhikevich_2003",
+    "izhikevich_2004",
+    "run",
+]