Spiking Neural Networks

De la biología a la computación

Las Spiking Neural Networks (SNNs) son la tercera generación de redes neuronales artificiales. A diferencia de las ANNs clásicas que procesan valores continuos, las SNNs comunican información mediante impulsos eléctricos discretos (spikes), imitando cómo el cerebro biológico realmente funciona.

La neurona biológica

Para entender las SNNs, primero necesitamos entender la neurona real. Una neurona biológica tiene cuatro partes fundamentales:

Este proceso, repetido miles de millones de veces por segundo en el cerebro, constituye la base de toda computación neuronal. Obsérvese que el spike es un evento discreto y binario, a diferencia de las activaciones continuas (\.g., ReLU, sigmoid) de las redes neuronales artificiales clásicas. Esta diferencia fundamental es la que motiva la investigación en SNNs.

El potencial de acción (spike)

El potencial de acción es un pulso eléctrico de ~1 ms de duración que viaja por el axón. Es un evento todo-o-nada: o dispara con amplitud completa, o no dispara en absoluto.

Este mecanismo fue descrito en detalle por Hodgkin y Huxley en 1952, quienes recibieron el Premio Nobel en 1963 por su trabajo con el axón gigante del calamar. Su modelo biofísico, basado en ecuaciones diferenciales para los canales iónicos de sodio (Na⁺) y potasio (K⁺), sigue siendo la referencia para entender la electrofisiología neuronal. En la práctica de las SNNs, utilizamos simplificaciones como el modelo Leaky Integrate-and-Fire (LIF), que captura la esencia del disparo sin necesidad de resolver las ecuaciones completas de Hodgkin-Huxley.

Spike trains: la información está en el tiempo

A diferencia de las ANNs que transmiten valores continuos (como 0.73), las neuronas biológicas transmiten trenes de spikes: secuencias de pulsos en el tiempo. La información se codifica en el patrón temporal de estos spikes.

La codificación temporal es lo que diferencia fundamentalmente a las SNNs de las redes recurrentes (RNNs): mientras que las RNNs procesan secuencias de valores continuos en pasos discretos, las SNNs operan con spikes binarios donde la información reside en el momento exacto del disparo. Esta representación es intrínsecamente sparse (dispersa), lo que permite eficiencia computacional y energética sin precedentes.

ANN vs SNN: diferencias fundamentales

En resumen, las SNNs representan un paradigma de computación neuronal que prioriza la eficiencia energética, la dimensión temporal y la plausibilidad biológica. A cambio, su entrenamiento es más complejo que el backpropagation estándar utilizado en MLPs, CNNs o RNNs. En las siguientes secciones exploraremos los modelos de neurona, los mecanismos de aprendizaje y las técnicas de entrenamiento que hacen posible construir SNNs funcionales.

Leaky Integrate-and-Fire (LIF)

El modelo LIF es el caballo de batalla de las SNNs: suficientemente simple para ser eficiente, suficientemente rico para capturar la dinámica esencial del spiking.

El LIF fue introducido por Louis Lapicque en 1907, lo que lo convierte en uno de los modelos computacionales más antiguos de la neurociencia. A pesar de su antigüedad, sigue siendo el modelo más utilizado en SNNs modernas por su excelente balance entre fidelidad biológica y eficiencia computacional. La idea clave es modelar la membrana neuronal como un circuito RC (resistencia-capacitancia): la corriente de entrada carga el condensador (membrana), mientras que la resistencia provoca un "leak" (fuga) gradual que devuelve el potencial al reposo.

Donde \( V \) es el potencial de membrana, \( \tau_m \) la constante de tiempo de membrana, \( V_{\text{rest}} \) el potencial de reposo, \( R \) la resistencia de membrana e \( I(t) \) la corriente de entrada.

LIF discreto (para simulación)

En la práctica, simulamos con pasos de tiempo discretos \( \Delta t \):

Donde \( \beta = e^{-\Delta t / \tau_m} \) es el factor de leak (decaimiento). Si \( V[t] \geq V_{\text{th}} \), spike y reset.

