synaptic-ml 0.1.0__tar.gz

synaptic_ml-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hrishikesh Rajulu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

synaptic_ml-0.1.0/PKG-INFO

@@ -0,0 +1,307 @@
+Metadata-Version: 2.4
+Name: synaptic-ml
+Version: 0.1.0
+Summary: The TensorFlow for neuromorphic computing — high-level SNN framework
+Home-page: https://github.com/HrishikeshRajulu/synaptic-ml
+Author: synaptic_ml contributors
+Keywords: neuromorphic,spiking neural network,SNN,deep learning,Loihi,BrainScaleS,energy efficient AI,edge computing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scipy>=1.7
+Requires-Dist: matplotlib>=3.4
+Requires-Dist: tqdm>=4.62
+Provides-Extra: torch
+Requires-Dist: torch>=1.9; extra == "torch"
+Provides-Extra: loihi
+Requires-Dist: nxsdk; extra == "loihi"
+Provides-Extra: brainscales
+Requires-Dist: pynn_brainscales; extra == "brainscales"
+Requires-Dist: hxtorch; extra == "brainscales"
+Provides-Extra: sklearn
+Requires-Dist: scikit-learn>=0.24; extra == "sklearn"
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: scikit-learn>=0.24; extra == "dev"
+Provides-Extra: all
+Requires-Dist: torch>=1.9; extra == "all"
+Requires-Dist: scikit-learn>=0.24; extra == "all"
+Requires-Dist: tqdm>=4.62; extra == "all"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# synaptic_ml
+
+**The TensorFlow for Neuromorphic Computing.**
+
+Train spiking neural networks. Deploy to neuromorphic chips. Use 1000× less energy than GPU.
+
+```python
+import synaptic_ml as sml
+
+# Build a spiking network
+model = sml.SpikingNet([784, 256, 10])
+model.summary()
+
+# Train with surrogate gradients (like backprop, but for spikes)
+model.train(X_train, y_train, epochs=10)
+
+# Evaluate
+predictions = model.predict(X_test)
+
+# See the energy advantage
+print(sml.energy_comparison_table(model))
+
+# Deploy to neuromorphic hardware
+model.deploy(target='loihi2')      # Intel Loihi 2
+model.deploy(target='brainscales') # BrainScaleS-2
+model.deploy(target='cpu')         # CPU simulation (default, always works)
+```
+
+---
+
+## Why neuromorphic?
+
+| | GPU (A100) | Intel Loihi 2 | Human Brain |
+|--|--|--|--|
+| Power | 300W | 30mW | 20W |
+| Energy/inference | ~1000 nJ | ~0.1 nJ | ~0.001 nJ |
+| Efficiency | baseline | **10,000× better** | **1,000,000× better** |
+
+The brain uses 20 watts. GPT-4 uses 50 megawatts. That's a 2.5 million× gap.  
+Neuromorphic chips close that gap — and `synaptic_ml` makes them programmable.
+
+---
+
+## Installation
+
+```bash
+pip install synaptic-ml
+# or from source:
+git clone https://github.com/yourusername/synaptic-ml
+pip install -e .
+```
+
+**Optional extras:**
+```bash
+pip install synaptic-ml[torch]    # PyTorch ANN→SNN conversion
+pip install synaptic-ml[sklearn]  # MNIST examples
+pip install synaptic-ml[all]      # Everything
+```
+
+---
+
+## Core Concepts
+
+### Neuron Models
+
+```python
+# Leaky Integrate-and-Fire (default, fast, efficient)
+model = sml.SpikingNet([784, 256, 10], neuron='lif')
+
+# Adaptive LIF (spike-frequency adaptation)
+model = sml.SpikingNet([784, 256, 10], neuron='adaptive_lif')
+
+# Izhikevich (biologically rich: bursting, chattering, fast-spiking)
+model = sml.SpikingNet([784, 256, 10], neuron='izhikevich')
+```
+
+### Spike Encoders
+
+```python
+import synaptic_ml as sml
+import numpy as np
+
+x = np.random.rand(784)  # your data, values in [0, 1]
+
+# Rate coding: spike probability ∝ value (most common)
+enc = sml.RateEncoder(time_steps=100, max_rate=100)
+spikes = enc.encode(x)  # shape: (100, 784)
+
+# Temporal: earlier spike = stronger signal (most energy efficient)
+enc = sml.TemporalEncoder(time_steps=100)
+spikes = enc.encode(x)  # at most 1 spike per neuron
+
+# Population: Gaussian tuning curves (most biologically realistic)
+enc = sml.PopulationEncoder(n_neurons=10, sigma=0.5)
+spikes = enc.encode(x)  # shape: (100, 7840)
+
+# Delta: spikes only on change — perfect for IoT/sensors
+enc = sml.DeltaEncoder(threshold=0.05)
+spikes = enc.encode_series(time_series)  # event-driven
+```
+
+### Learning Rules
+
+```python
+# Surrogate gradients (recommended) — backprop through spikes
+model.train(X, y, learning_rule='surrogate', learning_rate=0.001)
+
+# STDP — unsupervised, no labels needed, biologically inspired
+model.train(X, y, learning_rule='stdp')
+
+# Custom trainer
+trainer = sml.Trainer(model, learning_rule='surrogate', learning_rate=0.001)
+trainer.fit(X_train, y_train, epochs=10, validation_split=0.1)
+trainer.evaluate(X_test, y_test)
+```
+
+### ANN → SNN Conversion
+
+Convert your existing PyTorch/Keras models to SNNs in one line:
+
+```python
+import torch.nn as nn
+import synaptic_ml as sml
+
+# Your existing trained ANN
+ann = nn.Sequential(nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10))
+
+# Convert to SNN (threshold balancing method)
+snn = sml.convert_from_pytorch(ann, X_calibration, time_steps=100)
+
+# Deploy to neuromorphic hardware
+snn.deploy(target='loihi2')
+```
+
+### Hardware Backends
+
+```python
+# CPU simulation — always works, no hardware needed
+backend = model.deploy(target='cpu')
+
+# Intel Loihi 2 — requires NxSDK (Intel Research Program)
+# Apply at: intel.com/loihi
+backend = model.deploy(target='loihi2')
+
+# BrainScaleS-2 — requires EBRAINS access (Human Brain Project)  
+# Apply at: ebrains.eu
+backend = model.deploy(target='brainscales')
+```
+
+### Energy Analysis
+
+```python
+# After running predictions:
+model.predict(X_test)
+
+# Detailed energy breakdown
+energy = model.estimate_energy()
+print(f"Ops/inference:    {energy['synaptic_ops_per_inference']:,.0f}")
+print(f"Energy/inference: {energy['energy_per_inference_nJ']:.4f} nJ")
+print(f"vs GPU:           {energy['efficiency_gain']:.0f}× more efficient")
+
+# Full comparison table
+print(sml.energy_comparison_table(model))
+```
+
+### Save / Load
+
+```python
+model.save('my_snn.snm')
+model = sml.SpikingNet.load('my_snn.snm')
+```
+
+---
+
+## Examples
+
+```bash
+# MNIST classification with LIF neurons
+python examples/mnist_lif.py
+
+# Unsupervised pattern learning with STDP
+python examples/pattern_recognition.py
+
+# IoT anomaly detection with delta encoding
+python examples/edge_sensor.py
+
+# Quick self-test
+python -m synaptic_ml
+```
+
+---
+
+## Architecture
+
+```
+synaptic_ml/
+├── core/
+│   ├── neurons.py      # LIF, Adaptive LIF, Izhikevich
+│   ├── synapses.py     # Dense, Sparse, Delayed
+│   ├── layers.py       # LIFLayer, OutputLayer, etc.
+│   └── network.py      # SpikingNet (main model class)
+├── encoding/
+│   ├── rate.py         # Poisson rate coding
+│   ├── temporal.py     # Time-to-first-spike, phase coding
+│   └── population.py   # Gaussian tuning, delta/event coding
+├── learning/
+│   ├── stdp.py         # STDP, reward-modulated STDP
+│   ├── surrogate.py    # Surrogate gradient functions
+│   └── conversion.py   # ANN→SNN threshold balancing
+├── backends/
+│   ├── cpu.py          # Pure numpy simulation
+│   ├── loihi2.py       # Intel Loihi 2 (NxSDK)
+│   └── brainscales.py  # BrainScaleS-2 (PyNN)
+├── training/
+│   └── trainer.py      # Training loop, loss functions
+└── utils/
+    ├── metrics.py      # Energy, spike metrics, Van Rossum distance
+    └── visualization.py # Raster plots, membrane traces, energy bars
+```
+
+---
+
+## Hardware Access
+
+Neither Loihi 2 nor BrainScaleS requires purchase — they're available through research programs:
+
+- **Intel Loihi 2**: [Intel Neuromorphic Research Community](https://www.intel.com/content/www/us/en/research/neuromorphic-computing.html)
+- **BrainScaleS-2**: [EBRAINS / Human Brain Project](https://www.ebrains.eu/)
+
+Until you get hardware access, the CPU backend gives exact simulation results.
+
+---
+
+## Roadmap
+
+- [ ] GPU-accelerated simulation (CuPy backend)
+- [ ] Innatera T1 chip support
+- [ ] Online/streaming inference API
+- [ ] Quantization-aware training
+- [ ] Multi-chip deployment
+- [ ] Web dashboard for spike visualization
+
+---
+
+## License
+
+MIT License. See LICENSE.
+
+---
+
+*The brain uses 20 watts. GPT-4 uses 50 megawatts. synaptic_ml bridges that gap.*

synaptic_ml-0.1.0/README.md

@@ -0,0 +1,251 @@
+# synaptic_ml
+
+**The TensorFlow for Neuromorphic Computing.**
+
+Train spiking neural networks. Deploy to neuromorphic chips. Use 1000× less energy than GPU.
+
+```python
+import synaptic_ml as sml
+
+# Build a spiking network
+model = sml.SpikingNet([784, 256, 10])
+model.summary()
+
+# Train with surrogate gradients (like backprop, but for spikes)
+model.train(X_train, y_train, epochs=10)
+
+# Evaluate
+predictions = model.predict(X_test)
+
+# See the energy advantage
+print(sml.energy_comparison_table(model))
+
+# Deploy to neuromorphic hardware
+model.deploy(target='loihi2')      # Intel Loihi 2
+model.deploy(target='brainscales') # BrainScaleS-2
+model.deploy(target='cpu')         # CPU simulation (default, always works)
+```
+
+---
+
+## Why neuromorphic?
+
+| | GPU (A100) | Intel Loihi 2 | Human Brain |
+|--|--|--|--|
+| Power | 300W | 30mW | 20W |
+| Energy/inference | ~1000 nJ | ~0.1 nJ | ~0.001 nJ |
+| Efficiency | baseline | **10,000× better** | **1,000,000× better** |
+
+The brain uses 20 watts. GPT-4 uses 50 megawatts. That's a 2.5 million× gap.  
+Neuromorphic chips close that gap — and `synaptic_ml` makes them programmable.
+
+---
+
+## Installation
+
+```bash
+pip install synaptic-ml
+# or from source:
+git clone https://github.com/yourusername/synaptic-ml
+pip install -e .
+```
+
+**Optional extras:**
+```bash
+pip install synaptic-ml[torch]    # PyTorch ANN→SNN conversion
+pip install synaptic-ml[sklearn]  # MNIST examples
+pip install synaptic-ml[all]      # Everything
+```
+
+---
+
+## Core Concepts
+
+### Neuron Models
+
+```python
+# Leaky Integrate-and-Fire (default, fast, efficient)
+model = sml.SpikingNet([784, 256, 10], neuron='lif')
+
+# Adaptive LIF (spike-frequency adaptation)
+model = sml.SpikingNet([784, 256, 10], neuron='adaptive_lif')
+
+# Izhikevich (biologically rich: bursting, chattering, fast-spiking)
+model = sml.SpikingNet([784, 256, 10], neuron='izhikevich')
+```
+
+### Spike Encoders
+
+```python
+import synaptic_ml as sml
+import numpy as np
+
+x = np.random.rand(784)  # your data, values in [0, 1]
+
+# Rate coding: spike probability ∝ value (most common)
+enc = sml.RateEncoder(time_steps=100, max_rate=100)
+spikes = enc.encode(x)  # shape: (100, 784)
+
+# Temporal: earlier spike = stronger signal (most energy efficient)
+enc = sml.TemporalEncoder(time_steps=100)
+spikes = enc.encode(x)  # at most 1 spike per neuron
+
+# Population: Gaussian tuning curves (most biologically realistic)
+enc = sml.PopulationEncoder(n_neurons=10, sigma=0.5)
+spikes = enc.encode(x)  # shape: (100, 7840)
+
+# Delta: spikes only on change — perfect for IoT/sensors
+enc = sml.DeltaEncoder(threshold=0.05)
+spikes = enc.encode_series(time_series)  # event-driven
+```
+
+### Learning Rules
+
+```python
+# Surrogate gradients (recommended) — backprop through spikes
+model.train(X, y, learning_rule='surrogate', learning_rate=0.001)
+
+# STDP — unsupervised, no labels needed, biologically inspired
+model.train(X, y, learning_rule='stdp')
+
+# Custom trainer
+trainer = sml.Trainer(model, learning_rule='surrogate', learning_rate=0.001)
+trainer.fit(X_train, y_train, epochs=10, validation_split=0.1)
+trainer.evaluate(X_test, y_test)
+```
+
+### ANN → SNN Conversion
+
+Convert your existing PyTorch/Keras models to SNNs in one line:
+
+```python
+import torch.nn as nn
+import synaptic_ml as sml
+
+# Your existing trained ANN
+ann = nn.Sequential(nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10))
+
+# Convert to SNN (threshold balancing method)
+snn = sml.convert_from_pytorch(ann, X_calibration, time_steps=100)
+
+# Deploy to neuromorphic hardware
+snn.deploy(target='loihi2')
+```
+
+### Hardware Backends
+
+```python
+# CPU simulation — always works, no hardware needed
+backend = model.deploy(target='cpu')
+
+# Intel Loihi 2 — requires NxSDK (Intel Research Program)
+# Apply at: intel.com/loihi
+backend = model.deploy(target='loihi2')
+
+# BrainScaleS-2 — requires EBRAINS access (Human Brain Project)  
+# Apply at: ebrains.eu
+backend = model.deploy(target='brainscales')
+```
+
+### Energy Analysis
+
+```python
+# After running predictions:
+model.predict(X_test)
+
+# Detailed energy breakdown
+energy = model.estimate_energy()
+print(f"Ops/inference:    {energy['synaptic_ops_per_inference']:,.0f}")
+print(f"Energy/inference: {energy['energy_per_inference_nJ']:.4f} nJ")
+print(f"vs GPU:           {energy['efficiency_gain']:.0f}× more efficient")
+
+# Full comparison table
+print(sml.energy_comparison_table(model))
+```
+
+### Save / Load
+
+```python
+model.save('my_snn.snm')
+model = sml.SpikingNet.load('my_snn.snm')
+```
+
+---
+
+## Examples
+
+```bash
+# MNIST classification with LIF neurons
+python examples/mnist_lif.py
+
+# Unsupervised pattern learning with STDP
+python examples/pattern_recognition.py
+
+# IoT anomaly detection with delta encoding
+python examples/edge_sensor.py
+
+# Quick self-test
+python -m synaptic_ml
+```
+
+---
+
+## Architecture
+
+```
+synaptic_ml/
+├── core/
+│   ├── neurons.py      # LIF, Adaptive LIF, Izhikevich
+│   ├── synapses.py     # Dense, Sparse, Delayed
+│   ├── layers.py       # LIFLayer, OutputLayer, etc.
+│   └── network.py      # SpikingNet (main model class)
+├── encoding/
+│   ├── rate.py         # Poisson rate coding
+│   ├── temporal.py     # Time-to-first-spike, phase coding
+│   └── population.py   # Gaussian tuning, delta/event coding
+├── learning/
+│   ├── stdp.py         # STDP, reward-modulated STDP
+│   ├── surrogate.py    # Surrogate gradient functions
+│   └── conversion.py   # ANN→SNN threshold balancing
+├── backends/
+│   ├── cpu.py          # Pure numpy simulation
+│   ├── loihi2.py       # Intel Loihi 2 (NxSDK)
+│   └── brainscales.py  # BrainScaleS-2 (PyNN)
+├── training/
+│   └── trainer.py      # Training loop, loss functions
+└── utils/
+    ├── metrics.py      # Energy, spike metrics, Van Rossum distance
+    └── visualization.py # Raster plots, membrane traces, energy bars
+```
+
+---
+
+## Hardware Access
+
+Neither Loihi 2 nor BrainScaleS requires purchase — they're available through research programs:
+
+- **Intel Loihi 2**: [Intel Neuromorphic Research Community](https://www.intel.com/content/www/us/en/research/neuromorphic-computing.html)
+- **BrainScaleS-2**: [EBRAINS / Human Brain Project](https://www.ebrains.eu/)
+
+Until you get hardware access, the CPU backend gives exact simulation results.
+
+---
+
+## Roadmap
+
+- [ ] GPU-accelerated simulation (CuPy backend)
+- [ ] Innatera T1 chip support
+- [ ] Online/streaming inference API
+- [ ] Quantization-aware training
+- [ ] Multi-chip deployment
+- [ ] Web dashboard for spike visualization
+
+---
+
+## License
+
+MIT License. See LICENSE.
+
+---
+
+*The brain uses 20 watts. GPT-4 uses 50 megawatts. synaptic_ml bridges that gap.*

synaptic_ml-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

synaptic_ml-0.1.0/setup.py

@@ -0,0 +1,63 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="synaptic-ml",
+    version="0.1.0",
+    author="synaptic_ml contributors",
+    description="The TensorFlow for neuromorphic computing — high-level SNN framework",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/HrishikeshRajulu/synaptic-ml",
+    packages=find_packages(),
+    python_requires=">=3.8",
+    install_requires=[
+        "numpy>=1.21",
+        "scipy>=1.7",
+        "matplotlib>=3.4",
+        "tqdm>=4.62",
+    ],
+    extras_require={
+        "torch": ["torch>=1.9"],
+        "loihi": ["nxsdk"],
+        "brainscales": ["pynn_brainscales", "hxtorch"],
+        "sklearn": ["scikit-learn>=0.24"],
+        "dev": [
+            "pytest>=6.0",
+            "pytest-cov",
+            "black",
+            "isort",
+            "scikit-learn>=0.24",
+        ],
+        "all": [
+            "torch>=1.9",
+            "scikit-learn>=0.24",
+            "tqdm>=4.62",
+        ],
+    },
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Science/Research",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Topic :: Scientific/Engineering :: Bio-Informatics",
+    ],
+    keywords=[
+        "neuromorphic", "spiking neural network", "SNN",
+        "deep learning", "Loihi", "BrainScaleS",
+        "energy efficient AI", "edge computing",
+    ],
+    entry_points={
+        "console_scripts": [
+            "synaptic-info=synaptic_ml.__main__:main",
+        ],
+    },
+)