🧠 Neuromorphic Spiking Neural Network (SNN) Digit Classifier

Brain-Inspired AI for Real-Time Handwritten Digit Recognition using Spiking Neural Networks

⚡ Brain-Inspired Computing with Spiking Neural Networks

A Neuromorphic AI application that recognizes handwritten digits using biologically inspired Leaky Integrate-and-Fire (LIF) neurons, temporal spike processing, and interactive visualization.

📖 Overview

Neuromorphic Spiking Neural Network (SNN) Digit Classifier is an end-to-end Deep Learning application that classifies handwritten digits (0–9) using Spiking Neural Networks (SNNs) instead of conventional Artificial Neural Networks (ANNs).

Unlike traditional neural networks that process continuous activation values, SNNs communicate using discrete spikes over time, closely resembling how neurons communicate inside the human brain.

The project is built using PyTorch, snnTorch, and Torchvision, and deployed through an interactive Streamlit dashboard where users can draw digits, visualize spike activity, inspect output neuron firing, and observe the decision-making process of a neuromorphic neural network.

🎯 Project Objectives

This project aims to:

Learn Neuromorphic AI fundamentals
Understand Spiking Neural Networks
Simulate biological neuron behavior
Train an SNN on the MNIST dataset
Visualize temporal spike activity
Build an interactive AI dashboard
Demonstrate energy-efficient AI concepts

🌟 Features

🧠 Spiking Neural Network

Implements a biologically inspired neural architecture using:

Leaky Integrate-and-Fire (LIF) neurons
Temporal spike propagation
Membrane potential dynamics
Spike accumulation
Surrogate gradient learning

✍ Interactive Digit Drawing Canvas

Users can:

Draw handwritten digits
Clear the canvas
Predict instantly
Observe live inference

⚡ Real-Time Spike Visualization

The dashboard displays:

Output neuron spikes
Spike counts
Raster plots
Temporal firing activity
Prediction confidence

📊 Probability Distribution

Visualize:

Softmax probabilities
Spike accumulation
Winning neuron
Confidence score

🎨 Modern Dashboard

Built with:

Streamlit
Plotly
Dark Theme UI
Interactive Components

🧠 What are Spiking Neural Networks?

Traditional neural networks communicate using continuous numbers.

Neuron A
      │
      ▼
Activation = 0.82

Spiking Neural Networks communicate using discrete spikes over time.

Time →

Neuron A

0 0 1 0 0 1 1 0 0 1

This temporal behavior closely resembles biological neurons and enables energy-efficient computation suitable for neuromorphic hardware.

⚙ Leaky Integrate-and-Fire (LIF) Neuron

The project uses Leaky Integrate-and-Fire (LIF) neurons.

Each neuron:

Integrates incoming current
Stores membrane potential
Leaks over time
Fires when threshold is crossed
Resets after firing

Membrane Potential

[ U_t = \beta U_{t-1} + I_t ]

Where

(U_t) = Membrane Potential
(I_t) = Input Current
(\beta) = Leakage Constant

Spike Generation

If

[ U_t \ge U_{threshold} ]

Neuron emits

[ S_t = 1 ]

Otherwise

[ S_t = 0 ]

🏗 Network Architecture

                    MNIST Image
                     (28 × 28)
                          │
                          ▼
                  Flatten (784)
                          │
                          ▼
              Fully Connected Layer
                     (784 → 128)
                          │
                          ▼
             Leaky Integrate-and-Fire
                    Hidden Layer
                          │
                          ▼
              Fully Connected Layer
                     (128 → 10)
                          │
                          ▼
             Leaky Integrate-and-Fire
                  Output Neurons
                          │
                          ▼
                Spike Accumulation
                          │
                          ▼
                 Digit Prediction

⏱ Temporal Processing

Unlike ANNs, inference occurs across 25 simulation time steps.

T = 25

Time →

t0
t1
t2
t3
...
t24

Each neuron may fire multiple spikes.

The digit with the highest accumulated spike count is selected.

🔄 Complete ML Pipeline

MNIST Dataset

        │

        ▼

Image Preprocessing

        │

        ▼

Flatten Input

        │

        ▼

LIF Hidden Layer

        │

        ▼

