use crate::error::{BarracudaError, Result as BarracudaResult};
use rand::{Rng, SeedableRng};
#[derive(Debug, Clone)]
pub struct SNNConfig {
pub input_encoding: EncodingType,
pub output_decoding: DecodingType,
pub auto_reset: bool,
pub dt: f32,
}
impl Default for SNNConfig {
fn default() -> Self {
Self {
input_encoding: EncodingType::Rate { max_rate: 100.0 },
output_decoding: DecodingType::Rate,
auto_reset: true,
dt: 1.0,
}
}
}
#[derive(Debug, Clone)]
pub enum EncodingType {
Rate {
max_rate: f32,
},
Temporal,
Population {
n_neurons: usize,
},
}
#[derive(Debug, Clone)]
pub enum DecodingType {
Rate,
FirstSpike,
PopulationVector,
}
#[derive(Debug, Clone)]
pub enum SNNLayer {
LIF {
size: usize,
tau: f32,
threshold: f32,
reset: f32,
},
TemporalPool {
window_size: usize,
},
SparseLinear {
input_size: usize,
output_size: usize,
sparsity: f32,
weights: Option<Vec<f32>>,
},
RateEncoder {
max_rate: f32,
},
RateDecoder,
}
struct LayerState {
membrane: Vec<f32>,
spikes: Vec<f32>,
temporal_buffer: Vec<Vec<f32>>,
weights: Option<Vec<f32>>,
}
impl LayerState {
fn new(size: usize) -> Self {
Self {
membrane: vec![0.0; size],
spikes: vec![0.0; size],
temporal_buffer: Vec::new(),
weights: None,
}
}
}
pub struct SpikingNetwork {
config: SNNConfig,
layers: Vec<SNNLayer>,
states: Vec<LayerState>,
}
pub struct SNNBuilder {
layers: Vec<SNNLayer>,
config: SNNConfig,
}
impl SNNBuilder {
fn new(config: SNNConfig) -> Self {
Self {
layers: Vec::new(),
config,
}
}
#[must_use]
pub fn add_layer(mut self, layer: SNNLayer) -> Self {
self.layers.push(layer);
self
}
#[must_use]
pub fn build(self) -> SpikingNetwork {
let mut states = Vec::new();
for layer in &self.layers {
let size = match layer {
SNNLayer::LIF { size, .. } => *size,
SNNLayer::TemporalPool { .. } => 0, SNNLayer::SparseLinear { output_size, .. } => *output_size,
SNNLayer::RateEncoder { .. } => 0,
SNNLayer::RateDecoder => 0,
};
let mut state = LayerState::new(size);
if let SNNLayer::SparseLinear {
input_size,
output_size,
sparsity,
weights,
} = layer
{
let w = if let Some(w) = weights {
w.clone()
} else {
let mut rng = rand::rngs::StdRng::from_os_rng();
let mut weights = vec![0.0; input_size * output_size];
for w in &mut weights {
if rng.random::<f32>() < *sparsity {
*w = rng.random_range(-1.0..1.0);
}
}
weights
};
state.weights = Some(w);
}
states.push(state);
}
SpikingNetwork {
config: self.config,
layers: self.layers,
states,
}
}
}
impl SpikingNetwork {
#[must_use]
pub fn builder() -> SNNBuilder {
SNNBuilder::new(SNNConfig::default())
}
#[must_use]
pub fn builder_with_config(config: SNNConfig) -> SNNBuilder {
SNNBuilder::new(config)
}
pub fn process_step(&mut self, input: impl Into<Vec<f32>>) -> BarracudaResult<Vec<f32>> {
let mut current = input.into();
for i in 0..self.layers.len() {
current = self.process_layer(i, ¤t)?;
}
Ok(current)
}
pub fn process_sequence(&mut self, sequence: &[Vec<f32>]) -> BarracudaResult<Vec<Vec<f32>>> {
sequence
.iter()
.map(|input| self.process_step(input.as_slice()))
.collect()
}
fn process_layer(&mut self, layer_idx: usize, input: &[f32]) -> BarracudaResult<Vec<f32>> {
let layer = &self.layers[layer_idx];
let state = &mut self.states[layer_idx];
match layer {
SNNLayer::LIF {
size,
tau,
threshold,
reset,
} => {
if input.len() != *size {
return Err(BarracudaError::InvalidInput {
message: format!(
"LIF input size mismatch: expected {}, got {}",
size,
input.len()
),
});
}
let dt = self.config.dt;
let decay_factor = 1.0 - (dt / tau);
for ((membrane, inp), spike) in state
.membrane
.iter_mut()
.zip(input.iter())
.zip(state.spikes.iter_mut())
{
*membrane *= decay_factor;
*membrane += *inp;
if *membrane >= *threshold {
*spike = 1.0;
*membrane = *reset; } else {
*spike = 0.0;
}
}
Ok(state.spikes.clone())
}
SNNLayer::TemporalPool { window_size } => {
state.temporal_buffer.push(input.to_vec());
if state.temporal_buffer.len() > *window_size {
state.temporal_buffer.remove(0);
}
let output_size = input.len();
let mut pooled = vec![0.0; output_size];
for frame in &state.temporal_buffer {
for (i, &spike) in frame.iter().enumerate() {
pooled[i] += spike;
}
}
Ok(pooled)
}
SNNLayer::SparseLinear {
input_size,
output_size,
..
} => {
if input.len() != *input_size {
return Err(BarracudaError::InvalidInput {
message: format!(
"Linear input size mismatch: expected {}, got {}",
input_size,
input.len()
),
});
}
let weights = state.weights.as_ref().ok_or_else(|| {
crate::error::BarracudaError::InvalidOperation {
op: "SNN Dense layer".to_string(),
reason: "Dense layer weights not initialized".to_string(),
}
})?;
let mut output = vec![0.0; *output_size];
for i in 0..*output_size {
for j in 0..*input_size {
output[i] = weights[i * input_size + j].mul_add(input[j], output[i]);
}
}
Ok(output)
}
SNNLayer::RateEncoder { max_rate } => {
let mut rng = rand::rngs::StdRng::from_os_rng();
let dt = self.config.dt;
let spikes: Vec<f32> = input
.iter()
.map(|&value| {
let spike_prob = value.abs() * max_rate * dt / 1000.0; if rng.random::<f32>() < spike_prob {
1.0
} else {
0.0
}
})
.collect();
Ok(spikes)
}
SNNLayer::RateDecoder => {
Ok(input.to_vec())
}
}
}
pub fn reset(&mut self) {
for state in &mut self.states {
state.membrane.fill(0.0);
state.spikes.fill(0.0);
state.temporal_buffer.clear();
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_snn_builder() {
let network = SpikingNetwork::builder()
.add_layer(SNNLayer::LIF {
size: 10,
tau: 20.0,
threshold: 1.0,
reset: 0.0,
})
.build();
assert_eq!(network.layers.len(), 1);
}
#[test]
fn test_lif_spike() {
let mut network = SpikingNetwork::builder()
.add_layer(SNNLayer::LIF {
size: 5,
tau: 10.0,
threshold: 1.0,
reset: 0.0,
})
.build();
let input = vec![2.0, 2.0, 2.0, 2.0, 2.0];
let output = network.process_step(input.as_slice()).unwrap();
assert!(output.contains(&1.0));
}
#[test]
fn test_lif_no_spike() {
let mut network = SpikingNetwork::builder()
.add_layer(SNNLayer::LIF {
size: 5,
tau: 10.0,
threshold: 1.0,
reset: 0.0,
})
.build();
let input = vec![0.1, 0.1, 0.1, 0.1, 0.1];
let output = network.process_step(input.as_slice()).unwrap();
assert!(output.iter().all(|&x| x == 0.0));
}
#[test]
fn test_temporal_pool() {
let mut network = SpikingNetwork::builder()
.add_layer(SNNLayer::TemporalPool { window_size: 3 })
.build();
network.process_step([1.0, 0.0]).unwrap();
network.process_step([0.0, 1.0]).unwrap();
let output = network.process_step([1.0, 0.0]).unwrap();
assert_eq!(output[0], 2.0); assert_eq!(output[1], 1.0); }
#[test]
fn test_sparse_linear() {
let weights = vec![
0.5, 0.0, 0.0, 0.5, 0.0, 0.5, 0.5, 0.0, ];
let mut network = SpikingNetwork::builder()
.add_layer(SNNLayer::SparseLinear {
input_size: 4,
output_size: 2,
sparsity: 0.5,
weights: Some(weights),
})
.build();
let input = vec![1.0, 2.0, 3.0, 4.0];
let output = network.process_step(input.as_slice()).unwrap();
assert!((output[0] - 2.5).abs() < 1e-6);
assert!((output[1] - 2.5).abs() < 1e-6);
}
#[test]
fn test_rate_encoding() {
let mut network = SpikingNetwork::builder()
.add_layer(SNNLayer::RateEncoder { max_rate: 100.0 })
.build();
let high_input = vec![1.0; 10];
let low_input = vec![0.1; 10];
let mut high_spike_count = 0;
let mut low_spike_count = 0;
for _ in 0..1000 {
let high_out = network.process_step(high_input.as_slice()).unwrap();
let low_out = network.process_step(low_input.as_slice()).unwrap();
high_spike_count += high_out.iter().filter(|&&x| x == 1.0).count();
low_spike_count += low_out.iter().filter(|&&x| x == 1.0).count();
}
assert!(high_spike_count > low_spike_count * 2);
}
#[test]
fn test_network_reset() {
let mut network = SpikingNetwork::builder()
.add_layer(SNNLayer::LIF {
size: 5,
tau: 10.0,
threshold: 1.0,
reset: 0.0,
})
.build();
network.process_step([0.5; 5]).unwrap();
network.reset();
assert!(network.states[0].membrane.iter().all(|&x| x == 0.0));
assert!(network.states[0].spikes.iter().all(|&x| x == 0.0));
}
#[test]
fn test_multi_layer_network() {
let mut network = SpikingNetwork::builder()
.add_layer(SNNLayer::LIF {
size: 10,
tau: 20.0,
threshold: 1.0,
reset: 0.0,
})
.add_layer(SNNLayer::TemporalPool { window_size: 5 })
.build();
let sequence = vec![vec![1.5; 10], vec![1.5; 10], vec![0.0; 10]];
let outputs = network.process_sequence(&sequence).unwrap();
assert_eq!(outputs.len(), 3);
}
}