2.1 Credit Assignment in SNNs

To improve any neural network, we need to solve the credit assignment challenge: when the network makes an error, how do we determine which components to adjust? And by how much? This chapter explains the intuition and mathematics behind credit assignment with an emphasis on time because, unfortunately, credit assignment becomes harder when you work with stateful neurons and networks, which are described in the previous topic on Foundations of SNNs.

2.1.1The Credit Assignment Problem¶

The core question in this chapter is: Given an output error, which neurons and synapses contributed to that error? The term credit assignment was coined by Marvin Minsky in a 1960 paper Minsky, 1961, but he went the other way around: how do we reward the good parts of the network. Whether you think about credit as “reward” or “punishment”, the essence of the problem is the same:

The credit for a working program can only be assigned to [...] subroutines, and as these operate in hierarchies we should not expect individual instruction reinforcement to work well. - Minsky (1961)

What Minsky is saying, is that our networks consist of subcomponents that, together, make up the whole. So, if we are to assign credit and improve the network, we first need to understand how each component contributes to the whole. What is the contribution of, say, a synapse to the network output? Only when we understand that contribution, do we know how to change the synapse. That is the fundamental problem of credit assignment: how do we assign credit to the individual components?

2.1.1.1Credit assignment in space¶

The structural credit assignment problem is to determine which internal decisions are responsible - Minsky (1961)

In a feedforward network, credit assignment reduces to a structural question: which connections along the path from input to output are responsible for the error?

Consider a single linear layer with a single weight, and no bias term, as shown in Figure 1. Following the example in the figure, the layer receives some input (1), and the objective is to output 2. In this example, $w$ is set to ${2}$, so the output $1 * w_1 = 1 * 2 = 2$ is off by one. We can solve this by adjusting the linear weight from $2 \to 1$, which gives $1 * 1 = 1$: we’ve reached our goal!

Now, consider the case shown in Figure 2, where we have two linear layers, both with $w = 2$, and a goal of ${2}$. The output becomes ${4}$, since $1 * w_1 = 1 * 2 = 2$ and $2 * w_2 = 2 * 2 = 4$. Our error is now ${2}$, but which parts of the network do we update? And by how much? The simplest solution would probably be to set $w_1$ or $w_2$ to ${1}$, but there are many more solutions.

Even in this minimal example, there is no single correct answer: many combinations of weights produce the same output. This ambiguity is at the heart of spatial credit assignment, and it only grows worse as networks get deeper and more complex. A caveat on the word ambiguity: that many weight settings solve the task does not make credit undefined. Given a loss, the gradient still prescribes one well-defined update. It is the solution set, not the credit signal, that is degenerate: many distinct weight settings collapse onto the same output, so the task alone singles out none of them. Now, imagine adding time to the equation.

2.1.1.2Credit assignment in time¶

In networks without memory, credit assignment only needs to trace errors backward through layers. But neurons with state carry information across time, and a spike at timestep $t$ may cause an error at timestep $t + 100$. Now we must assign credit not just to the right component, but to the right component at the right moment.

To see why, take the single-weight example from Figure 1 and unroll it in time: the same neuron, with the same weight $w$, but now using state. Acting at $t=0$ and again at $t=1$ carries state forward from one step to the next (Figure 3). Notice that this is the same picture as the two-layer case in Figure 2, only now the “depth” is time rather than space. The output is wrong by the same amount, and the same question returns: which timestep should receive the update?

The catch is that $w$ is shared: the very same parameter acts at every timestep. When we ask how a small change in $w$ affects the final error, the answer is not a single number but a sum: one contribution from the role $w$ played at $t=0$, another from its role at $t=1$, and so on for every step it was active. Unrolling the network in time and differentiating makes this explicit:

This is exactly the backpropagation through time (BPTT) computation Werbos, 1990: we unroll the recurrence into a deep feedforward graph, one layer per timestep, and propagate the error backward through it.

Bundling every moment into a single gradient is convenient for computing an update, but it hides the same ambiguity we met in space. The total error could be blamed on what the neuron did at $t=0$, on what it did at $t=1$, or split between the two in any proportion; the sum in (1) constrains only the whole, never the per-step shares. Where the spatial two-layer case had infinitely many pairs $(w_1, w_2)$ that yield the same output, the temporal case has infinitely many ways to distribute one shared weight’s error across the moments it acted. Time, in other words, is just another axis of depth - and credit assignment is ambiguous along it for exactly the same reason.

The gradient in (1) really flows through the chain of state updates $\partial V[t]/\partial V[t-1]$. Carrying the membrane potential step by step through the entire chain of state updates makes SNNs especially hard:

• Non-differentiable spikes: the spike threshold has zero gradient almost everywhere, blocking the chain rule exactly where information is sent.

• Vanishing or exploding gradients: errors travel through a long product of state terms, arriving faint or wildly amplified.

• Sparse, nonlinear dynamics: only some neurons spike, and small changes can have large, delayed downstream effects.

2.1.1.3Credit assignment parameter updates¶

Once we know which components contributed to an error, we face a second question: how do we translate that knowledge into concrete parameter changes?

2.1.1.4A note on scalability¶

The ambiguity we have discussed so far is a question of correctness: which component, at which moment, deserves the credit. Scalability is a separate, practical question: even when we know how to compute the credit, can we afford to?

