Why I Chose Spiking Neural Networks for Satellite Imagery Change Detection

When I started building GeoGuard AI — an autonomous geospatial compliance system that monitors satellite imagery for unauthorized construction and environmental violations — the first big architectural decision I had to make was the model choice.

Everyone told me to use a CNN. ResNet50, maybe. Throw a U-Net on top. Call it a day.

I didn't.

Instead, I chose something that most production ML engineers have never shipped: a Spiking Neural Network (SNN). Specifically, a hybrid Siamese-SNN — the first of its kind deployed for real-world geospatial compliance monitoring.

Here's why, and it starts with the single biggest problem nobody talks about when working with satellite imagery.

The Problem No One Mentions: Satellite Data is Noisy by Nature

Open a satellite image. What do you see?

Probably clouds. Maybe haze. Atmospheric scattering. Seasonal color shifts. The exact same field of grass looks completely different in January versus August — not because anything changed on the ground, but because the sun angle, moisture content, and atmospheric conditions all changed.

This is a catastrophic problem for traditional change detection systems.

A standard CNN-based binary classifier looks at a "before" image and an "after" image and tries to answer: "Did anything change here?" But because a CNN is working with raw pixel differences, it can't distinguish between real structural change (a new building was constructed) and environmental noise (a cloud passed over, or it rained the day before the image was taken).

In my testing, naive CNN models were generating false positives constantly — flagging perfectly legal fields as unauthorized construction simply because the seasonal NDVI signature shifted. That's not a model problem. That's a fundamental architectural mismatch.

The real world generates data that is temporal, event-driven, and noisy. And the right tool for event-driven, temporal, noisy data is not a CNN.

What Makes a Spiking Neural Network Different

Traditional neural networks — CNNs, Transformers, LSTMs — operate in continuous value space. Every neuron fires on every forward pass, outputting a floating point number that propagates through the network. Whether or not anything has actually changed, every neuron is always "on."

The brain doesn't work this way.

Biological neurons are event-driven. They stay silent until their accumulated electrical potential (membrane potential) crosses a threshold — then they fire a discrete, binary spike. This "Leaky Integrate-and-Fire" (LIF) dynamics means neurons only activate when something meaningful has happened.

This is the core insight behind Spiking Neural Networks, which are considered the third generation of neural network architectures.

In my implementation (using snntorch), the SNN decoder layers use snn.Leaky neurons with a membrane decay constant β = 0.9:

self.lif1 = snn.Leaky(beta=0.9, spike_grad=surrogate.fast_sigmoid(slope=25))

The membrane potential leaks toward zero over time. Only when the accumulated input consistently pushes it past the threshold does the neuron fire. This is not a gimmick. This is physics. And it translates directly into the satellite domain.

How the Siamese Architecture Solves the Comparison Problem

For change detection, you fundamentally need to compare two images: a "before" and an "after." The classic approach is to concatenate the two images channel-wise and run them through a single network. The problem? The network has to learn the comparison function implicitly from data.

The Siamese architecture solves this explicitly. Both temporal images pass through the exact same encoder with shared weights:

Before Image ──► Shared Encoder ──► Features_A
After Image  ──► Shared Encoder ──► Features_B
                                    |F_A − F_B|  ← Absolute Difference

Because the weights are shared, both images are projected into the same feature space. The absolute difference |F_A - F_B| is therefore a geometrically meaningful measure of change — not a pixel-level subtraction, but a learned, high-level feature-space distance.

This feature difference then becomes the input to the SNN decoder — not as raw values, but encoded as Poisson spike trains using rate coding:

diff_norm = torch.sigmoid(diff_bottleneck)
spike_trains = spikegen.rate(diff_norm, num_steps=T)

The magnitude of the feature difference determines the firing rate of the corresponding spike train. High difference → high firing rate → strong change signal. Low difference (noise) → low firing rate → the SNN decoder ignores it.

The Accumulation Advantage: Confidence, Not Just Binary

One of the most underrated properties of SNNs for this use case is what happens at the output.

A traditional CNN gives you one prediction per pixel. Either it changed or it didn't. There's no natural confidence measure built into the architecture.

With the SNN decoder processing T = 10 time-steps, the final prediction is the mean firing rate over all steps:

spk_stack = torch.stack(spk_recordings, dim=0)  # (T, B, 2, H, W)
firing_rate = spk_stack.mean(dim=0)              # (B, 2, H, W)
change_prob = torch.softmax(firing_rate, dim=1)[:, 1]

A pixel that spikes consistently across many time-steps has high confidence of being a genuine change. A pixel that spikes erratically (like a cloud edge would) has low mean firing rate — it gets suppressed. This temporal voting mechanism is extremely effective at cleaning up false positives without needing any post-processing tricks like median filtering or morphological cleanup.

Why Not Just Use NDVI Thresholds?

Fair question. Spectral index thresholds (NDVI, NDBI, MNDWI) are the traditional "poor man's change detection" approach. They're fast, interpretable, and have no model weights to worry about.

But they have a critical flaw: they have no concept of context.

A pixel with a low NDVI value is not automatically a construction site. It could be bare soil, a dry riverbed, a gravel road, or a parking lot that existed five years ago. Pure spectral thresholds cannot distinguish intent or relative change — they can only see absolute values.

My system actually uses both, in a hybrid cascade:

1. Primary: The Siamese-SNN runs first on 128×128 patches and produces a binary change mask.
2. Fallback: If the SNN detects zero changed pixels (rare, but possible when the model is uncertain), the pipeline automatically activates a spectral index fallback using NDVI, NDBI, and MNDWI delta thresholds.
3. Classification: After change detection (by either method), spectral indices then classify what kind of change occurred — Construction, Vegetation Loss, Water Change, etc.

This means the SNN handles the detection problem (where did something change?) while spectral indices handle the classification problem (what type of change was it?). Each does what it's best at.

The Real Cost of Getting This Wrong

At this point you might be thinking — okay, a few false positives, so what?

In the real-world deployment context of GeoGuard AI, a false positive means a family or a business receives an unauthorized construction notice from a municipal authority. That triggers legal proceedings, financial penalties, and potentially demolition orders — for something that never happened.

A false negative means an actual violation goes undetected. Illegal construction in a 500-meter water body buffer zone continues unchallenged. Environmental damage accumulates. The ecosystem degrades.

This is not an academic benchmark problem. The precision of the model matters legally and ethically. The SNN's temporal voting and noise-resilient spike dynamics directly translate into fewer false positives in atmospheric noise conditions — and that is why the architecture choice matters in production.

What I Learned

Building this system taught me three things:

1. Architecture should match the physics of the data. Satellite data is temporal, event-driven, and noisy. SNNs are temporal, event-driven, and noise-resilient. This is not a coincidence — it's why the architecture works.

2. Hybrid systems outperform purist approaches. The best performing pipeline wasn't pure SNN or pure spectral — it was both, working in cascade, each solving the problem they're best suited for.

3. The novelty should serve the problem, not the other way around. I didn't choose SNNs because they're exotic or impressive on a slide deck. I chose them because nothing else gave me the noise-resilience properties I needed to make this legally credible in real-world atmospheric conditions.

Try It Yourself

The full system — model code, training notebooks, FastAPI backend, compliance engine, and agentic chatbot — is open-source:

👉 github.com/shaktisingh5580/PFL-SNN-BACKEND

If you're working on geospatial ML, remote sensing, or autonomous compliance systems and want to exchange ideas, reach out. I'm always happy to talk about the intersection of neuromorphic computing and real-world systems.

The era of spiking networks in production is just beginning.