SC-NeuroCore Learning Path

A structured progression from first contact to FPGA deployment. Use this page as the main onboarding route: it explains what to read, what to run, and what evidence each stage should produce. Each level builds on the previous. Estimated times assume familiarity with Python and basic linear algebra.

Before starting, read Product Overview for the project scope and Applications and Market for practical use cases and commercial boundaries.

---

Level 0 — What Is Stochastic Computing? (30 min)

Goal: Understand why random bitstreams can replace arithmetic.

Resource	What you learn
SC Fundamentals tutorial	Unipolar encoding, AND-gate multiplication, majority-gate addition
Neuromorphic Primer	Where SC fits in the neuromorphic landscape

Checkpoint: You can explain why P(A AND B) = P(A) * P(B) for independent Bernoulli streams.

---

Level 1 — Core Primitives (1 h)

Goal: Encode values, build neurons, connect synapses.

from sc_neurocore import (
    BitstreamEncoder, generate_bernoulli_bitstream, bitstream_to_probability,
    StochasticLIFNeuron, BitstreamSynapse,
)

# Encode a value as a bitstream
enc = BitstreamEncoder(x_min=0.0, x_max=1.0, length=1024)
bits = enc.encode(0.7)            # ~70% ones
p_hat = bitstream_to_probability(bits)  # ≈ 0.7

# Spike a LIF neuron
neuron = StochasticLIFNeuron(v_threshold=1.0, noise_std=0.0)
spikes = [neuron.step(1.5) for _ in range(100)]

# Weight a synapse
syn = BitstreamSynapse(w_min=0.0, w_max=1.0, w=0.5, length=1024)
post = syn.apply(bits)  # P(post) ≈ 0.7 * 0.5

Resource	What you learn
Getting Started	Install, first neuron, first layer
API: Neurons, Synapses, Utilities	Class signatures and parameters

Checkpoint: You can encode a value, feed it through a synapse into a neuron, and read back the firing rate.

---

Level 2 — Networks & Layers (2 h)

Goal: Compose neurons into layers, run multi-step simulations.

from sc_neurocore import SCDenseLayer, VectorizedSCLayer
import numpy as np

# Dense layer with SC input pipeline
layer = SCDenseLayer(
    n_neurons=8, x_inputs=[0.5, 0.3], weight_values=[0.8, 0.6],
    x_min=0.0, x_max=1.0, w_min=0.0, w_max=1.0,
)
layer.run(T=200)
trains = layer.get_spike_trains()  # (8, 200)

# High-performance vectorized layer (packed bitwise ops)
fast = VectorizedSCLayer(n_inputs=16, n_neurons=32, length=512)
rates = fast.forward(np.random.rand(16))  # (32,) firing rates

Resource	What you learn
Building Your First SNN	Multi-layer network, spike raster plots
Layer-by-Layer Guide	Dense, Conv2D, Recurrent, Fusion, Attention
API: Layers	All layer classes

Checkpoint: You can build a 2-layer SNN, run it for 500 steps, and plot the spike raster.

---

Level 3 — Learning & Plasticity (2 h)

Goal: Train networks using STDP, R-STDP, and surrogate gradients.

from sc_neurocore import StochasticSTDPSynapse, RewardModulatedSTDPSynapse

# Hebbian STDP
syn = StochasticSTDPSynapse(w_min=0.0, w_max=1.0, w=0.5, length=64)
for _ in range(200):
    syn.process_step(pre_bit=1, post_bit=1)  # correlated → LTP
print(syn.w)  # > 0.5

# Reward-modulated (three-factor) learning
rsyn = RewardModulatedSTDPSynapse(w_min=0.0, w_max=1.0, w=0.5, length=64)
for _ in range(50):
    rsyn.process_step(pre_bit=1, post_bit=1)
rsyn.apply_reward(1.0)  # delayed reward signal

Resource	What you learn
Surrogate Gradient Training	Gradient-based SNN training with PyTorch
Online Learning with STDP	STDP, R-STDP, eligibility traces
User Manual	Learning rules, training loops

Checkpoint: You can train a network to classify a simple pattern using either STDP or surrogate gradients.

---

Level 4 — Advanced Architectures (2 h)

Goal: Use convolutional, recurrent, hyperdimensional, and attention layers.

Resource	What you learn
MNIST SC Classification	End-to-end SC image classification
Reservoir Computing	Echo state networks with SC recurrent layers
Multi-Scale Networks	Hierarchical cortical column models
Hyper-Dimensional Computing	HDC encoding, bundling, binding
Advanced Usage Patterns	Custom neuron models, quantum entropy, analysis tools
Brunel Network Translation	Translate a classic balanced network to SC
API: HDC, Ensembles	Hyperdimensional and ensemble modules

Checkpoint: You can classify MNIST with an SC network or implement a reservoir computing benchmark.

---

Level 5 — Performance & Acceleration (1 h)

Goal: Use the Rust engine, GPU backend, and packed-bitstream vectorization for production-grade throughput.

Resource	What you learn
Rust Engine & Performance	SIMD-accelerated Rust engine, Python↔Rust bridge
Performance Tuning	Packed uint64 ops, CuPy GPU path, sparse layers
Rust Engine API	Rust crate API reference
Benchmark Report	Throughput numbers vs Brian2, Norse, snnTorch

Checkpoint: You can run the Rust engine from Python and see

10x speedup over pure NumPy for a Brunel network.

---

Level 6 — Hardware Deployment (2 h)

Goal: Synthesize SC neuron designs onto an FPGA.

Resource	What you learn
FPGA in 20 Minutes	Yosys synthesis, Verilator simulation, resource utilization
Hardware Co-simulation	Python ↔ Verilog cycle-exact verification
Fixed-Point Arithmetic	Q8.8 format, overflow, weight export
Network Export & Deployment	Rust, FPGA, and checkpoint export
Hardware Guide	HDL module inventory, timing constraints
FPGA Toolchain Guide	Yosys + sv2v + nextpnr setup
Hardware Manual	Pin-level specification for each Verilog module

Checkpoint: You can synthesize sc_lif_neuron.v with Yosys, verify it with Verilator, and read the resource utilization report.

---

Level 7 — Research & Extension (open-ended)

Goal: Extend SC-NeuroCore for your own research.

Resource	What you learn
Architecture Overview	Full system architecture, module dependency graph
Component Inventory	Every module, its role, its test coverage
Technical Manual	Internal design decisions, numerical choices
Foundational Whitepaper	Theoretical basis for the SC-SNN approach
Quantum-SC Hybrid Networks	Quantum circuits as SC front-ends
Neuromorphic Signal Processing	SC filterbanks, edge detection
Integration Guide	Embedding SC-NeuroCore in larger systems

Checkpoint: You can add a custom neuron model, wire it into the compiler, and generate HDL for it.

---

Quick Reference: Which Doc for Which Question?

Question	Go to
"How do I install it?"	Getting Started
"What does class X do?"	API Reference
"How fast is it?"	Benchmarks
"Can it run on an FPGA?"	FPGA in 20 Minutes
"How does SC multiplication work?"	SC Fundamentals
"I come from Brian2/NEST"	SC for Neuroscientists
"I come from PyTorch/JAX"	SC for ML Engineers
"I design FPGAs/ASICs"	SC for Hardware Engineers
"What changed in v3?"	V3 Migration