El parámetro \( \beta \) controla la memoria temporal de la neurona: un valor cercano a 1 (poco leak) hace que la neurona recuerde entradas pasadas durante muchos pasos temporales, mientras que un valor bajo (mucho leak) hace que solo responda a estímulos recientes. Este trade-off es análogo al de las redes recurrentes (RNNs), donde las constantes de "forget gate" en LSTMs cumplen un rol similar.

import torch
import snntorch as snn

# Crear neurona LIF
beta = 0.85  # factor de decaimiento (leak)
lif = snn.Leaky(beta=beta, threshold=1.0)

# Simular 100 pasos de tiempo
num_steps = 100
input_current = torch.ones(num_steps) * 0.3  # corriente constante

# Inicializar estado
mem = lif.init_leaky()  # V = 0
spikes = []
membrane = []

for t in range(num_steps):
    spk, mem = lif(input_current[t], mem)
    spikes.append(spk.item())
    membrane.append(mem.item())

spike_count = sum(spikes)
print(f"Spikes: {spike_count} en {num_steps} pasos")
print(f"Tasa de disparo: {spike_count/num_steps:.2%}")

Otros modelos de neurona spiking

Sinapsis: conexiones entre neuronas spiking

Cuando una neurona pre-sináptica \( j \) dispara un spike en el instante \( t_j^f \), genera una corriente post-sináptica (PSC) en la neurona \( i \):

Donde \( w_{ij} \) es el peso sináptico y \( \kappa(t) \) es el kernel post-sináptico (PSP kernel), típicamente:

con \( \Theta(t) \) la función escalón de Heaviside y \( \tau_s \) la constante de tiempo sináptica.

Este paradigma event-driven es radicalmente distinto al de las ANNs clásicas, donde todas las neuronas se activan en cada forward pass, independientemente de la relevancia de la entrada. En una SNN entrenada para clasificar imágenes, por ejemplo, típicamente solo el 5–15% de las neuronas dispara en un paso temporal dado. Esta sparsity intrínseca es la clave de la eficiencia de los chips neuromórficos como Intel Loihi, que solo consumen energía cuando una neurona recibe un spike.

Codificación de información con spikes

Un reto clave de las SNNs: ¿cómo representar datos del mundo real (imágenes, audio, sensores) como trenes de spikes? Los esquemas principales son:

La elección del esquema de codificación es tan importante como la arquitectura de la red, ya que determina la eficiencia energética, la latencia y la capacidad de información del sistema. A diferencia de las ANNs clásicas, donde la entrada es simplemente un vector de números reales, las SNNs requieren una etapa explícita de conversión dato→spike que afecta directamente al rendimiento.

import snntorch.spikegen as spikegen
import torch

# Imagen MNIST normalizada [0, 1] → spike train
pixel_values = torch.tensor([0.2, 0.8, 0.5, 0.1])
num_steps = 100

# Cada paso: spike con prob = pixel_value
spike_train = spikegen.rate(pixel_values, num_steps=num_steps)
print(f"Shape: {spike_train.shape}")  # (100, 4)
print(f"Tasa real pixel 0.8: {spike_train[:, 1].mean():.2f}")

import snntorch.spikegen as spikegen
import torch

pixel_values = torch.tensor([0.9, 0.5, 0.1, 0.7])
num_steps = 50

# Mayor valor → spike más temprano
spike_train = spikegen.latency(
    pixel_values,
    num_steps=num_steps,
    tau=5.0,            # constante de tiempo
    normalize=True,
    linear=False         # codificación logarítmica
)

for i, val in enumerate(pixel_values):
    first = (spike_train[:, i] == 1).nonzero()
    t = first[0].item() if len(first) > 0 else "∞"
    print(f"Pixel {val:.1f} → primer spike en t={t}")

STDP: Spike-Timing-Dependent Plasticity

La STDP es la regla de aprendizaje biológico más importante para las SNNs. Descubierta experimentalmente por Bi & Poo (1998), formaliza la regla de Hebb: "neurons that fire together, wire together", pero con una dependencia temporal precisa.

