spiking-neural

A high-performance Spiking Neural Network (SNN) library for Node.js with biologically-inspired neuron models and unsupervised learning. SNNs process information through discrete spike events rather than continuous values, making them more energy-efficient and better suited for temporal pattern recognition.

What Are Spiking Neural Networks?

Unlike traditional neural networks that use continuous activation values, SNNs communicate through discrete spike events timed in milliseconds. This mirrors how biological neurons work, enabling:

• Temporal pattern recognition - naturally process time-series data
• Energy efficiency - event-driven computation (10-100x lower power)
• Online learning - adapt in real-time with STDP (no batches needed)
• Neuromorphic deployment - run on specialized hardware like Intel Loihi

Key Features

| Feature | Description | |---------|-------------| | LIF Neurons | Leaky Integrate-and-Fire model with configurable membrane dynamics | | STDP Learning | Spike-Timing-Dependent Plasticity for unsupervised pattern learning | | Lateral Inhibition | Winner-take-all competition for sparse representations | | SIMD Optimization | Loop-unrolled vector math for 5-54x speedup | | Multiple Encodings | Rate coding and temporal coding for flexible input handling | | Zero Dependencies | Pure JavaScript SDK works everywhere Node.js runs |

Installation

npm install spiking-neural

Note: This package is pure JavaScript and works out of the box. No native compilation required.

Quick Start

CLI Usage

# Run pattern recognition demo
npx spiking-neural demo pattern

# Run performance benchmarks
npx spiking-neural benchmark

# Run SIMD vector operation benchmarks
npx spiking-neural simd

# Run validation tests
npx spiking-neural test

# Show help
npx spiking-neural help

SDK Usage

const {
  createFeedforwardSNN,
  rateEncoding,
  native
} = require('spiking-neural');

// Create a 3-layer feedforward SNN
const snn = createFeedforwardSNN([100, 50, 10], {
  dt: 1.0,               // 1ms time step
  tau: 20.0,             // 20ms membrane time constant
  a_plus: 0.005,         // STDP LTP rate
  a_minus: 0.005,        // STDP LTD rate
  lateral_inhibition: true,
  inhibition_strength: 10.0
});

// Create input pattern
const input = new Float32Array(100).fill(0.5);

// Run simulation
for (let t = 0; t < 100; t++) {
  const spikes = rateEncoding(input, snn.dt, 100);
  snn.step(spikes);
}

// Get output
const output = snn.getOutput();
console.log('Output:', output);

CLI Commands

| Command | Description | |---------|-------------| | demo <type> | Run demonstration (pattern, temporal, learning, all) | | benchmark | Run SNN performance benchmarks | | simd | Run SIMD vector operation benchmarks | | train | Train a custom SNN | | test | Run validation tests | | info | Show system information | | version | Show version | | help | Show help |

Examples

# Pattern recognition with 5x5 pixel patterns
npx spiking-neural demo pattern

# Train custom network
npx spiking-neural train --layers 25,50,10 --epochs 10

# All demos
npx spiking-neural demo all

API Reference

createFeedforwardSNN(layer_sizes, params)

Create a feedforward spiking neural network.

const snn = createFeedforwardSNN([100, 50, 10], {
  dt: 1.0,                    // Time step (ms)
  tau: 20.0,                  // Membrane time constant (ms)
  v_rest: -70.0,              // Resting potential (mV)
  v_reset: -75.0,             // Reset potential (mV)
  v_thresh: -50.0,            // Spike threshold (mV)
  resistance: 10.0,           // Membrane resistance (MOhm)
  a_plus: 0.01,               // STDP LTP learning rate
  a_minus: 0.01,              // STDP LTD learning rate
  w_min: 0.0,                 // Minimum weight
  w_max: 1.0,                 // Maximum weight
  init_weight: 0.5,           // Initial weight mean
  init_std: 0.1,              // Initial weight std
  lateral_inhibition: false,  // Enable winner-take-all
  inhibition_strength: 10.0   // Inhibition strength
});

SpikingNeuralNetwork

// Run one time step
const spike_count = snn.step(input_spikes);

// Run for duration
const results = snn.run(100, (time) => inputGenerator(time));

// Get output spikes
const output = snn.getOutput();

// Get network statistics
const stats = snn.getStats();

// Reset network
snn.reset();

rateEncoding(values, dt, max_rate)

Encode values as Poisson spike trains.

const input = new Float32Array([0.5, 0.8, 0.2]);
const spikes = rateEncoding(input, 1.0, 100); // 100 Hz max rate

temporalEncoding(values, time, t_start, t_window)

Encode values as time-to-first-spike.

const input = new Float32Array([0.5, 0.8, 0.2]);
const spikes = temporalEncoding(input, currentTime, 0, 50);

SIMDOps

SIMD-optimized vector operations.

