Твій мозок споживає 20 ватів. Менше, ніж лампочка. При цьому він обробляє інформацію, на яку GPU витрачає кіловати. Розпізнає обличчя за мілісекунди. Розуміє мову в шумному середовищі. Координує рухи всього тіла.
Секрет? Мозок не рахує постійно. Нейрони мовчать більшість часу. Вони «стріляють» (spike) тільки коли є щось важливе. Spike — і тиша. Spike — і тиша. Інформація кодується не в амплітуді сигналу, а в часі спайків.
Spiking Neural Networks (SNN) копіюють цей принцип. А нейроморфні чіпи — Intel Loihi, IBM TrueNorth, BrainChip Akida — це hardware, який робить це ефективно. В 100-1000 разів менше енергії, ніж традиційні нейромережі. Це не покращення. Це інша парадигма обчислень.
Чому традиційні нейронки енергетично неефективні
Проблема continuous activation:
class TraditionalNeuralNet:
"""Чому звичайні мережі споживають багато енергії"""
def forward(self, x):
# КОЖЕН нейрон активується на КОЖНОМУ кроці
for layer in self.layers:
x = layer(x) # матричне множення
x = relu(x) # activation
# Навіть якщо input не змінився — все одно обчислюємо
# Мільйони neurons × мільйони операцій = мільярди FLOPs
return x
# Проблеми:
# 1. Dense computation — всі нейрони активні
# 2. Synchronous updates — все обчислюється кожен timestep
# 3. High precision — float32 для кожної операції
# 4. Memory bandwidth — постійне читання/запис вагБіологічна реальність:
| Властивість | Традиційна NN | Біологічний мозок |
|-------------|---------------|-------------------|
| Активність нейронів | 100% (dense) | ~1-5% (sparse) |
| Обробка | Synchronous | Asynchronous, event-driven |
| Енергія на операцію | ~pJ (GPU) | ~fJ (біологія) |
| Інформаційне кодування | Rate (amplitude) | Temporal (spike timing) |
| Пластичність | Тільки training | Continuous |
Моделі спайкових нейронів
Leaky Integrate-and-Fire (LIF) — найпопулярніша модель:
import torch
import torch.nn as nn
import numpy as np
class LeakyIntegrateAndFire(nn.Module):
"""
Leaky Integrate-and-Fire neuron — основа SNN
Динаміка:
τ·dV/dt = -(V - V_rest) + R·I(t)
Якщо V > V_threshold: emit spike, V = V_reset
"""
def __init__(self,
tau_mem: float = 20.0, # membrane time constant (ms)
v_rest: float = -65.0, # resting potential (mV)
v_threshold: float = -50.0, # spike threshold (mV)
v_reset: float = -70.0, # reset potential after spike (mV)
dt: float = 1.0): # time step (ms)
super().__init__()
self.tau_mem = tau_mem
self.v_rest = v_rest
self.v_threshold = v_threshold
self.v_reset = v_reset
self.dt = dt
# Decay factor
self.beta = np.exp(-dt / tau_mem)
def forward(self, input_current: torch.Tensor,
membrane: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
"""
Single timestep update
input_current: (batch, neurons) - weighted input spikes
membrane: (batch, neurons) - membrane potential
returns: (spikes, new_membrane)
"""
# Leaky integration
membrane = self.beta * membrane + (1 - self.beta) * input_current
# Spike generation
spikes = (membrane > self.v_threshold).float()
# Reset after spike
membrane = membrane * (1 - spikes) + self.v_reset * spikes
return spikes, membrane
class LIFLayer(nn.Module):
"""Повний LIF layer з ваговими зв'язками"""
def __init__(self, in_features: int, out_features: int,
beta: float = 0.9):
super().__init__()
self.fc = nn.Linear(in_features, out_features, bias=False)
self.beta = beta # membrane decay
self.threshold = 1.0
def forward(self, spikes: torch.Tensor,
mem: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
"""
spikes: input spikes (batch, in_features)
mem: membrane potential (batch, out_features)
"""
# Weighted input
cur = self.fc(spikes)
# Leaky integration
mem = self.beta * mem + cur
# Threshold and fire
out_spikes = (mem > self.threshold).float()
# Soft reset (subtract threshold)
mem = mem - out_spikes * self.threshold
return out_spikes, memІнші моделі нейронів:
class AdaptiveLIF(nn.Module):
"""
Adaptive LIF — нейрон з адаптацією
Після спайку threshold тимчасово підвищується
"""
def __init__(self, beta: float = 0.9, rho: float = 0.95):
super().__init__()
self.beta = beta # membrane decay
self.rho = rho # threshold adaptation decay
self.base_threshold = 1.0
self.adaptation_strength = 0.5
def forward(self, x: torch.Tensor, mem: torch.Tensor,
threshold: torch.Tensor) -> tuple:
# Leaky integration
mem = self.beta * mem + x
# Dynamic threshold
spike = (mem > threshold).float()
# Soft reset
mem = mem - spike * threshold
# Threshold adaptation (increases after spike, then decays)
threshold = self.rho * threshold + (1 - self.rho) * self.base_threshold
threshold = threshold + spike * self.adaptation_strength
return spike, mem, threshold
class IzhikevichNeuron(nn.Module):
"""
Izhikevich model — біологічно реалістичніший
Може відтворювати різні паттерни: regular, bursting, chattering
"""
def __init__(self, a=0.02, b=0.2, c=-65, d=8, dt=0.5):
super().__init__()
self.a = a # time scale of recovery
self.b = b # sensitivity of recovery to V
self.c = c # reset voltage
self.d = d # reset recovery
self.dt = dt
def forward(self, I: torch.Tensor, v: torch.Tensor,
u: torch.Tensor) -> tuple:
"""
I: input current
v: membrane potential
u: recovery variable
"""
# Dynamics
dv = 0.04 * v**2 + 5*v + 140 - u + I
du = self.a * (self.b*v - u)
v = v + self.dt * dv
u = u + self.dt * du
# Spike and reset
spike = (v >= 30).float()
v = torch.where(spike.bool(), torch.tensor(self.c), v)
u = u + spike * self.d
return spike, v, uSpike Encoding — як перетворити дані в спайки
Три основні методи кодування:
import torch
import numpy as np
class SpikeEncoding:
"""Методи перетворення аналогових даних у спайки"""
@staticmethod
def rate_encoding(data: torch.Tensor, num_steps: int,
max_rate: float = 1.0) -> torch.Tensor:
"""
Rate encoding — частота спайків пропорційна інтенсивності
Простий, але не оптимальний для енергоефективності
"""
# Normalize to [0, 1]
data_norm = (data - data.min()) / (data.max() - data.min() + 1e-8)
# Generate spikes based on probability
spikes = torch.zeros(num_steps, *data.shape)
for t in range(num_steps):
spikes[t] = (torch.rand_like(data_norm) < data_norm * max_rate).float()
return spikes # (time, batch, features)
@staticmethod
def latency_encoding(data: torch.Tensor, num_steps: int,
tau: float = 5.0) -> torch.Tensor:
"""
Latency encoding — час спайку кодує інтенсивність
Сильніший сигнал → раніший спайк
Дуже енергоефективний (один спайк на нейрон)
"""
# Normalize to [0, 1]
data_norm = (data - data.min()) / (data.max() - data.min() + 1e-8)
# Inverse: higher value → earlier spike
spike_times = ((1 - data_norm) * (num_steps - 1)).long()
# Generate spike train
spikes = torch.zeros(num_steps, *data.shape)
for t in range(num_steps):
spikes[t] = (spike_times == t).float()
return spikes
@staticmethod
def delta_encoding(data: torch.Tensor,
threshold: float = 0.1) -> torch.Tensor:
"""
Delta encoding — спайк при зміні сигналу
Ідеально для event-driven sensors (DVS cameras)
"""
# Compute differences
diff = torch.zeros_like(data)
diff[1:] = data[1:] - data[:-1]
# Positive and negative changes
pos_spikes = (diff > threshold).float()
neg_spikes = (diff < -threshold).float()
# Two channels: ON and OFF
return torch.stack([pos_spikes, neg_spikes], dim=-1)
class DVSEventStream:
"""
Dynamic Vision Sensor (DVS) — event camera
Виводить події тільки при зміні яскравості
Природне джерело spike-based даних
"""
def __init__(self, threshold: float = 0.15):
self.threshold = threshold
self.reference = None
def process_frame(self, frame: np.ndarray) -> list[dict]:
"""Перетворює кадр у потік подій"""
if self.reference is None:
self.reference = frame.copy().astype(np.float32)
return []
events = []
log_frame = np.log(frame.astype(np.float32) + 1)
log_ref = np.log(self.reference + 1)
diff = log_frame - log_ref
# ON events (brightness increase)
on_mask = diff > self.threshold
on_coords = np.argwhere(on_mask)
for y, x in on_coords:
events.append({'x': x, 'y': y, 'polarity': 1, 'timestamp': 0})
# OFF events (brightness decrease)
off_mask = diff < -self.threshold
off_coords = np.argwhere(off_mask)
for y, x in off_coords:
events.append({'x': x, 'y': y, 'polarity': 0, 'timestamp': 0})
# Update reference where events occurred
self.reference[on_mask | off_mask] = frame[on_mask | off_mask]
return eventsНавчання SNN — проблема недиференційованості
Проблема: Spike function — step function, градієнт = 0 або ∞
class SurrogateGradient(torch.autograd.Function):
"""
Surrogate gradient — ключ до backprop через спайки
Forward: справжня spike function (hard threshold)
Backward: smooth surrogate (дозволяє градієнту проходити)
"""
@staticmethod
def forward(ctx, membrane: torch.Tensor, threshold: float = 1.0):
ctx.save_for_backward(membrane)
ctx.threshold = threshold
# Hard threshold: справжні спайки
return (membrane > threshold).float()
@staticmethod
def backward(ctx, grad_output: torch.Tensor):
membrane, = ctx.saved_tensors
threshold = ctx.threshold
# Surrogate gradient: fast sigmoid
grad = grad_output / (1 + torch.abs(membrane - threshold))**2
return grad, None
class FastSigmoidSurrogate:
"""Альтернативні surrogate functions"""
@staticmethod
def rectangular(x: torch.Tensor, width: float = 0.5) -> torch.Tensor:
"""Rectangular window"""
return (torch.abs(x) < width).float() / (2 * width)
@staticmethod
def triangular(x: torch.Tensor, width: float = 1.0) -> torch.Tensor:
"""Triangular window"""
return torch.clamp(1 - torch.abs(x) / width, min=0) / width
@staticmethod
def gaussian(x: torch.Tensor, sigma: float = 0.5) -> torch.Tensor:
"""Gaussian window"""
return torch.exp(-x**2 / (2 * sigma**2)) / (sigma * np.sqrt(2*np.pi))
@staticmethod
def fast_sigmoid(x: torch.Tensor, slope: float = 25) -> torch.Tensor:
"""Fast sigmoid — найпопулярніший"""
return slope / (1 + slope * torch.abs(x))**2
class SNNWithSurrogateGrad(nn.Module):
"""Повна SNN з surrogate gradient training"""
def __init__(self, input_size: int, hidden_size: int, output_size: int,
num_steps: int = 100, beta: float = 0.9):
super().__init__()
self.num_steps = num_steps
self.beta = beta
# Layers
self.fc1 = nn.Linear(input_size, hidden_size)
self.fc2 = nn.Linear(hidden_size, output_size)
# Spike function with surrogate gradient
self.spike_fn = SurrogateGradient.apply
def forward(self, x: torch.Tensor) -> torch.Tensor:
"""
x: (batch, time, features) or (batch, features) for static input
"""
batch_size = x.shape[0]
# Initialize membrane potentials
mem1 = torch.zeros(batch_size, self.fc1.out_features, device=x.device)
mem2 = torch.zeros(batch_size, self.fc2.out_features, device=x.device)
# Output accumulator
out_sum = torch.zeros(batch_size, self.fc2.out_features, device=x.device)
for t in range(self.num_steps):
# Get input (time-varying or static)
if x.dim() == 3:
x_t = x[:, t, :]
else:
x_t = x
# Layer 1
cur1 = self.fc1(x_t)
mem1 = self.beta * mem1 + cur1
spk1 = self.spike_fn(mem1)
mem1 = mem1 - spk1 # soft reset
# Layer 2
cur2 = self.fc2(spk1)
mem2 = self.beta * mem2 + cur2
spk2 = self.spike_fn(mem2)
mem2 = mem2 - spk2
# Accumulate output spikes
out_sum += spk2
# Rate decoding: spike count / time steps
return out_sum / self.num_stepsANN-to-SNN Conversion
Альтернативний підхід: Навчаємо звичайну мережу, потім конвертуємо.
class ANNtoSNNConverter:
"""
Конвертація навченої ANN у SNN
Плюси: використовуємо існуючі trained models
Мінуси: suboptimal — не використовуємо temporal dynamics
"""
def __init__(self, percentile: float = 99.9):
self.percentile = percentile
self.scale_factors = {}
def calibrate(self, model: nn.Module, data_loader,
num_batches: int = 100):
"""Калібрує scale factors на representative data"""
activations = {}
def hook_fn(name):
def hook(module, input, output):
if name not in activations:
activations[name] = []
activations[name].append(output.detach().cpu())
return hook
# Register hooks
hooks = []
for name, module in model.named_modules():
if isinstance(module, nn.ReLU):
hooks.append(module.register_forward_hook(hook_fn(name)))
# Run calibration
model.eval()
with torch.no_grad():
for i, (x, _) in enumerate(data_loader):
if i >= num_batches:
break
model(x)
# Remove hooks
for h in hooks:
h.remove()
# Compute scale factors
for name, acts in activations.items():
all_acts = torch.cat(acts)
self.scale_factors[name] = np.percentile(
all_acts.numpy().flatten(),
self.percentile
)
def convert_layer(self, layer: nn.Linear,
scale_in: float, scale_out: float) -> nn.Linear:
"""Конвертує один linear layer"""
# Scale weights
new_layer = nn.Linear(layer.in_features, layer.out_features,
bias=layer.bias is not None)
new_layer.weight.data = layer.weight.data * (scale_out / scale_in)
if layer.bias is not None:
new_layer.bias.data = layer.bias.data / scale_in
return new_layer
def convert_model(self, ann_model: nn.Module) -> nn.Module:
"""Конвертує всю модель"""
# Implementation depends on model architecture
# Basic idea: replace ReLU with IF neurons
# Scale weights based on calibration
pass
class ConvertedSNN(nn.Module):
"""SNN отримана з конвертації ANN"""
def __init__(self, converted_layers: list, num_steps: int = 100):
super().__init__()
self.layers = nn.ModuleList(converted_layers)
self.num_steps = num_steps
def forward(self, x: torch.Tensor) -> torch.Tensor:
batch_size = x.shape[0]
# Initialize membranes
mems = [torch.zeros(batch_size, l.out_features, device=x.device)
for l in self.layers if isinstance(l, nn.Linear)]
out_spikes = torch.zeros(batch_size, self.layers[-1].out_features,
device=x.device)
for t in range(self.num_steps):
spk = x / self.num_steps # Rate encoding
for i, layer in enumerate(self.layers):
if isinstance(layer, nn.Linear):
mems[i] += layer(spk)
spk = (mems[i] > 1.0).float()
mems[i] = mems[i] - spk # reset
out_spikes += spk
return out_spikesНейроморфні чіпи
Intel Loihi 2 (2021):
class Loihi2Architecture:
"""Характеристики Intel Loihi 2"""
SPECS = {
"neurons": 1_000_000,
"synapses": 120_000_000,
"cores": 128,
"process": "Intel 4",
"features": [
"Programmable neuron models",
"On-chip learning (STDP, 3-factor rules)",
"Graded spikes (multi-bit activations)",
"Programmable synaptic delays",
"Sparse event-driven computation"
],
"power": "~1W typical workload",
"latency": "~1ms for inference"
}
@staticmethod
def compare_to_gpu():
"""Порівняння з GPU на SNN workloads"""
return {
"energy_ratio": "100-1000x more efficient",
"latency": "10-100x faster for sparse",
"throughput": "Lower than GPU for dense"
}
class LoihiDeployment:
"""Приклад deployment на Loihi через Lava"""
def create_network(self):
"""
Lava framework для Loihi
Примітка: потребує Intel INRC access
"""
# Псевдокод — реальний API вимагає Lava installation
"""
from lava.proc.lif.process import LIF
from lava.proc.dense.process import Dense
# Define layers
input_layer = InputProcess(shape=(784,))
hidden = LIF(shape=(128,), du=0.9, dv=0.9, vth=1.0)
output = LIF(shape=(10,), du=0.9, dv=0.9, vth=1.0)
# Connections
conn1 = Dense(weights=w1)
conn2 = Dense(weights=w2)
# Connect
input_layer.out_ports.s_out.connect(conn1.in_ports.s_in)
conn1.out_ports.a_out.connect(hidden.in_ports.a_in)
hidden.out_ports.s_out.connect(conn2.in_ports.s_in)
conn2.out_ports.a_out.connect(output.in_ports.a_in)
# Run
run_cfg = Loihi2HwCfg()
output.run(condition=RunSteps(100), run_cfg=run_cfg)
"""
passIBM TrueNorth:
class TrueNorthArchitecture:
"""IBM TrueNorth характеристики"""
SPECS = {
"neurons": 1_000_000,
"synapses": 256_000_000,
"cores": 4096,
"process": "Samsung 28nm",
"power": "70mW at typical workload",
"features": [
"Fixed neuron model (simplified LIF)",
"No on-chip learning",
"256 neurons per core",
"Tile-based architecture"
]
}BrainChip Akida:
class AkidaDeployment:
"""BrainChip Akida — комерційний нейроморфний чіп"""
def deploy_model(self, keras_model):
"""
Akida підтримує пряму конвертацію з Keras
pip install akida
"""
"""
from akida import Model as AkidaModel
from cnn2snn import convert
# Convert Keras model to Akida
akida_model = convert(keras_model)
# Quantize for Akida hardware
akida_model.quantize(...)
# Map to hardware
akida_model.map(...)
# Inference on Akida chip
predictions = akida_model.predict(x_test)
"""
pass
APPLICATIONS = [
"Keyword spotting (always-on voice)",
"Gesture recognition",
"Object detection (edge cameras)",
"Anomaly detection (industrial IoT)",
"Vibration analysis (predictive maintenance)"
]STDP — біологічне навчання
Spike-Timing-Dependent Plasticity:
class STDPLearning:
"""
STDP — локальне unsupervised learning rule
If pre-spike comes BEFORE post-spike: strengthen synapse (LTP)
If pre-spike comes AFTER post-spike: weaken synapse (LTD)
"""
def __init__(self, tau_plus: float = 20.0, tau_minus: float = 20.0,
a_plus: float = 0.01, a_minus: float = 0.01):
self.tau_plus = tau_plus
self.tau_minus = tau_minus
self.a_plus = a_plus
self.a_minus = a_minus
def compute_weight_change(self, pre_times: np.ndarray,
post_times: np.ndarray) -> float:
"""
Обчислює зміну ваги на основі часів спайків
pre_times: масив часів pre-synaptic спайків
post_times: масив часів post-synaptic спайків
"""
delta_w = 0.0
for t_pre in pre_times:
for t_post in post_times:
dt = t_post - t_pre
if dt > 0:
# Pre before post: potentiation
delta_w += self.a_plus * np.exp(-dt / self.tau_plus)
else:
# Post before pre: depression
delta_w -= self.a_minus * np.exp(dt / self.tau_minus)
return delta_w
class STDPLayer(nn.Module):
"""Layer з online STDP learning"""
def __init__(self, in_features: int, out_features: int,
lr: float = 0.01):
super().__init__()
self.weights = nn.Parameter(torch.rand(out_features, in_features) * 0.1)
self.lr = lr
# Trace variables for STDP
self.pre_trace = None
self.post_trace = None
def forward(self, pre_spikes: torch.Tensor,
post_spikes: torch.Tensor = None) -> torch.Tensor:
"""
Forward pass + online STDP update
"""
# Decay traces
tau = 20.0
decay = np.exp(-1 / tau)
if self.pre_trace is None:
self.pre_trace = torch.zeros_like(pre_spikes)
self.post_trace = torch.zeros(pre_spikes.shape[0],
self.weights.shape[0])
# Update traces
self.pre_trace = decay * self.pre_trace + pre_spikes
if post_spikes is not None:
self.post_trace = decay * self.post_trace + post_spikes
# Compute output
output = torch.matmul(pre_spikes, self.weights.T)
# STDP update (if training)
if self.training and post_spikes is not None:
# LTP: post-spike × pre-trace
ltp = torch.outer(post_spikes.mean(0), self.pre_trace.mean(0))
# LTD: pre-spike × post-trace
ltd = torch.outer(self.post_trace.mean(0), pre_spikes.mean(0))
# Weight update
with torch.no_grad():
self.weights += self.lr * (ltp - ltd.T)
self.weights.clamp_(0, 1) # Keep weights bounded
return outputBenchmark результати
Порівняння енергоефективності:
| Task | Platform | Accuracy | Power | Energy/inf |
|------|----------|----------|-------|------------|
| Gesture (DVS128) | GPU (RTX 3090) | 97.2% | 350W | 70mJ |
| Gesture (DVS128) | Loihi 2 | 96.5% | 1W | 0.2mJ |
| Keyword spotting | GPU | 94% | 200W | 40mJ |
| Keyword spotting | Akida | 92% | 50mW | 0.1mJ |
Висновок: 100-1000x енергоефективність за 1-2% accuracy trade-off
Ідеї для дослідження
Для бакалаврської роботи:
- Конвертація простої CNN (MNIST) у SNN, порівняння accuracy
- Реалізація LIF neurons на snnTorch, visualization spike patterns
- Gesture recognition з DVS dataset (DVS128 Gesture)
Для магістерської:
- Surrogate gradient training для specific application
- SNN для anomaly detection в IoT (energy comparison)
- Deployment на BrainChip Akida через MetaTF
- Hybrid SNN-ANN architectures
Для PhD:
- Novel learning rules для SNN (beyond STDP)
- Theoretical expressiveness: що можуть SNN, чого не можуть ANN?
- Scaling SNN до vision transformers
- Bio-plausible credit assignment
Чому це майбутнє edge AI
Moore's Law сповільнюється. GPU споживають сотні ватів. Dennard scaling закінчився. А потреба в edge AI росте експоненційно.
SNN + нейроморфні чіпи — це не інкрементальне покращення. Це інша парадигма. Обчислення, що імітують мозок не метафорично, а буквально. Event-driven. Sparse. Energy-efficient.
Коли твій сенсор має працювати рік від батарейки — CNN не варіант. Коли потрібна мікросекундна latency — GPU не варіант. Коли треба always-on voice detection без drain battery — традиційні мережі не варіант.
SNN — варіант. І нейроморфні чіпи вже доступні комерційно.
Для тих, хто готує наукову роботу з SNN або нейроморфних обчислень — від курсової до дисертації — команда SKP-Degree на skp-degree.com.ua готова допомогти з дослідженням та реалізацією. Пишіть у Telegram: @kursovi_diplomy — маємо досвід супроводу проєктів у галузі neuromorphic computing.
Ключові слова: spiking neural networks, SNN, neuromorphic computing, Intel Loihi, IBM TrueNorth, BrainChip Akida, surrogate gradient, STDP, event-driven, edge AI, енергоефективність, наукова робота, дипломна, магістерська.