Output LIF Layer

        │

        ▼

Spike Accumulation

        │

        ▼

Predicted Digit

        │

        ▼

Interactive Streamlit Dashboard

📁 Project Structure

snn-digit-classifier/
│
├── app.py
├── model.py
├── train.py
│
├── models/
│   └── snn_mnist.pth
│
├── screenshots/
│
├── requirements.txt
├── .gitignore
├── LICENSE
└── README.md

⚙ Technology Stack

Programming

Python 3.10+

Deep Learning

PyTorch
snnTorch
Torchvision

Neuromorphic Computing

Leaky Integrate-and-Fire Neurons
Surrogate Gradient Learning
Spike Encoding
Temporal Learning

Visualization

Plotly
Streamlit

Scientific Computing

NumPy
Pillow

🚀 Installation

Clone Repository

git clone https://github.com/SHALINISAURAV/snn-digit-classifier.git

cd snn-digit-classifier

Create Virtual Environment

Windows

python -m venv venv

venv\Scripts\activate

macOS/Linux

python3 -m venv venv

source venv/bin/activate

Install Dependencies

pip install --upgrade pip

pip install -r requirements.txt

🏋 Train the Model

python train.py

Training includes:

Downloading MNIST
Building SNN
Forward propagation
Spike simulation
Surrogate backpropagation
Saving trained weights

▶ Run the Dashboard

streamlit run app.py

Open

http://localhost:8501

🌐 Live Demo

🚀 Streamlit Cloud

https://snn-digit-classifier-mexwdjvrvwct7yefeqf57f.streamlit.app/

📸 Screenshots

Home Dashboard

(Add Screenshot)

Drawing Canvas

(Add Screenshot)

Spike Raster Plot

(Add Screenshot)

Prediction Dashboard

(Add Screenshot)

📊 Model Details

Property	Value
Dataset	MNIST
Model	Spiking Neural Network
Hidden Layer	128 Neurons
Output Layer	10 Neurons
Simulation Time	25 Steps
Neuron Model	LIF
Learning	Surrogate Gradient
Framework	PyTorch + snnTorch

🧪 Skills Demonstrated

✔ Python

✔ PyTorch

✔ snnTorch

✔ Neuromorphic Computing

✔ Deep Learning

✔ Artificial Intelligence

✔ Biological Neural Networks

✔ Surrogate Gradient Learning

✔ Streamlit

✔ Plotly

✔ Data Visualization

✔ Interactive Dashboards

✔ Scientific Computing

✔ Software Architecture

🧠 Concepts Covered

This project demonstrates:

Neuromorphic AI
Spiking Neural Networks
Temporal Neural Processing
Biological Learning
Deep Learning
Computer Vision
MNIST Classification
Interactive AI Applications
Brain-Inspired Computing
Human-Computer Interaction

🚀 Future Improvements

Neuromorphic AI

Computer Vision

Dashboard

🤝 Contributing

Contributions are welcome!

Fork the repository
Create a feature branch

git checkout -b feature-name

Commit your changes

git commit -m "Added new feature"

Push your branch

git push origin feature-name

Open a Pull Request

📜 License

This project is licensed under the MIT License.

👩‍💻 Author

Shalini Saurav

AI Engineer | Deep Learning Engineer | Neuromorphic AI Enthusiast | Machine Learning Developer

Connect with me

🌐 GitHub: https://github.com/SHALINISAURAV
💼 LinkedIn: (Add Your LinkedIn)
🌍 Portfolio: (Add Your Portfolio)

⭐ Support

If you found this project helpful,

⭐ Star this repository

🍴 Fork it

📢 Share it

💙 Contribute

🧠 Neuromorphic Spiking Neural Network Digit Classifier

Brain-Inspired Computing • Neuromorphic AI • Deep Learning • Interactive Visualization

Built with ❤️ using PyTorch, snnTorch, Streamlit, Plotly, and Python

Name		Name	Last commit message	Last commit date
models		models
.gitignore		.gitignore
README.md		README.md
app.py		app.py
model.py		model.py
requirements.txt		requirements.txt
train.py		train.py

Latest commit

History

Folders and files

Repository files navigation