Es importante contextualizar la STDP dentro del panorama de algoritmos de aprendizaje: mientras que el backpropagation clásico requiere propagar errores globales por toda la red (no biológicamente plausible), la STDP es una regla completamente local — cada sinapsis actualiza su peso basandose únicamente en la actividad de sus dos neuronas conectadas. Esto la hace compatible con implementaciones en hardware neuromórfico donde no existe un controlador global de errores.

Donde \( \Delta t = t_{\text{post}} - t_{\text{pre}} \), y \( A_+, A_- \) son las amplitudes de potenciación/depresión, y \( \tau_+, \tau_- \) las constantes de tiempo (típicamente ~20 ms).

Más allá de STDP: otras formas de plasticidad

La R-STDP (Reward-modulated STDP) es particularmente interesante porque conecta el aprendizaje biológico con el aprendizaje por refuerzo. La señal de recompensa, que en el cerebro es mediada por la dopamina, modula la magnitud de los cambios STDP, permitiendo que la red aprenda asociaciones causales entre acciones y resultados sin necesidad de un supervisor explícito. Este mecanismo es una de las vías más prometedoras para lograr aprendizaje on-chip en hardware neuromórfico.

El problema del gradiente en SNNs

El entrenamiento de SNNs mediante backpropagation tiene un obstáculo fundamental: la función de disparo (spike) es una función escalón de Heaviside, cuyo gradiente es cero en todas partes excepto en el umbral, donde es infinito (delta de Dirac):

Este problema es único de las SNNs y no tiene equivalente directo en las ANNs clásicas, donde las funciones de activación (ReLU, sigmoid, tanh) son diferenciables (o al menos sub-diferenciables en el caso de ReLU en cero). La no-diferenciabilidad de la función de disparo impide el uso directo de la cadena de regla y backpropagation estándar, lo que motivó el desarrollo de varias estrategias alternativas.

Esto hace que el backprop estándar no funcione: los gradientes son exactamente 0 o ∞. ¿Soluciones?

Surrogate Gradients

La técnica más exitosa: en el forward pass se usa la función escalón real (Heaviside), pero en el backward pass se sustituye el gradiente por una función suave:

Esta estrategia es una generalización del Straight-Through Estimator (STE) propuesto por Bengio et al. (2013) para redes con cuantización binaria. La idea clave es que, aunque la función real no sea diferenciable, podemos pretender que lo es durante el backward pass sustituyéndola por una aproximación suave. En la práctica, la elección del surrogate concreto tiene un impacto moderado: lo que importa más es que exista un gradiente útil, no la forma exacta de la curva.

import torch
import torch.nn as nn
import snntorch as snn
from snntorch import surrogate

# Usar fast sigmoid como surrogate
spike_grad = surrogate.fast_sigmoid(slope=25)

class SpikingNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 256)
        self.lif1 = snn.Leaky(beta=0.9, spike_grad=spike_grad)
        self.fc2 = nn.Linear(256, 10)
        self.lif2 = snn.Leaky(beta=0.9, spike_grad=spike_grad)

    def forward(self, x, num_steps=25):
        mem1 = self.lif1.init_leaky()
        mem2 = self.lif2.init_leaky()
        spk2_rec = []

        for _ in range(num_steps):
            cur1 = self.fc1(x)
            spk1, mem1 = self.lif1(cur1, mem1)
            cur2 = self.fc2(spk1)
            spk2, mem2 = self.lif2(cur2, mem2)
            spk2_rec.append(spk2)

        # Contar spikes de salida
        return torch.stack(spk2_rec, dim=0)

# La loss: contar spikes por clase
# La clase con más spikes gana
net = SpikingNet()
optimizer = torch.optim.Adam(net.parameters(), lr=1e-3)

Backpropagation Through Time (BPTT) para SNNs

Las SNNs procesan información a lo largo del tiempo, similar a las RNNs. El entrenamiento despliega la red en el eje temporal y aplica BPTT con surrogate gradients:

