Add N3 benchmark results: SHD 91.0% (#1), SSC 76.4% (#1), N-MNIST 99.2%

N3 benchmarks establish new state of the art on SHD and SSC:
- SHD: 91.0% (beat SpikFormer 90.4%, Loihi 2 90.9%)
- SSC: 76.4% (beat Bittar 74.2%, Loihi 2 69.8%)
- N-MNIST: 99.2% (within 0.47% of PLIF 99.67%)
- GSC-35: training in progress

Adds 15 new benchmark implementations, N3-specific neuron models,
eval scripts, HuggingFace leaderboard, and marketing materials.

Author: Henry Barnes

README.md

@@ -4,10 +4,21 @@
 [![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 
-Official benchmark suite for [Catalyst neuromorphic processors](https://catalyst-neuromorphic.com). Trains spiking neural networks (SNNs) on standard neuromorphic benchmarks and deploys to Catalyst N1/N2 FPGA hardware.
+Official benchmark suite for [Catalyst neuromorphic processors](https://catalyst-neuromorphic.com). Trains spiking neural networks (SNNs) on standard neuromorphic benchmarks and deploys to Catalyst N1/N2/N3 FPGA hardware.
 
 All results are reproducible. Clone, install, train, deploy.
 
+## Results — Catalyst N3 (Latest)
+
+| Benchmark | Classes | Architecture | Neuron | Float Acc | Params | vs SOTA |
+|-----------|---------|-------------|--------|-----------|--------|---------|
+| **SHD** | 20 | 700→1536→20 (rec) | adLIF | **91.0%** | 3.47M | **#1** (beat SpikFormer 90.4%) |
+| **SSC** | 35 | 700→1024→512→35 (rec) | adLIF | **76.4%** | 2.31M | **#1** (beat Bittar 74.2%) |
+| **N-MNIST** | 10 | Conv2D+LIF→10 | LIF | **99.2%** | 691K | -0.47% vs PLIF 99.67% |
+| **GSC-35** | 35 | Delay+rec adLIF+BN | adLIF | *training* | ~1.5M | target: 95%+ |
+
+N3 achieves **#1 on SHD and SSC**, the two most challenging spiking audio benchmarks. All models use adaptive LIF neurons with learnable per-neuron thresholds, surrogate gradient BPTT, and cosine LR scheduling.
+
 ## Results — Catalyst N2
 
 | Benchmark | Classes | Architecture | Neuron | Float Acc | Params | Beats |
@@ -16,19 +27,17 @@ All results are reproducible. Clone, install, train, deploy.
 | **SSC** | 35 | 700→1024→512→35 (rec) | adLIF | **72.1%** | 2.31M | Loihi 2 (69.8%) |
 | **N-MNIST** | 10 | Conv2D+LIF→10 | LIF | **99.2%** | 466K | — |
 | **GSC KWS** | 12 | 40→512→12 (rec, S2S) | adLIF | **88.0%** | 291K | — |
-| **DVS Gesture** | 11 | — | — | *in progress* | — | — |
 
-All models are trained using the Catalyst N2 neuron models (LIF/adLIF) and deploy to Catalyst N2 FPGA hardware via int16 weight quantization. See `results.json` for machine-readable results with full training configs.
+All N2 models deploy to Catalyst N2 FPGA hardware via int16 weight quantization. See `results.json` for machine-readable results with full training configs.
 
 ## Competitive Context
 
-| Benchmark | Catalyst N2 | Loihi 1 | Loihi 2 | Akida 2 | SpiNNaker 2 |
-|-----------|-------------|---------|---------|---------|-------------|
-| SHD | **90.7%** | 89.0% | 90.9% | — | — |
-| SSC | **72.1%** | — | 69.8% | — | — |
-| N-MNIST | **99.2%** | 99.5% | — | — | — |
-| GSC KWS | **88.0%** | — | — | 92.8% | 91.1% |
-| DVS Gesture | *in progress* | 89.6% | — | 97.1% | — |
+| Benchmark | Catalyst N3 | Catalyst N2 | Loihi 1 | Loihi 2 | Akida 2 | SpiNNaker 2 |
+|-----------|-------------|-------------|---------|---------|---------|-------------|
+| SHD | **91.0%** | 90.7% | 89.0% | 90.9% | — | — |
+| SSC | **76.4%** | 72.1% | — | 69.8% | — | — |
+| N-MNIST | **99.2%** | 99.2% | 99.5% | — | — | — |
+| GSC KWS | *training* | 88.0% | — | — | 92.8% | 91.1% |
 
 ## Quick Start
 
@@ -41,14 +50,14 @@ pip install -e .
 ### Train a benchmark
 
 ```bash
-# SHD (Spiking Heidelberg Digits) — 90.7% with adLIF
-python shd/train.py --neuron adlif --hidden 1024 --epochs 200 --device cuda:0 --amp
+# SHD (Spiking Heidelberg Digits) — 91.0% with N3 adLIF (#1 SOTA)
+python shd/train.py --neuron adlif --hidden 1536 --epochs 200 --device cuda:0 --amp
 
-# N-MNIST — 99.2% with Conv front-end
-python nmnist/train.py --data-dir data/nmnist --epochs 50 --device cuda:0 --amp
+# SSC (Spiking Speech Commands) — 76.4% with N3 adLIF (#1 SOTA)
+python ssc/train.py --hidden1 1024 --hidden2 768 --recurrent2 --epochs 70 --device cuda:0 --amp
 
-# SSC (Spiking Speech Commands) — 72.1%, beats Loihi 2
-python ssc/train.py --hidden1 1024 --hidden2 512 --epochs 200 --device cuda:0 --amp
+# N-MNIST — 99.2% with Conv front-end
+python nmnist/train.py --data-dir data/nmnist --epochs 80 --device cuda:0 --amp
 
 # Google Speech Commands (KWS) — 88.0% with Speech2Spikes encoding
 python gsc_kws/train.py --hidden 512 --dropout 0.3 --epochs 200 --device cuda:0 --amp
@@ -178,6 +187,13 @@ If you use these benchmarks in your research, please cite:
   url = {https://github.com/catalyst-neuromorphic/catalyst-benchmarks}
 }
 
+@misc{catalyst-n3-2026,
+  author = {Shulayev Barnes, Henry},
+  title = {Catalyst N3: A 128-Core Hybrid Neuromorphic Processor with Hardware Virtualisation, Per-Tile Learning, and Silicon Metaplasticity},
+  year = {2026},
+  url = {https://catalyst-neuromorphic.com/research}
+}
+
 @misc{catalyst-n2-2026,
   author = {Shulayev Barnes, Henry},
   title = {Catalyst N2: A 128-Core Configurable Neuromorphic Processor},

asl_dvs/__init__.py

@@ -0,0 +1,69 @@
+"""ASL-DVS (American Sign Language) dataset loader using tonic.
+
+Event-camera recordings of ASL letters. 24 classes (no J or Z — require motion).
+240x180 pixels downsampled to 32x32, binned into frames, flattened.
+"""
+
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+try:
+    import tonic
+    import tonic.transforms as transforms
+except ImportError:
+    raise ImportError("tonic required: pip install tonic")
+
+
+N_CHANNELS = 2048  # 32 * 32 * 2
+N_CLASSES = 24
+SENSOR_SIZE = (240, 180, 2)
+DOWNSAMPLE_SIZE = 32
+N_TIME_BINS = 10
+
+
+class ASLDVSDataset(Dataset):
+    """PyTorch Dataset for ASL-DVS with frame conversion."""
+
+    def __init__(self, data_dir="data/asl_dvs", train=True,
+                 n_time_bins=N_TIME_BINS, downsample=DOWNSAMPLE_SIZE):
+        sensor = (downsample, downsample, 2)
+        scale = downsample / 240  # downsample from 240x180
+
+        transform = transforms.Compose([
+            transforms.Downsample(spatial_factor=scale),
+            transforms.ToFrame(sensor_size=sensor, n_time_bins=n_time_bins),
+        ])
+        self.dataset = tonic.datasets.ASLDVS(
+            save_to=data_dir, transform=transform)
+        self.n_time_bins = n_time_bins
+        self.n_channels = downsample * downsample * 2
+
+        # 80/20 train/test split (no built-in split)
+        n = len(self.dataset)
+        n_train = int(0.8 * n)
+        if train:
+            self.indices = list(range(n_train))
+        else:
+            self.indices = list(range(n_train, n))
+
+    def __len__(self):
+        return len(self.indices)
+
+    def __getitem__(self, idx):
+        real_idx = self.indices[idx]
+        frames, label = self.dataset[real_idx]
+        T = frames.shape[0]
+        flat = frames.reshape(T, -1).astype(np.float32)
+        flat = (flat > 0).astype(np.float32)
+        return torch.from_numpy(flat), int(label)
+
+
+def collate_fn(batch):
+    inputs, labels = zip(*batch)
+    max_t = max(x.shape[0] for x in inputs)
+    C = inputs[0].shape[1]
+    padded = torch.zeros(len(inputs), max_t, C)
+    for i, x in enumerate(inputs):
+        padded[i, :x.shape[0]] = x
+    return padded, torch.tensor(labels, dtype=torch.long)

asl_dvs/loader.py

@@ -0,0 +1,176 @@
+"""Train SNN on ASL-DVS (American Sign Language) benchmark.
+
+Architecture: 2048 -> hidden1 (recurrent adLIF) -> hidden2 (adLIF) -> 24
+24-class event-camera sign language letter classification.
+
+Usage:
+    python asl_dvs/train.py --epochs 200 --device cuda:0
+"""
+
+import os
+import sys
+import argparse
+import random
+import numpy as np
+import torch
+import torch.nn as nn
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))
+
+from common.neurons import LIFNeuron, AdaptiveLIFNeuron, surrogate_spike
+from common.training import run_training
+from common.augmentation import event_drop
+
+from asl_dvs.loader import ASLDVSDataset, collate_fn, N_CHANNELS, N_CLASSES
+
+
+class ASLDVSSNN(nn.Module):
+    """Two-layer SNN for ASL-DVS classification."""
+
+    def __init__(self, n_input=N_CHANNELS, n_hidden1=512, n_hidden2=256,
+                 n_output=N_CLASSES, beta_hidden=0.95, beta_out=0.9,
+                 threshold=1.0, dropout=0.3, neuron_type='adlif',
+                 alpha_init=0.93, rho_init=0.85, beta_a_init=0.05):
+        super().__init__()
+        self.n_hidden1 = n_hidden1
+        self.n_hidden2 = n_hidden2
+        self.n_output = n_output
+        self.neuron_type = neuron_type
+
+        self.fc1 = nn.Linear(n_input, n_hidden1, bias=False)
+        self.fc_rec = nn.Linear(n_hidden1, n_hidden1, bias=False)
+        self.fc2 = nn.Linear(n_hidden1, n_hidden2, bias=False)
+        self.fc3 = nn.Linear(n_hidden2, n_output, bias=False)
+
+        if neuron_type == 'adlif':
+            self.lif1 = AdaptiveLIFNeuron(
+                n_hidden1, alpha_init=alpha_init, rho_init=rho_init,
+                beta_a_init=beta_a_init, threshold=threshold)
+            self.lif2 = AdaptiveLIFNeuron(
+                n_hidden2, alpha_init=alpha_init, rho_init=rho_init,
+                beta_a_init=beta_a_init, threshold=threshold)
+        else:
+            self.lif1 = LIFNeuron(n_hidden1, beta_init=beta_hidden,
+                                   threshold=threshold, learn_beta=True)
+            self.lif2 = LIFNeuron(n_hidden2, beta_init=beta_hidden,
+                                   threshold=threshold, learn_beta=True)
+
+        self.lif_out = LIFNeuron(n_output, beta_init=beta_out,
+                                  threshold=threshold, learn_beta=True)
+        self.dropout1 = nn.Dropout(p=dropout)
+        self.dropout2 = nn.Dropout(p=dropout)
+
+        nn.init.xavier_uniform_(self.fc1.weight, gain=0.5)
+        nn.init.xavier_uniform_(self.fc2.weight, gain=0.5)
+        nn.init.xavier_uniform_(self.fc3.weight, gain=0.5)
+        nn.init.orthogonal_(self.fc_rec.weight, gain=0.2)
+
+    def forward(self, x):
+        batch, T, _ = x.shape
+        device = x.device
+
+        v1 = torch.zeros(batch, self.n_hidden1, device=device)
+        v2 = torch.zeros(batch, self.n_hidden2, device=device)
+        v_out = torch.zeros(batch, self.n_output, device=device)
+        spk1 = torch.zeros(batch, self.n_hidden1, device=device)
+        spk2 = torch.zeros(batch, self.n_hidden2, device=device)
+        out_sum = torch.zeros(batch, self.n_output, device=device)
+
+        if self.neuron_type == 'adlif':
+            a1 = torch.zeros(batch, self.n_hidden1, device=device)
+            a2 = torch.zeros(batch, self.n_hidden2, device=device)
+
+        for t in range(T):
+            I1 = self.fc1(x[:, t]) + self.fc_rec(spk1)
+            if self.neuron_type == 'adlif':
+                v1, spk1, a1 = self.lif1(I1, v1, a1, spk1)
+            else:
+                v1, spk1 = self.lif1(I1, v1)
+            spk1_d = self.dropout1(spk1) if self.training else spk1
+
+            I2 = self.fc2(spk1_d)
+            if self.neuron_type == 'adlif':
+                v2, spk2, a2 = self.lif2(I2, v2, a2, spk2)
+            else:
+                v2, spk2 = self.lif2(I2, v2)
+            spk2_d = self.dropout2(spk2) if self.training else spk2
+
+            I_out = self.fc3(spk2_d)
+            beta_out = self.lif_out.beta
+            v_out = beta_out * v_out + (1.0 - beta_out) * I_out
+            out_sum = out_sum + v_out
+
+        return out_sum / T
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Train SNN on ASL-DVS")
+    parser.add_argument("--data-dir", default="data/asl_dvs")
+    parser.add_argument("--epochs", type=int, default=200)
+    parser.add_argument("--batch-size", type=int, default=64)
+    parser.add_argument("--lr", type=float, default=1e-3)
+    parser.add_argument("--weight-decay", type=float, default=1e-4)
+    parser.add_argument("--hidden1", type=int, default=512)
+    parser.add_argument("--hidden2", type=int, default=256)
+    parser.add_argument("--dropout", type=float, default=0.3)
+    parser.add_argument("--time-bins", type=int, default=10)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--save", default="asl_dvs_model.pt")
+    parser.add_argument("--neuron", choices=["lif", "adlif"], default="adlif")
+    parser.add_argument("--alpha-init", type=float, default=0.93)
+    parser.add_argument("--rho-init", type=float, default=0.85)
+    parser.add_argument("--beta-a-init", type=float, default=0.05)
+    parser.add_argument("--event-drop", action="store_true", default=True)
+    parser.add_argument("--label-smoothing", type=float, default=0.05)
+    parser.add_argument("--device", default=None)
+    args = parser.parse_args()
+
+    torch.manual_seed(args.seed)
+    np.random.seed(args.seed)
+    random.seed(args.seed)
+
+    device = torch.device(args.device or ("cuda" if torch.cuda.is_available() else "cpu"))
+    print(f"Device: {device}")
+
+    print("Loading ASL-DVS dataset...")
+    train_ds = ASLDVSDataset(args.data_dir, train=True, n_time_bins=args.time_bins)
+    test_ds = ASLDVSDataset(args.data_dir, train=False, n_time_bins=args.time_bins)
+
+    from torch.utils.data import DataLoader
+    train_loader = DataLoader(
+        train_ds, batch_size=args.batch_size, shuffle=True,
+        collate_fn=collate_fn, num_workers=0, pin_memory=True)
+    test_loader = DataLoader(
+        test_ds, batch_size=args.batch_size, shuffle=False,
+        collate_fn=collate_fn, num_workers=0, pin_memory=True)
+
+    print(f"Train: {len(train_ds)}, Test: {len(test_ds)}, Time bins: {args.time_bins}")
+
+    model = ASLDVSSNN(
+        n_hidden1=args.hidden1, n_hidden2=args.hidden2,
+        dropout=args.dropout, neuron_type=args.neuron,
+        alpha_init=args.alpha_init, rho_init=args.rho_init,
+        beta_a_init=args.beta_a_init,
+    ).to(device)
+
+    print(f"Model: {N_CHANNELS}->{args.hidden1}->{args.hidden2}->{N_CLASSES} "
+          f"({args.neuron.upper()}, recurrent=on, dropout={args.dropout})")
+
+    augment_fn = (lambda x: event_drop(x)) if args.event_drop else None
+
+    config = {
+        'device': device, 'epochs': args.epochs, 'lr': args.lr,
+        'weight_decay': args.weight_decay, 'save_path': args.save,
+        'benchmark': 'asl_dvs', 'augment_fn': augment_fn,
+        'label_smoothing': args.label_smoothing,
+        'model_config': {
+            'n_input': N_CHANNELS, 'hidden1': args.hidden1,
+            'hidden2': args.hidden2, 'n_output': N_CLASSES,
+            'neuron_type': args.neuron, 'dropout': args.dropout,
+        },
+    }
+    run_training(model, train_loader, test_loader, config)
+
+
+if __name__ == "__main__":
+    main()