const { SIMDOps } = require('spiking-neural');

const a = new Float32Array([1, 2, 3, 4]);
const b = new Float32Array([4, 3, 2, 1]);

SIMDOps.dotProduct(a, b);        // Dot product
SIMDOps.distance(a, b);          // Euclidean distance
SIMDOps.cosineSimilarity(a, b);  // Cosine similarity

LIFLayer

Low-level LIF neuron layer.

const { LIFLayer } = require('spiking-neural');

const layer = new LIFLayer(100, {
  tau: 20.0,
  v_thresh: -50.0,
  dt: 1.0
});

layer.setCurrents(inputCurrents);
const spike_count = layer.update();
const spikes = layer.getSpikes();

SynapticLayer

Low-level synaptic connection layer with STDP.

const { SynapticLayer } = require('spiking-neural');

const synapses = new SynapticLayer(100, 50, {
  a_plus: 0.01,
  a_minus: 0.01,
  w_min: 0.0,
  w_max: 1.0
});

synapses.forward(pre_spikes, post_currents);
synapses.learn(pre_spikes, post_spikes);
const stats = synapses.getWeightStats();

Performance

JavaScript (Auto-vectorization)

| Operation | 64d | 128d | 256d | 512d | |-----------|-----|------|------|------| | Dot Product | 1.1x | 1.2x | 1.6x | 1.5x | | Distance | 5x | 54x | 13x | 9x | | Cosine | 2.7x | 1.0x | 0.9x | 0.9x |

Benchmark Results

| Network Size | Updates/sec | Latency | |--------------|-------------|---------| | 100 neurons | 16,000+ | 0.06ms | | 1,000 neurons | 1,500+ | 0.67ms | | 10,000 neurons | 150+ | 6.7ms |

Examples

Pattern Recognition

const { createFeedforwardSNN, rateEncoding } = require('spiking-neural');

// 5x5 pattern -> 4 classes
const snn = createFeedforwardSNN([25, 20, 4], {
  a_plus: 0.005,
  lateral_inhibition: true
});

// Define patterns
const cross = [
  0,0,1,0,0,
  0,0,1,0,0,
  1,1,1,1,1,
  0,0,1,0,0,
  0,0,1,0,0
];

// Train
for (let epoch = 0; epoch < 5; epoch++) {
  snn.reset();
  for (let t = 0; t < 100; t++) {
    snn.step(rateEncoding(cross, 1.0, 100));
  }
}

// Test
snn.reset();
for (let t = 0; t < 100; t++) {
  snn.step(rateEncoding(cross, 1.0, 100));
}
const output = snn.getOutput();
const winner = Array.from(output).indexOf(Math.max(...output));
console.log(`Pattern classified as neuron ${winner}`);

Custom Network Architecture

const { LIFLayer, SynapticLayer, SpikingNeuralNetwork } = require('spiking-neural');

// Build custom architecture
const input_layer = new LIFLayer(100, { tau: 15.0 });
const hidden_layer = new LIFLayer(50, { tau: 20.0 });
const output_layer = new LIFLayer(10, { tau: 25.0 });

const input_hidden = new SynapticLayer(100, 50, { a_plus: 0.01 });
const hidden_output = new SynapticLayer(50, 10, { a_plus: 0.005 });

const layers = [
  { neuron_layer: input_layer, synaptic_layer: input_hidden },
  { neuron_layer: hidden_layer, synaptic_layer: hidden_output },
  { neuron_layer: output_layer, synaptic_layer: null }
];

const snn = new SpikingNeuralNetwork(layers, {
  lateral_inhibition: true
});

Related Demos

This package is part of the ruvector meta-cognition examples:

| Demo | Description | Command | |------|-------------|---------| | Pattern Recognition | 5x5 pixel classification | npx spiking-neural demo pattern | | SIMD Benchmarks | Vector operation performance | npx spiking-neural simd | | Attention Mechanisms | 5 attention types | See meta-cognition examples | | Hyperbolic Attention | Poincaré ball model | See meta-cognition examples | | Self-Discovery | Meta-cognitive systems | See meta-cognition examples |

What are Spiking Neural Networks?

SNNs are third-generation neural networks that model biological neurons:

| Feature | Traditional ANN | Spiking NN | |---------|-----------------|------------| | Activation | Continuous values | Discrete spikes | | Time | Ignored | Integral to computation | | Learning | Backpropagation | STDP (Hebbian) | | Energy | High | 10-100x lower | | Hardware | GPU/TPU | Neuromorphic chips |

Advantages:

• More biologically realistic
• Energy efficient (event-driven)
• Natural for temporal data
• Online learning without batches

License

MIT © rUv

Links

• Homepage: ruv.io
• GitHub: github.com/ruvnet/ruvector
• npm: npmjs.com/package/spiking-neural
• SNN Guide: Meta-Cognition Examples