@ruvector/nervous-system-wasm

Bio-inspired AI components compiled to WebAssembly. Implements Hyperdimensional Computing (HDC) for ultra-fast classification, Behavioral Time-Scale Synaptic Plasticity (BTSP) for one-shot learning, and neuromorphic spiking network primitives.

Quick Reference

Installation

bash
1npx @ruvector/nervous-system-wasm@latest

Node.js Usage

typescript
1import init, {
2  HyperdimensionalComputing,
3  BTSP,
4  SpikingNetwork,
5} from '@ruvector/nervous-system-wasm';
6
7await init();
8
9// Hyperdimensional Computing: encode and classify
10const hdc = new HyperdimensionalComputing({
11  dimensions: 10_000,
12  numClasses: 5,
13  encoding: 'random-projection',
14});
15
16// Train on labeled data
17hdc.train('cat', new Float32Array([0.1, 0.8, 0.2, 0.9]));
18hdc.train('dog', new Float32Array([0.9, 0.2, 0.8, 0.1]));
19
20// Classify new input
21const result = hdc.classify(new Float32Array([0.15, 0.75, 0.25, 0.85]));
22console.log(`Class: ${result.label}, confidence: ${result.confidence}`);
23
24// BTSP: one-shot synaptic plasticity
25const btsp = new BTSP({
26  inputSize: 100,
27  outputSize: 50,
28  plasticityRate: 0.1,
29  plateauDuration: 10,
30});
31
32const input = new Float32Array(100).fill(0.5);
33const target = new Float32Array(50).fill(1.0);
34btsp.learn(input, target);  // Single-exposure learning
35
36const output = btsp.forward(input);
37console.log('BTSP output correlation:', btsp.correlation(output, target));
38
39// Spiking Neural Network
40const snn = new SpikingNetwork({
41  neurons: 1000,
42  excitatory: 800,
43  inhibitory: 200,
44  connectivity: 0.1,
45  model: 'izhikevich',
46});
47
48const spikes = snn.step(new Float32Array(1000));
49console.log(`Active neurons: ${spikes.filter(s => s > 0).length}`);

Browser Usage

html
1<script type="module">
2  import init, { HyperdimensionalComputing } from '@ruvector/nervous-system-wasm';
3  await init();
4
5  const hdc = new HyperdimensionalComputing({ dimensions: 10000, numClasses: 3 });
6  hdc.train('A', new Float32Array([1, 0, 0]));
7  hdc.train('B', new Float32Array([0, 1, 0]));
8  const result = hdc.classify(new Float32Array([0.9, 0.1, 0]));
9  console.log(result.label); // 'A'
10</script>

Key API

HyperdimensionalComputing

Ultra-fast classification using high-dimensional binary vectors.

typescript
1const hdc = new HyperdimensionalComputing(config: HDCConfig);

HDCConfig:

typescript
1hdc.train(label: string, features: Float32Array): void
2hdc.classify(features: Float32Array): ClassifyResult
3hdc.batchClassify(batch: Float32Array[]): ClassifyResult[]
4hdc.encode(features: Float32Array): Float32Array  // Raw hypervector
5hdc.retrain(): void  // Re-optimize class prototypes
6hdc.accuracy(testData: Array<{ features: Float32Array; label: string }>): number

ClassifyResult: { label: string; confidence: number; scores: Record<string, number> }

BTSP

Behavioral Time-Scale Synaptic Plasticity for one-shot learning.

typescript
1const btsp = new BTSP(config: BTSPConfig);

BTSPConfig:

typescript
1btsp.learn(input: Float32Array, target: Float32Array): void
2btsp.forward(input: Float32Array): Float32Array
3btsp.correlation(output: Float32Array, target: Float32Array): number
4btsp.weights(): Float32Array
5btsp.reset(): void

SpikingNetwork

Spiking Neural Network with configurable neuron models.

typescript
1const snn = new SpikingNetwork(config: SNNConfig);

SNNConfig:

typescript
1snn.step(input: Float32Array): Float32Array          // One timestep, returns spikes
2snn.stepN(input: Float32Array, n: number): Float32Array[]  // N timesteps
3snn.membranePotentials(): Float32Array
4snn.firingRates(): Float32Array
5snn.reset(): void

References

• API Reference
• npm