Skip to content

Latest commit

 

History

History
240 lines (186 loc) · 8.88 KB

README.md

File metadata and controls

240 lines (186 loc) · 8.88 KB

Meta-Cognition Spiking Neural Network

Advanced hybrid AI architecture combining Spiking Neural Networks (SNN), SIMD-optimized vector operations, and 5 attention mechanisms with meta-cognitive self-discovery capabilities.

Features

Capability Performance Description
Spiking Neural Networks 10-50x faster LIF neurons + STDP learning with N-API SIMD
SIMD Vector Operations 5-54x faster Loop-unrolled distance/dot product calculations
5 Attention Mechanisms Sub-millisecond Multi-Head, Flash, Linear, Hyperbolic, MoE
Vector Search 150x faster RuVector-powered semantic search
Meta-Cognition Autonomous Self-discovering emergent capabilities

Quick Start

# Install dependencies
npm install

# Run all demos
node demos/run-all.js

# Or run specific demos
node demos/snn/examples/pattern-recognition.js
node demos/attention/all-mechanisms.js
node demos/optimization/simd-optimized-ops.js

Project Structure

meta-cognition-spiking-neural-network/
├── demos/                          # Runnable examples
│   ├── attention/                  # Attention mechanism demos
│   │   ├── all-mechanisms.js       # All 5 attention types compared
│   │   └── hyperbolic-deep-dive.js # Poincaré ball model exploration
│   ├── exploration/                # Autonomous discovery
│   │   ├── cognitive-explorer.js   # Full hybrid architecture
│   │   └── discoveries.js          # Emergent capability finder
│   ├── optimization/               # Performance optimization
│   │   ├── adaptive-cognitive-system.js  # Self-optimizing attention selection
│   │   ├── performance-benchmark.js      # Comprehensive benchmarks
│   │   └── simd-optimized-ops.js         # SIMD vector operations
│   ├── self-discovery/             # Meta-cognitive systems
│   │   ├── cognitive-explorer.js   # Self-awareness demos
│   │   └── enhanced-cognitive-system.js  # Multi-attention integration
│   ├── snn/                        # Spiking Neural Network
│   │   ├── examples/               # SNN demos
│   │   ├── lib/                    # JavaScript wrapper
│   │   └── native/                 # C++ SIMD implementation
│   ├── vector-search/              # Semantic search demos
│   └── run-all.js                  # Master demo runner
├── docs/                           # Documentation
│   ├── AGENTDB-EXPLORATION.md      # AgentDB capabilities guide
│   ├── DISCOVERIES.md              # 6 emergent discoveries
│   ├── HYPERBOLIC-ATTENTION-GUIDE.md # Poincaré ball attention
│   ├── OPTIMIZATION-GUIDE.md       # Performance tuning guide
│   ├── SIMD-OPTIMIZATION-GUIDE.md  # SIMD techniques
│   └── SNN-GUIDE.md                # Spiking Neural Network guide
├── verification/                   # Testing & verification
│   ├── VERIFICATION-REPORT.md      # Package verification results
│   ├── functional-test.js          # API functional tests
│   └── verify-agentdb.js           # AgentDB verification script
└── package.json

Core Components

1. Spiking Neural Networks (SNN)

Biologically-inspired neural networks with SIMD-optimized N-API native addon.

const { createFeedforwardSNN, rateEncoding } = require('./demos/snn/lib/SpikingNeuralNetwork');

const snn = createFeedforwardSNN([100, 50, 10], {
  dt: 1.0,
  tau: 20.0,
  a_plus: 0.005,
  lateral_inhibition: true
});

// Train with STDP
const input = rateEncoding(pattern, snn.dt, 100);
snn.step(input);

Performance:

  • LIF Updates: 16.7x speedup
  • Synaptic Forward: 14.9x speedup
  • STDP Learning: 26.3x speedup
  • Full Simulation: 18.4x speedup

2. SIMD Vector Operations

Loop-unrolled operations enabling CPU auto-vectorization.

const { distanceSIMD, dotProductSIMD, cosineSimilaritySIMD } = require('./demos/optimization/simd-optimized-ops');