La conexión con las redes recurrentes (RNNs) es profunda: la dinámica de membrana de una neurona LIF es matemáticamente equivalente a una celda recurrente con un estado oculto (el potencial \( V \)) y una no-linealidad de salida (la función de disparo). La principal diferencia es que en las SNNs la salida es binaria (spike/no spike) en vez de continua, y la "recurrencia" proviene del leak de membrana, no de pesos recurrentes explícitos. Los mismos problemas de vanishing/exploding gradients aplican, y técnicas como truncated BPTT o detach periodos refractarios se usan para estabilizar el entrenamiento.

Conversión ANN → SNN

Enfoque alternativo al entrenamiento directo: entrenar una ANN convencional y convertirla a SNN post-entrenamiento.

La conversión ANN→SNN ha sido especialmente exitosa con arquitecturas como ResNets y VGGs, donde la equi-valencia ReLU→tasa de disparo está bien fundamentada teóricamente. Sin embargo, la conversión de modelos con batch normalization, max pooling o skip connections requiere técnicas adicionales (threshold balancing, temporal batch norm) que aún son área de investigación activa.

Otras estrategias de entrenamiento

Más allá de surrogate gradients y la conversión ANN→SNN, la comunidad ha explorado múltiples vías alternativas para entrenar SNNs. Cada una ofrece un balance distinto entre plausibilidad biológica, eficiencia y rendimiento, abriendo diferentes caminos hacia la implementación en hardware neuromórfico.

Hardware neuromórfico

Las SNNs alcanzan su máximo potencial cuando se ejecutan en hardware neuromórfico: chips diseñados para emular neuronas y sinapsis directamente en silicio, con eficiencia energética de órdenes de magnitud superior a las GPUs.

A diferencia de la arquitectura von Neumann tradicional (usada en GPUs/CPUs), donde procesamiento y memoria están separados y la comunicación entre ambos crea un cuello de botella (el memory wall), los chips neuromórficos integran computación y memoria en cada neurona. Cada núcleo neuromórfico contiene tanto la lógica de integración/disparo como los pesos sinápticos locales, eliminando transferencias masivas de datos. Este paradigma se denomina in-memory computing y es la razón principal de la eficiencia energética de estos chips.

Frameworks de software para SNNs

Aunque el hardware neuromórfico está en fase de maduración, podemos simular SNNs en GPUs convencionales usando frameworks especializados. Los principales:

La buena noticia es que el ecosistema de software para SNNs ha crecido enormemente desde 2020. Los frameworks modernos se integran nativamente con PyTorch, lo que permite aplicar las técnicas de deep learning ya conocidas (autograd, DataLoader, optimizadores) al mundo spiking. Si ya tienes experiencia con redes neuronales en PyTorch, la curva de aprendizaje para SNNs es sorprendentemente suave.

import torch
import torch.nn as nn
import snntorch as snn
from snntorch import surrogate

spike_grad = surrogate.fast_sigmoid(slope=25)
beta = 0.9

class SpikingCNN(nn.Module):
    def __init__(self):
        super().__init__()
        # Capa convolucional spiking
        self.conv1 = nn.Conv2d(1, 16, 3, padding=1)
        self.lif1 = snn.Leaky(beta=beta, spike_grad=spike_grad)
        self.pool = nn.MaxPool2d(2)

        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
        self.lif2 = snn.Leaky(beta=beta, spike_grad=spike_grad)

        self.fc = nn.Linear(32 * 7 * 7, 10)
        self.lif3 = snn.Leaky(beta=beta, spike_grad=spike_grad)

    def forward(self, x, num_steps=25):
        mem1 = self.lif1.init_leaky()
        mem2 = self.lif2.init_leaky()
        mem3 = self.lif3.init_leaky()
        spk_out = []

        for _ in range(num_steps):
            spk1, mem1 = self.lif1(self.pool(self.conv1(x)), mem1)
            spk2, mem2 = self.lif2(self.pool(self.conv2(spk1)), mem2)
            spk3, mem3 = self.lif3(self.fc(spk2.flatten(1)), mem3)
            spk_out.append(spk3)

        return torch.stack(spk_out)

