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:

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.

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.

ANN vs SNN: diferencias fundamentales

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.

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.

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.

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:

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.

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

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):

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:

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:

Conversión ANN → SNN

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

Otras estrategias de entrenamiento

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.

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:

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):

Aplicaciones de las Spiking Neural Networks

SNNs vs ANNs: comparativa exhaustiva

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/en/latest/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 Textbook: Schuman, C.D. et al. (2022) — Survey completo del campo.
• TU Graz SNNs course: materiales del grupo de Wolfgang Maass (creador del concepto de SNNs como 3ª generación).