Backpropagation through time answers the credit question by unrolling the network into one layer per timestep and storing every intermediate state, so it can later walk the errors backward. That storage is the bottleneck. Memory grows with the sequence length $T$ multiplied by the size of the network, because every activation along the way must be kept until the backward pass reaches it; compute grows with the same product, since each stored step must also be revisited. A long recording or a deeply recurrent loop can exhaust memory long before the method itself runs into any limit.

This cost is a large part of why the coming chapters exist. It motivates truncating the unroll to a short window, propagating sensitivities forward in time instead of backward (real-time recurrent learning (RTRL), which stores nothing extra as the sequence grows but scales poorly in network size Marschall et al., 2020) or abandoning the global backward pass entirely in favor of local rules (such as eligibility traces, plasticity, and reward signals) that update each synapse from information it already has on hand. Correctness tells us what credit assignment should compute. Scalability decides which approximation we can actually run.

2.1.1.5Why not just use backpropagation?¶

Beyond its memory cost, BPTT sits awkwardly with biology and neuromorphic hardware Lillicrap et al., 2020: the backward pass needs the transpose of the forward weights (the weight-transport problem), it requires separate locked forward and backward phases, and its updates are non-local. These objections motivate the alternatives that follow, some of which keep backprop’s form but swap the transposed weights for fixed random ones (feedback alignment Lillicrap et al., 2016, direct feedback alignment Nøkland, 2016) while others drop the global backward pass entirely.

2.1.2Approaches to solving credit assignment¶

The rest of this topic explores three families of approaches, each developed fully in the chapters that follow:

• Gradient-based: approximate the derivatives and flow error signals backward, just as in classical deep learning (Surrogate Gradient Training).

• Eligibility-based: each synapse keeps a running eligibility trace of its recent activity, so a later global signal (an error or a reward) can find the synapses responsible: the three-factor rule of neuroscience Gerstner et al., 2018. This is more than a heuristic. e-prop Bellec et al., 2020 shows the exact BPTT gradient of (1) factorizes into just such a local trace times a top-down signal.

• Direct optimization — sidestep gradients entirely and search for good parameters through evolution or random perturbation.

2.1.2.1Choosing a method: a simple heuristic¶

Now that you have multiple options, the practical question is when to reach out for which. The choice depends on what is available (a differentiable loss? a reward signal? a compute budget?) and on what you need (biological plausibility? on-chip locality? sample efficiency?) Here are a few questions to guide you:

• Do you have a differentiable loss and enough memory to backpropagate? Use a gradient-based method (surrogate gradients, Surrogate Gradient Training). It is the default when it applies because it uses the error most efficiently.

• Do you need a local rule a neuron could run on its own for on-chip learning or biological plausibility? Use a plasticity-based rule, and add an eligibility trace when the learning signal arrives only after a delay.

• Is your feedback a sparse, delayed, or non-differentiable reward rather than a target output? Use a reinforcement-based method.

• Is there no usable gradient at all, but you can afford many forward evaluations? Fall back to evolution or another direct-optimization search.

The table below summarizes the trade-offs. Plasticity- and eligibility-based rules are closely related (both are local) and evolution is one instance of the broader direct-optimization family. They are separated here only where the distinction changes when you would reach out for them.

These families are not mutually exclusive. In practice they are often combined. Eligibility traces carry a reward signal, surrogate gradients seed an evolutionary search, and plasticity rules can themselves be meta-learned by evolution. Treat the heuristic as a starting point, not a verdict.

2.1.3Summary¶

It is my conviction that no scheme for learning, or for pattern-recognition, can have very general utility unless there are provisions for recursive, or at least hierarchical, use of previous results. We cannot expect a learning system to come to handle very hard problems without preparing it with a reasonably graded sequence of problems of growing difficulty. - Minsky, 1961

As Minsky anticipated, credit assignment in SNNs requires exactly this kind of hierarchical reasoning—tracing contributions through layers of space and steps of time.

2.1.4Related reading¶

Here is a list of resources sorted by topic (please help expand the list):

• Foundational: Sutton & Barto, 2018, Werbos, 1990, Rumelhart et al., 1986, Williams & Zipser, 1989, Bengio et al., 1994

• Gradient geometry (natural gradient): Amari, 1998, Martens, 2020

• Eligibility traces: Bellec et al., 2020, Gerstner et al., 2018, Singh & Sutton, 1996

• Reinforcement learning: Sutton & Barto, 2018, Pignatelli et al., 2023, Singh & Sutton, 1996

• Biologically plausible alternatives to backprop: Lillicrap et al., 2016, Nøkland, 2016, Whittington & Bogacz, 2017, Scellier & Bengio, 2017, Lee et al., 2015

• Neuroscience: Lillicrap et al., 2020, Murray, 2019, Roelfsema & Holtmaat, 2018

• Category theory: Cruttwell et al., 2022

@incollection{snnbook2026-credit-assignment,
  author    = {Pedersen, Jens Egholm},
  title     = {{Credit Assignment in SNNs}},
  booktitle = {{Practical Spiking Neural Networks}},
  editor    = {Gaurav, Ramashish and Pedersen, Jens Egholm and Bogdan, Petrut},
  publisher = {Open Neuromorphic},
  year      = {2026},
  edition   = {Version 0.8},
  url       = {https://snnbook.net/topics/2_1_credit_assignment},
}