model = SpikingCNN()
print(f"Parámetros: {sum(p.numel() for p in model.parameters()):,}")

import torch
import norse.torch as norse

# Parámetros de la neurona LIF
params = norse.LIFParameters(
    tau_mem_inv=100.0,  # 1/τ_mem
    v_th=torch.tensor(1.0),
    v_leak=torch.tensor(0.0),
)

# Crear celda recurrente LIF
cell = norse.LIFRecurrentCell(
    input_size=784,
    hidden_size=128,
    p=params
)

# Simular
state = None
for t in range(50):
    x = torch.randn(32, 784)  # batch=32
    output, state = cell(x, state)
    # output contiene spikes (0 o 1)

from brian2 import *

# Definir neurona LIF con ecuaciones
eqs = '''
dv/dt = (I - v) / (10*ms) : 1
I : 1
'''

# Crear grupo de 100 neuronas
G = NeuronGroup(100, eqs, threshold='v > 1',
                reset='v = 0', method='exact')
G.I = '0.5 + 1.5 * rand()'  # corriente aleatoria

# Monitor de spikes
M = SpikeMonitor(G)
run(1*second)

print(f"Total spikes: {M.num_spikes}")
print(f"Tasa media: {M.num_spikes/100:.1f} Hz")

Datasets neuromórficos

Los datasets convencionales (MNIST, CIFAR) se pueden convertir a spikes, pero existen datasets nativamente event-driven capturados con cámaras de eventos (DVS):

Los datasets neuromórficos son esenciales para evaluar SNNs en condiciones realistas. A diferencia de convertir MNIST a spikes (donde se pierde la ventaja temporal), los datasets DVS capturan información intrínsecamente temporal que las SNNs pueden explotar de forma nativa. Los benchmarks más citados son DVS-Gesture (gestos manuales) y SHD (Spiking Heidelberg Digits), que se han convertido en estándares de facto para comparar métodos de entrenamiento. SpikingJelly incluye cargadores nativos para la mayoría de estos datasets a través de spikingjelly.datasets.

Aplicaciones de las Spiking Neural Networks

Las SNNs no son una curiosidad académica: ya se despliegan en aplicaciones reales donde la baja latencia, el bajo consumo energético y el procesamiento temporal nativo ofrecen ventajas decisivas sobre las ANNs convencionales. Las aplicaciones más maduras se concentran en el edge computing, donde ejecutar un modelo en una GPU remota no es viable por latencia, consumo o privacidad.

SNNs vs ANNs: comparativa exhaustiva

Es importante notar que la brecha de accuracy entre SNNs y ANNs se está cerrando rápidamente. En tareas como MNIST y DVS-Gesture, las SNNs ya alcanzan rendimiento comparable a las ANNs. En ImageNet, los Spiking Transformers (Spikformer, Spike-driven Transformer) han alcanzado ~78% top-1 accuracy con solo 4 pasos temporales, frente al ~90% de los mejores modelos clásicos — pero consumiendo una fracción de la energía en hardware neuromórfico. Para muchas aplicaciones edge, esta leve pérdida de accuracy es más que compensada por la reducción de 100–1000× en consumo energético.

Estado del arte: resultados recientes

Referencias académicas y recursos

📄 Papers fundacionales

📄 Papers recientes destacados

🔗 Repositorios y recursos

📚 Recursos de aprendizaje

• snnTorch Tutorials: snntorch.readthedocs.io/tutorials — Curso completo de SNNs con PyTorch (8 tutoriales).
• Neuromatch Academy: compneuro.neuromatch.io — Curso de neurociencia computacional con módulo de SNNs.
• Neuromorphic Computing Survey: Schuman, C.D. et al. (2022). Opportunities for neuromorphic computing algorithms and applications. Nature Comp. Science. DOI
• TU Graz SNNs course: materiales del grupo de Wolfgang Maass (creador del concepto de SNNs como 3ª generación).