const dist = distanceSIMD(vectorA, vectorB);  // 5-54x faster
const dot = dotProductSIMD(query, key);        // 1.5x faster
const cos = cosineSimilaritySIMD(a, b);        // 2.7x faster

Peak Performance:

  • Distance (128d): 54x speedup
  • Cosine (64d): 2.73x speedup
  • Batch (100+ pairs): 2.46x speedup

3. Attention Mechanisms

Five specialized attention types for different data structures.

Mechanism Best For Latency
Flash Long sequences 0.023ms
MoE Specialized domains 0.021ms
Multi-Head Complex patterns 0.047ms
Linear Real-time processing 0.075ms
Hyperbolic Hierarchical data 0.222ms 
// Run all mechanisms demo
node demos/attention/all-mechanisms.js

// Deep dive into hyperbolic attention
node demos/attention/hyperbolic-deep-dive.js

4. Meta-Cognitive Discovery

Autonomous system that discovers emergent capabilities.

// Run discovery system
node demos/exploration/discoveries.js

6 Discovered Emergent Behaviors:

  1. Multi-Scale Attention Hierarchy (Novelty: 5/5)
  2. Spike Synchronization Patterns
  3. Attention-Gated Spike Propagation
  4. Temporal Coherence Emergence
  5. Emergent Sparsity (80% fewer active neurons)
  6. Meta-Plasticity (faster learning on later tasks)

5. Vector Search

High-performance semantic search powered by RuVector.

node demos/vector-search/semantic-search.js

Performance: 0.409ms latency, 2,445 QPS, 150x faster than SQLite

Demos

Run All Demos

node demos/run-all.js

Individual Demos

Demo Command Description
SNN Pattern Recognition node demos/snn/examples/pattern-recognition.js 5x5 pattern classification with STDP
SNN Benchmark node demos/snn/examples/benchmark.js Performance analysis
All Attention node demos/attention/all-mechanisms.js Compare 5 mechanisms
Hyperbolic Deep Dive node demos/attention/hyperbolic-deep-dive.js Poincaré ball exploration
SIMD Operations node demos/optimization/simd-optimized-ops.js Vector operation benchmarks
Adaptive System node demos/optimization/adaptive-cognitive-system.js Self-optimizing attention
Performance Benchmark node demos/optimization/performance-benchmark.js Comprehensive benchmarks
Semantic Search node demos/vector-search/semantic-search.js Vector search demo
Cognitive Explorer node demos/self-discovery/cognitive-explorer.js Self-awareness demo
Enhanced Cognitive node demos/self-discovery/enhanced-cognitive-system.js Multi-attention integration
Discoveries node demos/exploration/discoveries.js Emergent capability discovery
Full Explorer node demos/exploration/cognitive-explorer.js Complete hybrid architecture

Documentation

Detailed guides in the docs/ folder:

Building Native SNN Addon

For maximum SNN performance, build the native SIMD addon:

cd demos/snn
npm install
npm run build

# Verify native addon
node examples/benchmark.js

Requirements:

  • Node.js >= 16.0.0
  • C++ compiler (g++, clang, or MSVC)
  • SSE/AVX CPU support

Key Insights

  1. Hybrid Architectures Win: SNN + Attention creates emergent capabilities
  2. SIMD is Essential: 5-54x speedup for vector operations
  3. Attention Selection Matters: Different mechanisms for different problems
  4. Meta-Cognition Works: Systems can discover their own capabilities
  5. Sparsity is Efficient: 80% reduction in active neurons via lateral inhibition

Performance Summary

Operation               | Speedup | Notes
------------------------|---------|---------------------------
STDP Learning           | 26.3x   | SIMD + N-API
Distance (128d)         | 54.0x   | Loop unrolling champion
Full SNN Simulation     | 18.4x   | LIF + Synaptic + STDP
Cosine Similarity (64d) | 2.73x   | Triple accumulation
Vector Search           | 150x    | vs SQLite baseline
Attention (Flash)       | 0.023ms | Sub-millisecond

License

MIT License - See LICENSE

Related Packages