File size: 2,609 Bytes
9d72007 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 | from __future__ import annotations
import torch
from torch import nn
from torch.nn import functional as F
def surrogate_spike(membrane: torch.Tensor, threshold: float = 1.0) -> torch.Tensor:
hard = (membrane >= threshold).float()
soft = torch.sigmoid((membrane - threshold) * 10.0)
return hard + soft - soft.detach()
class LIFSpikingClassifier(nn.Module):
def __init__(self, hidden_dimensions: int = 64, decay: float = 0.85) -> None:
super().__init__()
self.hidden_dimensions = hidden_dimensions
self.decay = decay
self.input = nn.Linear(64, hidden_dimensions)
self.output = nn.Linear(hidden_dimensions, 10)
def forward(
self,
pixels: torch.Tensor,
*,
timesteps: int = 24,
generator: torch.Generator | None = None,
return_raster: bool = False,
) -> tuple[torch.Tensor, torch.Tensor] | tuple[
torch.Tensor, torch.Tensor, torch.Tensor
]:
membrane = torch.zeros(
len(pixels),
self.hidden_dimensions,
device=pixels.device,
)
logits = torch.zeros(len(pixels), 10, device=pixels.device)
spike_total = torch.zeros((), device=pixels.device)
input_raster = []
for _ in range(timesteps):
random_values = torch.rand(
pixels.shape,
generator=generator,
device=pixels.device,
)
input_spikes = (random_values < pixels).float()
membrane = self.decay * membrane + self.input(input_spikes)
hidden_spikes = surrogate_spike(membrane)
membrane = membrane - hidden_spikes.detach()
logits = logits + self.output(hidden_spikes)
spike_total = spike_total + hidden_spikes.sum()
if return_raster:
input_raster.append(input_spikes)
spike_rate = spike_total / (len(pixels) * self.hidden_dimensions * timesteps)
if return_raster:
return logits / timesteps, spike_rate, torch.stack(input_raster, dim=1)
return logits / timesteps, spike_rate
class MatchedDenseClassifier(nn.Module):
def __init__(self, hidden_dimensions: int = 64) -> None:
super().__init__()
self.first = nn.Linear(64, hidden_dimensions)
self.output = nn.Linear(hidden_dimensions, 10)
def forward(self, pixels: torch.Tensor) -> torch.Tensor:
return self.output(F.gelu(self.first(pixels)))
def parameter_count(model: nn.Module) -> int:
return sum(parameter.numel() for parameter in model.parameters())
|