Efficient and Flexible Neural Network Training through Layer-wise Feedback Propagation
Authors: Leander Weber
Jim Berend
Moritz Weckbecker
Alexander Binder
Thomas Wiegand
Wojciech Samek
Sebastian Lapuschkin
Venue: Accepted by TMLR ()

Abstract: Gradient-based optimization has been a cornerstone of machine learning that enabled the vast ad- vances of Artificial Intelligence (AI) development over the past decades. However, this type of optimization requires differentiation, and with recent evidence of the benefits of non-differentiable (e.g. neuromorphic) architectures over classical models w.r.t. efficiency, such constraints can be- come limiting in the future. We present Layer-wise Feedback Propagation (LFP), a novel training principle for neural network-like predictors that utilizes methods from the domain of explainability to decompose a reward to individual neurons based on their respective contributions. Leveraging these neuron-wise rewards, our method then implements a greedy approach reinforcing helpful parts of the network and weakening harmful ones. While having comparable computational complexity to gradient descent, LFP does not require gradient computation and generates sparse and thereby memory- and energy-efficient parameter updates and models. We establish the convergence of LFP theoretically and empirically, demonstrating its effectiveness on various models and datasets. Via two applications — neural network pruning and the approximation-free training of Spiking Neural Networks (SNNs) — we demonstrate that LFP combines increased efficiency in terms of computation and representation with flexibility w.r.t. choice of model architecture and objective function.

Published in Transactions on Machine Learning Research (06/2025)
Efficient and Flexible Neural Network Training through Layer-wise Feedback Propagation
Moritz Weckbecker Wojciech Samek 14,5 Sebastian Lapuschkin L.6.f
Leander Weber! Jim Berend"
Alexander Binder
Thomas Wiegand
Fraunhofer Heinrich Hertz Institute, Berlin, Germany voe-iikkkeekkkk University, Magdeburg. Germany
3 Singapore Institute of Technology, Singapore, Singapore Technische Universität Berlin, Berlin, Germany
BIFOLD Berlin Institute for the Foundations of Learning and Data, Berlin, Germany
Centre of explainable Artificial Intelligence, Technological University Dublin, Dublin, Ireland
corresp.: (wo twocciec.. samek, sebastian lawuschkin @hhi. www...aaunnooee.eeee Fraunhofer.co de
Reviewed on Ottptiiiii..ttsss//oo.r/rv/////t
Abstract
Gradient-based optimization has been a cornerstone of machine learning that enabled the vast ad- vances of Artificial Intelligence (AI) development over the past decades. However, this type of optimization requires differentiation, and with recent evidence of the benefits of non-differentiable (e.g. neuromorphic) architectures over classical models w.r.t. efficiency, such constraints can become limiting in the future. We present Layer-wise Feedback Propagation (LFP), novel training prin- ciple for neural network-like predictors that utilizes methods from the domain of explainability to decompose reward to individual neurons based on their respective contributions. Leveraging these neuron-wise rewards, our method then implements greedy approach reinforcing helpful parts of the network and weakening harmful ones. While having comparable computational complexity to gradi- ent descent, LFP does not require gradient computation and generates sparse and thereby memory- and energy-efficient parameter updates and models. We establish the convergence of LFP theoretically and empirically, demonstrating its effectiveness on various models and datasets. Via two applications neural network pruning and the upproximation--iee training of Spiking Neural Networks (SNNs) demonstrate that LFP combines increased efficiency in terms of computation and representation with flexibility w.r.t. choice of model architecture and objective function. Our code is available at https: //gtt http:///eaaeeeeeeee//eaeeeeeeeee http::/wwweeeeeeeaaae-e--roaaaeo
Motivation
In recent years, supervised deep learning has been successfully employed in a wide variety of applications, including highly accurate classification (Dosovitskiy et al., 2021), generation of realistic images (Rombach et al., 2022), writing of complex text (Ouyang et al., 2022), or assisting medical diagnosis (Briganti Le Moine, 2020). These develop- ments have been enabled by the widespread use of well-researched gradient- training methods that provide fast convergence and are easily implemented on GPU hardware. However, the computation of gradients requires the model and objective be differentiable,, which can pose significant restriction and limit flexibility in terms of objective formulation and model architecture: For instance, gradient-based training becomes difficult when non non-differentiable evaluation measures should be integrated into the objective function (e.g. FI-Score in classification or Levenshtein distance in word recognition tasks) or when feedback is obtained from external sources such as humans (Christiano et al., 2017). Similarly, gradients cannot be used directly train non-differentiable models despite these models providing unique benefits, especially when implemented on dedicated hardware; e.g., when a model is quantized have discrete forward passes for reduced memory requirements or when neuromorphic architectures such Spiking Neural

---

Published in Transactions on Machine Learning Research (06/2025)
Layer-wise Feedback Propagation
A Forward Pass
Feedback Propogation
C Weight Update
Inst Reward
Use local reward
d x W aj Tk to update parameter
aj
j
ai
T
f
W Wik new j,k = j,k t
Figure 1: Our proposed method. A: During the forward pass, the model receives an input and generates activations aj: ag and an output. B: After receiving initial reward Te (cf. Sections 3, 3.2) that evaluates the output quality, Layer-wise Feedback Propagation (LFP) decomposes To into local rewards 7k for each neuron & (and rewards Tjk for each weighted connection j - k). This is achieved via backward pass that leverages Layer-wise Relevance Propagation (LRP)-rules and does not require gradient computation, obtaining feedback for each neuron that evaluates how well it performed w.r.t. given task. For this step, LFP requires an initial reward for each output neuron, but otherwise places no restrictions how this reward is obtained. C: After the initial reward is decomposed into local rewards, each neuron is viewed separate agent with its own (local) reward that is used to derive parameter update d This update implements greedy strategy, strengthening connections that are evaluated as helpful by receiving positive reward, and weakening connections that receive a negative reward. Note that the fiebbian-like update in step C could be performed based on any local reward, and not necessarily tied to the specific propagation in step B we employ this work.
Networks (SNNs) are employed that encode information more efficiently than Artificial Neural Networks (ANNs). evidenced by recent research (Singh et al., 2023). Consequently, finding alternatives to gradient-baser training methods is paramount for the application of more suitable objectives and more information-efffcient models.
1.1 Approach
We introduce Layer-wise Feedback Propagation (LFP), a novel principle of training based on eXplainable artificial intelligence (XAI). As summarized in Figure 1, optimizing a model with LFP consists of three distinct steps:
A: Forward Pass. each iteration, LFP first requires the model to perform a forward pass, similar to other training methods such as gradient descent. Here, some intermediate variables such as activations are set and a prediction is obtained.
B: Feedback Propagation. Based this prediction, the model then receives an initial reward (cf. Section 3.2) evaluating the prediction quality. In modified backward pass, LFP decomposes this initial reward into local rewards that provide feedback to single neurons and connections.
C: Weight Update. Finally, LFP updates parameters based on a local reward at each neuron. In this work, the local reward obtained from step B; however, local reward obtained from any source could be used in theory. Here, positive and negative reinforcement is leveraged in greedy manner, strengthening connections that work well (i.e., receive positive reward) and weakening those that do not (i.e., receive negative reward). This step is similar to Hebbian update rule, as discussed in Section 3.1.2.
As such, LFP is related to the reinforcement learning paradigm of encouraging rewarded behavior, implementing it at the smallest elements of neural networks - neurons and connections. Refer to Section 3 for more details.
To propagate feedback to each neuron, we decompose an initial reward (cf. Figure 1) based on each neuron's 's contribution. The question of neuron contributions (or feature importance) is addressed by subset of interpretability methods (Baehrens et al., 2010; Simonyan et al., 2013; Springenberg al., 2015; Bach et al., 2015; Sundararajan et al., 2017)
2

---

Published in Transactions on Machine Learning Research (06/2025)
Layer-wise Feedback Propagation
Gradient Descent
Applicable to Non- Differentiable Models
Applicable to Differentiable Models
Applicable to Non-Differentiable Objectives
Applicable Differentiable Objectives
Computationally Efficient
Naturally Encourages Sparsity
Converges to SOTA Solutions
Figure Venn diagram of the capabilitiies of LFP and supervised gradient descent. LFP shares some properties of gradient descent but provides several additional benefits, it does not require gradient computation and thus provides increased flexibility w.r.t. choice of model and objective, and naturally encourages sparsity.
that focus obtaining local explanations. These techniques assign importance scores to individual features groups of features in specific samples, based on the model's behavior. It is important to note that some of these methods are not limited to attributing importance solely to input features but can also determine the significance of individual units within a model. Among these, LRP (Bach et al., 2015) efficiently explains predictions after inference by computing the contribution of network components to the prediction outcome. This is achieved by decomposing an initial relevance value assigned to the output layer through a modified backward pass. LFP leverages the deR-decomposition rules to distribute initial reward during step in Figure (in place of an initial relevance) to individual neurons during training. Our method then utilizes the distributed reward at each neuron to update parameters (see step C of Figure l).
Compared to several other gradient alternatives such as evolutionary approaches or methods from the domain of biologically plausible learning, LFP makes more assumptions about the model and objective, for instance, that the model is decomposable in terms of layer-wise mappings or that forward weights equal backward weights. However, our method preserves similar computational complexity, performance and convergence speed to gradient descent (ef. Section 3.3) and scales well to complex tasks and models (cf. Sections 3.5 A.9) but does not require gradient computation (see Figure 2). This allows for increased flexibility in terms of model and objective function compared to gradient-based methods. Consequently, LFP can be employed for training both Deep Neural Networks (DNNs) (cf. Sections 3.5, 3.6) and neuromorphic architectures such SNNs (cf. Section 4.2). The formulation of objective functions for LFP is similarly flexible. For instance, similar to supervised gradient descent, prior knowledge about the task such as ground truth predictions can be included in the objective. But if such knowledge is not available, or non-differentiable elements should be integrated, a valid objective for LFP can still be formulated (see Table 1). It is therefore well-suited to supervised tasks (and naturally extends to reinforcement learning tasks well, although we leave this application to future work).
Neurons that do not contribute in the forward pass are not altered by LFP, which encourages sparse (and thus theoretically more efficient) updates, property also found in biological networks (Pozzi et al., 2020). Due to an implicit weight scaling, the models obtained via LFP sparsely represent information and are easily prunable, contributing to Artificial Intelligence (AI).
1.2 Contributions
The primary objective of this work is to introduce LFP and demonstrate that this method provides valid training signal and converges to a local optimum in a set of controlled tasks explored in this work. Specifically, we focus on the well-understood supervised problem of classification, using fully fully-connected and convolutional neural networks (although we provide simple initial examples for regression and transformers in Appendix A.8 and A.9, respectively). We further examine the properties of LFP and consequently explore two applications that impact AI energy efficiency and expressivity. We can show that LFP performs well in these semi-complex settings, which is a positive indicator for
3

---

Published in Transactions on Machine Learning Research (06/2025)
Table 1: Overview of model and objective configurations solvable by LFP and gradient- methods (in the table, D stands for Differentiable and ND for Nondifferentiable), respectively, in the context of supervised learning. LFP is more flexible and can be applied wide variety of learning settings without requiring significant adaptations or substitutions.
Gradient-based Training
LFP-based Training
Configuration
Example
D
ND
MNIST Classification with ReLU-activated MLP
Objective
X
0
Model
ND
Learning with Neuromorphic Architecture, e.g. SNNs
Objective Model
x
ND
Non-differentiable evaluation measures in objective, e.g. Levenshtein distance
Objective Model
X
ND
Any Combination of the Two Rows Above
Objective
X
x
Model
a successful extension to more difficult problems as well, given appropriate parameterization and further research. The current work thus serves as a foundation for understanding the fundamental aspects of LFP, with future investigations expected explore the method's applicability in more state-of-the-ee scenarios.
In summary, make the following contributions:
We propose Layer-wise Feedback Propagation (LFP), a novel, interpretability-baseee training paradigm for DNNs that updates parameters based on local, neuron-wise reward.
2. We prove the convergence of LFP and confirm this theoretical result empirically several different models and datasets.
3. We discuss the properties, advantages and disadvantages of LFP.
Based on the discovered properties, we investigate two applications of LFP in-depth: Obtaining sparser models, that represent information efficiently and can be pruned more easily, and training non-differentiable models, such Heaviside-activated SNNs.
2 Related Work
2.1 Deep Learning Approaches
Depending the amount of (human) supervision involved, deep learning approaches can generally be categorized into supervised, unsupervised, and reinforcement learning, well hybrids between these, such as semi-supervised approaches. Setting aside unsupervised and hybrid methods, supervised approaches assume the availability of examples with ground truth predictions and aim to solve a well-defined and specific task. Reinforcement learning makes far less assumptions, requiring a model to learn to interact with potentially changing environment only from a reward signal that typically sparse and discrete. As such, reinforcement learning is the most general category, as most supervised problems can be reformulated reinforcement learning problems, while the reverse is usually not possible. However, this reformulation is often inefficient, since it leverages less domain knowledge and results in an optimization problem
Gradicnt--hasee based methods not applicable here without substituting non-di -on-iifeerentable model parts in the backward "hhse settings can be expressed as reinforeement learning problems and solved through gradient-bused reinforcement learning methods however, depending on specific objective, this reformulation can increase problem difficulty and thus suboptimal solutions (Barto Dietterich, 2004).
4

---

Published in Transactions on Machine Learning Research (06/2025)
that is more difficult to solve (Barto & Dietterich, 2004). Therefore, if the task constraints allow, supervised methods are preferred in practice.
Within these categories, gradient-based approaches (Rumelhart et al., 1985; Sutton et al., 1999; Mnih et al., 2013; Schulman et al., 2017) are by far the most widely used. However, as detailed in Section 1, these approaches assume the model and (for supervised learning) the objective function to be differentiable w.r.t. the model parameters. This is not always desirable because, as a consequence, gradient-based learning restricts the space of usable models, can be inefficient (Zuo, 2020), limits implementations on hardware, and is not plausible from biological perspective (Pozzi et al., 2020; Hinton, 2022). Several alternative approaches have been proposed to address these issues over the years. For instance, a number of studies (Goldstein et al., 2014; Carreira-Perpiñan & Wang. 2014; Taylor et al., 2016; Zeng et al., 2019; Wang et al., 2019; Tang et al., 2020; Wang et al., 2022) formulate neural network training as alternating minimization problems using auxiliary variables. These methods make training easily parallelizable and require comparatively few (but computationally expensive) iterations, but often scale badly to complex problems. Another set of methods (Salimans et al., 2017; Such et al., 2017: Cui et al., 2019; Tripathi & Singh, 2020; Chen al., 2021) involves training models through evolutionary strategies, by making random alterations to the model's parameters and selecting the best-performing version. While these strategies are highly flexible w.r.t. model architecture and task description, they are based on sampling strategies and therefore do not scale well to larger models.
Several learning methods specifically aim for higher biological plausibility. For instance, feedback alignment (Lillicrap et al., 2016; Nøkland, 2016) removes the need for symmetric weights in the forward and backward pass (a biologically implausible property), but otherwise backpropagates gradients nonetheless, limiting its applicability to e.g. non- differentiable models. Variations of target propagation (Le Cun, 1986; Lee et al., 2015; Bartunov al., 2018; Emoult et al., 2022; Roulet & Harchaoui, 2023) introduce dedicated backward connections to directly generate layer-wise activation targets and update parameters locally per layer based on these targets. This avoids the need for both symmetric weights and eгror propagation altogether and can even pass meaningful training signals through non- differentiable activations (Lee et al., 2015), but requires optimizing an additional, dedicated feedback path. Approaches to Hebbian learning (Hebb, 1949; Whittington & Bogacz, 2017: Miconi, 2021: Gupta et al., 2021; Lagani et al., 2022; Demidovskij et al., 2023; Journé et al., 2023) implement fully local but unsupervised learning rules proportional to the product of neuron inputs and outputs. To extend Hebbian learning to supervised settings, it is usually combined with backpropagation of a feedback signal Gupta et al. (2021); Demidovskij et al. (2023) in order to obtain both local and global representations. Finally, Hinton (2022); Ghader et al. (2025) suggest a contrastive approach to learning that requires no backward pass but assumes data to be split in positive and negative examples.
For specialized architectures, gradient application can be especially inefficient or infeasible, resulting in the development of dedicated learning methods for these settings. In the context of convergent recurrent architectures and Hopfield-like models, approaches such as contrastive Hebbian learning (Movellan, 1991; Detorakis et al., 2019) and equilibrium propagation (Scellier& & Bengio, 2017; Ernoult et al., 2019; Laborieux et al., 2021) approximate local gradients through differences in neural activities between (free) forward phase and a backward phase where the network outputs are nudged towards a target. Due to the need for two settling phases, these approaches are comparatively slow but effectively avoid the computation of gradients, inspiring extensions to physical systems such as SNNs (Martin et al., 2021) or Ising Machines (Laydevant et al., 2024), where gradient-based learning is notoriously difficult. Due to their promising properties Singh et al. (2023), specifically gradient- free optimization on SNNs is an active field of research. Here, DECOLLE (Kaiser et al., 2020) avoids propagation through time by minimizing the global loss at each layer separately using random readout matrices, and then utilizes surrogates to approximate Heaviside gradients. The unsupervised spike-time dependent plasticity (Bengio et al., 2015; Mozafari al., 2018) and its extensions for supervised settings, e.g., Reward-modulated Spike-Timing Dependent Plasticity (R-STDP) (Frémaux & Gerstner, 2016), implement a local, unsupervised learning rule akin to Hebbian principles that considers the timing between incoming and outgoing spikes.
Our method is biologically implausible, as it requires symmetric forward and backward weights and backpropagates a reward signal. However, it implements select propertics from biological learning, such as only altering contributing neurons Pozzi et al. (2020) and performing local, hebbian-like updates modulated by a reward (cf. Section 3.1. LFP scales well to surge-scale tasks (cf. Sections 3.5, 4.1) and avoids gradient computations altogether by adopting a multi-agent view of DNNs and distributing a global reward locally to single neurons based on their contribution. It is therefore closely related to techniques that apply reinforcement to single neurons, either based on global reward (Seung, 2003) or by assuming local, neuron neuron-wise rewards are available (Wang & Cai, 2015), Among these methods, BrainProp (Pozzi et al., 2020) also distributes a feedback signal to single neurons based on a global reward, similar
5

---

Published in Transactions on Machine Learning Research (06/2025)
to LFP. However, BrainProp's feedback consists of enror signal derived from the global reward, and consequently requires computation of derivatives and differentiable models. Furthermore, the method optimizes for one output unit at time, limiting convergence speed, and the feedback can grow arbitrarily large for deeper models due to long chains of weight multiplications. In contrast, LFP does not require models to be differentiable as no gradients are computed, implicitly normalizes the distributed reward (cf. Equation 2), and can optimize for all outputs at the same time. This makes LFP applicable to both supervised and reinforcement learning problem formulations.
2.2 Utility of Intermediate Explanations
Due to the highly nonlinear complexity of DNNs, their underlying decision decision-making is difficult to interpret. For this reason, the field of XAl has come forth with several methods to elucidate on a model's behavior. Here, post-hoc methods aim to explain existing and already trained models and can be divided into global and local approaches:
Global XAI interprets model's behavior in general manner, e.g.. by identifying (and visualizing) encoded concepts or learned representations and their hierarchical relationships (Bau et al., 2017; Kim et al., 2018; Hu et al., 2020; Hohman et al., 2020; Zhang et al., 2021; Fel et al., 2023b; Achtibat et al., 2023; Vielhaben et al., 2023; Kowal et al., 2024), by computing (and visualizing) its sensitivities (Santurkar et al., 2019; Fel et al., 2023a), or by interpreting their internal mechanisms through surrogate models (Huben et al., 2024; Gorton, 2024; Bhalla et al., 2024; Dreyer et al., 2025).
Local XAI instead explains the individual predictions of model. That is, for particular sample, local explanation techniques seek assign importance scores to individual features groups of features that have the most influence on model's decision. Here, sampling-basee techniques (Strumbelj & Kononenko, 2014; Ribeiro et al., 2016; Zintgraf et al., 2017; Fong & Vedaldi, 2017; Lundberg & Lee, 2017) assume models to be impenetrable black boxes, and consequently Sewnnng--resoonse-eeeee
explain through a Methods that modify the backward pass, such as Baehrens et al. (2010); Bach et al. (2015); Montavon et al. (2017); Shrikumar et al. (2017); Sundararajan et al. (2017) require grey-box access to model's internal parameters. In turn, most of these latter methods can be implemented explain efficiently in terms of computation time (requiring exactly one forward- barkwardd pass).
involving perturbation, but are costly to compute and approximative.
Beyond the human- human-understandaee understandable explanations in input space, secondary property of local XAI is the ability to generate intermediate explanations, i.e., assign importance scores to the activations (or for some methods even to weighted connections) of intermediate layers. Especially methods that modify the backward pass yield such intermediate explanations naturally and efficiently, as a by-product of computing input-level scores.
Several previous works have utilized these intermediate importance assignments towards improving models: For instance, explanation scores can be employed similarly to an attention mechanism during training, masking features in the forward pass (Fukui et al., 2019; Schiller al., 2019; Sun et al., 2020), to guide which information is passed through dropout layers beyond random choice (Zunino et al., 2021). Lee et al. (2019); Nagisetty al. (2020) instead apply similar XAI-based masking to the gradients during the backward pass. In trained models, intermediate explanations are employed as a criterion for pruning or quantization (Voita et al., 2019; Sabih et al., 2020; Becking et al., 2022: Yeom et al., 2021: Soroush et al., 2023; Hatefi et al., 2024) to increase efficiency. Similarly, Ede et al. (2022) proposes XAI-guided plasticity regularization of relevant neurons in order to mitigate catastrophic forgetting when learning consecutive tasks.
Our method is related to the above works that leverage intermediate explanations for model improvement both during and after training, specifically those that augment the backward pass (Lee et al., 2019; Nagisetty et al., 2020). However, in contrast to the above methods, we do not utilize explanations as additional guidance, and rather distribute reward directly to single neurons based on their contribution. Instead of explaining a specific decision, this can be understood as explaining the source of an obtained reward in terms of internal model components and updating parameters based on that information. We choose utilize Layer-wise Relevance Propagation (LRP) for reward propagation due to its demonstrated utility in several of the above applications (Lee et al., 2019; Sun al., 2020; Becking et al., 2022: Yeom et al., 2021; Ede et al., 2022; Soroush et al., 2023; Hatefi et al., 2024).

---

Published in Transactions on Machine Learning Research (06/2025)
3
Layer-wise Feedback Propagation
In this section, we introduce the methodology behind LFP in detail, demonstrate its convergence empirically, and prove it theoretically.
3.1
LFP Backpropagation and Credit Assignment
LFP assigns credit to parameters by distributing reward throughout the model. We detail the specific LFP backpropa- gation rules partially inherited from the LRP methodology - below:
3.1.1 Reward Propagation and Parameter Update
Let be singular input sample to model f, with corresponding one-hot encoded ground-truth label y E 10,1)% and C' possible classes. Then, fxx denotes the model output given x and ag |++1] the output of an arbitrary neuron j at layer [+ 1. This output computed as
=
= ofttl
Σ
1+11 a.! w 1u
(1)
where of
|/++]] denotes the activation function of the neuron j and the parameters wif [++1] weigh the output a." of the i-th
neuron at layer The weight Wiytt1 may be if there is no connection between i and j. We view the bias 6/ b of
[[+1] in this context. As common in LRP-literature
each neuron j as a weighted connection constantly receiving 0b,
(e.g., Montavon et al. (2019)), we denote the contribution of connection between neurons i, as Zij wa
|++1| [t+1]
and the pre-activation of the j-th neuron as [[+1] Σ, [++1]
LFP then assumes that an initial reward re is available for each output neuron c, measuring how well it contributes to solving the task. In practice, r, is decomposed from a global reward Rg assigned the predicted outcome (e.g., the class in supervised classification) corresponding to c. This initial decomposition from R. re may be task-specifie. Refer to Section 3.2 for more details. Intuitively, positive reward should cause positive reinforcement, and negative reward negative reinforcement. Therefore, the resulting change neuron activation depends the sign of both the reward and the activation. To optimize performance, if positively activated neuron receives positive or negative reward, we signal it to increase or decrease, respectively. With the same-signed reward, a negative activation is signaled to decrease or increase, respectively. After obtaining Te, it is propagated backwards through the model based on the backpropagation rules of LRP, so that the at layer | + eventually receives local reward r [[+1] decomposition of the initial r. of all E C. In the below derivations, the LRP-0-rule is used for simplicity, although this rule is generally not applicable without issue in practice due numerical instability (cf. Sections below). Then, reward message r. [[+1|
is from neuron j at layer + 1 to neuron layer (i.e., through the connection weighted by wij
[++1]
[++1]
|++
1]
[+1]
(2)
[+1]
2
The local reward for neuron then accumulates as
14
R-11
(3)
Equation 3 inherently assigns credit to i, providing a notion of how helpful an activated neuron or a parameter in solving the task correctly. Similarly, rig /4+1] from Equation 2 is derived by decomposition from the local reward Tes and can thus be interpreted as reward for the connection weighted by Wiytr u- Note that (excluding reward flowing to bias terms) Equation 3 and Equation 2 implicitly normalize the decomposed reward to sum to the initial reward (cf. Bach
et al. (2015)). I.e., if the model has layers E [0, 1,.,,,. I. 1). then VI. E.r!" Σ, E- Ee [2] holds.
7

---

Published in Transactions on Machine Learning Research (06/2025)
In order derive update for wij 1) replace wij
[++1] in Fig
[++1] from Equation equation 2 with sign(wit
(gn((tt w
2+1]
wey [++1]] Le., we multiply the reward rij [t+1] with the parameter sign (since identically signed rewards should result in opposite update directions for negative/positive parameters) and thus arrive the following update step:
[+11|
11
dhp "i
[w)
ag
R+1]
[+1]
2
(4)
(wi )
[
[++1]
d
wij n
Here, 1) is learning rate. We refer to this basic formulation of L.PP LFP-0. Note that while utilize LRP-like rules to obtain [++1], this is not strictly required, and r [++]] could theoretically come from any source, with Equation 4 performing reward-modulated Hebbian-like update, as detailed below. Optimization akin to Stochastic Gradient Descent (SGD) with momentum can then be described follows:
dm [t-1]
dold
R++1
[t-1 a mom
+ (1 ()) dd
(5)
[++|] (wi ynew
[1+1]
wij + 17
[+1]
where E [0, 1].
Since compared to SGD, LFP employs a reward instead of a loss function, requires maximization instead of minimization the update step of the above formula. This reward is then distributed throughout the model, which - as detailed by the above equations requires no gradient computation'. Consider e.g. the Heaviside step function (cf. infinite gradients everywhere, but Equation and Equation can still
Figure A.11): This activation function has propagate a meaningful non-zero signal through models with Heaviside activations.
3.1.2 Connection to Hebbian Learning
While we derived equations (2-4) from the relevance propagation of LRP, as described in Bach al. (2015), there close similarity the resulting update rule Hebbian learning (Hebb, 1949). At its core, Hebbian learning formulates weight updates
Hebb 11 [+1]] (+1 a aj
(6)
The LFP update rule from Equation 4 can be reformulated as follows:
[++]] 11
[4]
Mp
Wij
a
|1+1]
[+1)]
|++1|
kg
2j
a
[++1]
|a]ttal so 2/ 2/t111
[++]
rr
(7)
a
[[+1]
[+1]] .r
the LFP weight update can be interpreted as Hebbian update, modulated by the local reward / [++|| In expectation, Equation 6 simply results in increasing la [+1]] By multiplying
Since (excluding 0) sagn(a." 1 /a, ////t111 [++]]]
sign( a a. [+1]
with / [[+1] LFP contextualizes [+1] to given task, decreasing (4 |++]] if neuron hinders performance as evaluated
EEquation 2 be written activation times gradient only for (piece-wise) linear models, egg. with Rel. activations, Theorem
8

---

Published in Transactions on Machine Learning Research (06/2025)
by the reward function. Aside from this reward modulation, the largest difference the original Hebbian formulation is the division of a and a. [ in place of multiplication. While this preserves the update direction, it also implicitly
regularizes the update when the weights grow too large (and, as a consequence, also la ( similar to, e-g., Oja's rule (Oja, 1989). Lastly, the LPP-update includes a multiplication with the weight magnitude that induces sparse updates, which have been shown improve performance in the context of Hebbian learning (Gupta al., 2021).
3.1.3 Special Case: Numerical Stability
The LFP-O-rule described above captures the fundamental idea of how rewards are distributed via LFP but is infeasible in practical applications due being numerically unstable for denominators close to zero (cf. the LRP-O-rule (Bach et al., 2015)).
Inspired by Bach et al. (2015), we therefore employ normalizing constant to increase numerical stability, resulting in the LFP-E-rule:
[++1]
[++1]
[+1]
(8)
19
[1-1]
[+11]
2g
+ sign( 22j
|++1||
11]
d
[1+1]
(9)
[+
[[+1]
sign(3
2j
Note that for the remainder of this work, we define sign(0) 1. We utilize this rule in all experiments as a replacement for LFP-0. As recommended by Bach et al. (2015), we choose 10-6
3.1.4 Special Case: Batch Normalization Layers
Attribution methods based on modified backpropagation, such LRP, are generally not implementation invariant and require models to be canonized (i.e. restructuring models to functionally equivalent version that only contains layer types with well-understood properties w.r.t. a given explanation method) before the explanations are computed (Kohlbrenner et al., 2020; Motzkus et al., 2022), which usually involves merging multiple layers. This mostly affects BatchNorm layers (Ioffe Szegedy, 2015) (and their neighboring layers), which implement the following operation:
(a (al+tlyonn
[+1] -2
a
F (0
Varla
11 +
We expect the above issue to extend to LFP as well due to its close relation to LRP. However, merging BatchNorm layers during training is not possible, as these layers also contain learnable parameters. For this reason, we instead provide a rule to propagate reward through BatchNorm layers approximatively by first writing the BatchNorm equation as two consecutive linear operations:
(af (o = u+ 1ل 11 + g[[+1] and az
F
[a
(10)
Varlu!") | +
Varla +
11|
This allows us to formulate the following I.FP rule:
[[+]]
+
5) [+1]]
(11)
ij a
[-1
+
sign (a
[+1l

---

Published in Transactions on Machine Learning Research (06/2025)
Table 2: Examples of reward functions for multiclass classification (i.e., one output neuron per class) with LFP. In the table, denotes the sigmoid function, and SM the softmax function. GD denotes gradient descent and CE cross-entropy.
Theorem 1: ED-Equivalent
ID
Tc
p(f(x))
Re
#1
sign(o.) 0c) [lye 1)
1(ye 1)
sign(0.):
#2
-1(3d -ye
A Or > Oct)
-1(3d ye 1/0 0ct)
(1- (M)() SM(o.)
if =
l0el
if Ye
#3
oe (ye SM(Oo))
Softmax-CE
yo 0
-1oel
V/c
(1-0(0))
if ye =
loel
if Ye
#4
Oc (ye- - o(o)))
Sigmoid-CE
(00)
if ye
10el
if yo 0
Mp
h
|4
[+11]
[+
aj + sign(a)
[+1]
1+1
1
18
Ifp 6/+11
1++1]
(12)
|+1| aj + sign(a,
1+1
For updating parameters 7/ |++1] and +!++]] the above rule simply applies LFP-E to the second, parameterized linear operation. This is also done for passing the reward backward in Equation 11, but mean F(a!")) 0 is assumed for this backward pass since shifting rewards across can lead to updates in the wrong direction in preceding layers. Note that
[[+1] aj
[+1] here, since BatchNorm employs linear activation function.
We apply this rule to the ResNet (He et al., 2016) and VGG-16-BN (Simonyan Zisserman, 2014) models in our experiments.
3.1.5 Special Case: Skip Connections
Skip connections do not contain parameters and simply merge incoming activation signals from multiple pathways. They are present several architectures such as ResNets (He et al., 2016) and merge activations either through concatenation (a) ( ja!"] 0 1 or summation (a) j !!] dj ?-1') For the former type, we pass rewards through the concatenation. For the latter type, rewards are decomposed according to their proportional contributions:
[[+1] (1
[11]
a
[+1]
si
[+1]
[1-1]
[[+1]
aj
r3 [+1]
r kj
[+1]
sign(a,
(+1l)
(13)
aj
3.2 Obtaining Initial Rewards
I.PP distributes reward signal r. throughout the model. re is the initial reward assigned to the output neuron As such, it slightly differs from a global reward R. (as employed, e.g., in reinforcement learning) assigned to the outcome associated with neuron c. We distinguish between an output and an outcome as follows: For instance, consider the example of (multiclass) classification. The highest-activating output neuron e = may produce the output o, 1.234
be linearly activated (i.e. o, z.) in all models except SNNs, where multiclass classification, the class with the largest predicted, any nonlincarities (e.g., softmax ohtain probabilities) are interpreted as part the objective function.
'Note that assume output
Heaviside activation.
10

---

Published in Transactions on Machine Learning Research (06/2025)
for given sample. Consequently, the class corresponding to this neuron is chosen prediction, resulting in the outcome that class 0 is assigned to the given input. I.e., the outcome (the class prediction in this example) is derived from the output (the raw logit) via some rule or function that depends on the task. Note that the current prediction in the above example only one of C' possible outcomes, and more than one outcome may be considered at the same time by obtaining nonzero R. for more than one class.
In this framework, Rg measures the quality of an outcome, not considering the model that produced it. For instance, the correctness of class assignment to given input. r. considers the model by decomposing R. to the output o, of the neuron based on the mapping from output to outcome. Consequently, how oe should be evaluated w.r.t. the task depends on how an outcome (e.g., a class prediction) is derived from Oc. For instance, consider binary classification with an instance correctly classified as class O, and RS = 1. If two output neurons exist, each corresponding to a single class, neuron c = receives a positive global reward. However, if og < 0, the initial reward To should become negative in order to encourage positive output maximizing class probability. On the other hand, if only one output neuron exists and the sign Og determines the predicted class, ro should be positive, e.g., to Rg. in order to encourage the current (correct) direction of on - again maximizing class probability. As shown in the example, obtaining re from Rg therefore requires initial decomposition that depends the relationship between output og and the associated outcome.
For supervised classification, which is the focus of this work, deriving re from Re straightforward: In the special case binary classification with one output neuron, we maintain т. = Rg. Otherwise, for multiclass settings with one output neuron per class, re can be obtained as
sign(oe)
Re
(14)
Since the reward directly affects parameter updates (cf. Equation 4), the model will be updated long as long as a re is nonzero. While this is not the only solution', including convergence mechanism p(f(x)) RC + [0, 1] in the initial
reward re alleviates this issue:
Fc = sign(o.) p(f(x)) R
(15)
Under the above formulation, possible reward functions for LFP are listed in Table 2. In this table, the third and fourth row are equivalent to commonly used loss functions for gradient descent, as described in Theorem (cf. Section 3.3). Specifically, #3 corresponds to cross-entropy loss with softmax, and #4 to a cross-entropy loss with sigmoid. Note that for the purpose of Theorem we view the softmax and sigmoid nonlinearities as part of the loss function, applied to linearly activated outputs og. We employ reward #3 in our experiments. We briefly investigate LFP with reward #2 in Appendix A.3.
3.3 Convergence of LFP
In this section, we demonstrate theoretically and experimentally in the context of supervised classification that LFP converges, and can successfully train MI models. First, we show the following theorem:
Theorem 1. For a differentiable loss function I. and any Rel.U-activated network, LFP-0 with initial reward
Tc = 0c (
d.C
(-doo
do
is equivalent to weight-scaled gradient descent, i.e.
[1+1] (Wi 11 now w. - 17 -w0
[++1]
11-1| dl
[+1
dw ij
"There exist heuristics for training despite non-converging rewards, such zero-capped rewards, capped parameters, early stopping. or progressively decaying learning rates or rewards. Utilization such techniques allows for the application wider range reward functions heyond those applied this work.
11

---

Published in Transactions on Machine Learning Research (06/2025)
In particular, allowing for individual step sizes Tkÿ if we choose Taj |wij |w/j 11 o1 we can frame gradient descent for any differentiable loss function in the LFP-framework.
For the detailed proof, refer to Appendix A.2. While we proved the statement in the Theorem for Rel.U-activated models, as that is by far the most common setup in DNNs, it in fact holds for several piecewise linear activation functions (such as Linear, ReL.U, or Leaky ReLU). Le.. for networks with these activation functions, we can reformulate gradient descent with any differentiable loss function as LFP-0 with the appropriate reward.
However, LFP can also be used achieve learning behaviour different from gradient descent as the above theorem is subject to several conditions, which are not necessarily fulfilled in practice (including the experiments below). These conditions are as follows:
The theorem assumes LFP-0 Rule. In practice, we employ LFP-E in all experiments for numerical stability. This results in updates that do not only differ in magnitude from L.FP-0, but potentially even in sign due to cascading effects from higher layers. Additional rules may be formulated for LFP, which can yield diverse learning dynamics and behaviors (see Appendix A.5).
LFP-0 Rule.
Specific Activations. The theorem implicitly assumes activations
(=(")) = do! (2.1)
(16)
dz!'
This condition is fulfilled by e.g. ReLU, LeakyReLU and Linear activations, but not Hcaviside, Tanh, SiLU, ELU, GeLU. For the latter group, LFP may exhibit update behavior different to gradient descent even in simple settings, as shown, e.g. Appendix A.4 In our experiments, we apply both types of activations.
Specifie Reward Functions. The theorem only holds for rewards r. o, rewards for LFP which cannot be expressed through gradient descent and would require other, reinforcement-lerriing based approaches instead, e.g. Table 2, reward #2:
(-
d.c. do
However, there exist sensible
Te - 103 we 0. > 0o) -iig((o))
(17)
where reward -1 punishes any false positive?.
In a first experiment, we show empirically that LFP is able to train models in simple supervised classification settings. For this purpose, we train a small ReLU-activated MLP (fulfilling the proof-conditions of Theorem except for the LFP-0 rule) on three toy datasets (cf. Figure leff) using LFP-s (Equation 8). For more details about the specific setup, refer to Appendix A.7.1. Figure 3 shows the decision boundaries, accuracies, and weight distributions of the resulting models. Firstly, as shown by the train set accuracies over iterations (second-to--rihh), LFP is able to converge well to respective solutions for the given toy tasks, with the obtained solutions achieving high test set accuracies and their decision boundaries (left) separating well between classes. Refer to Appendix A. for decision boundaries for other stochastic gradient descent (Grad), we find that they achieve the same accuracy, however, I.PP scales differently w.r.t. Mime ). Thirdly, we observe that the solutions (parameters of the model) learning rate (for same performance, TILP 100
activation functions. Secondly, when comparing the performance (second-tt to--edf of LFP and
obtained by LFP are of increased d-sparsity (right), with few large positive negative parameters when compared to the initialization or solutions obtained by standard gradient descent. When dividing weights into groups via threshold 85, LFP-trained models have much more "neutral" weights w.r.t. 0 than the initial model or the models trained via gradient descent. As shown in Figure 4, this sparsity is caused by the implicit weight-scaling in the LFP update step (cf. Theorem 1). We investigate this property in detail in Section 4.1.
3.4
Computational Cost of LFP
LFP leverages LRP to decompose rewards to all neurons in network. Updates for each connection are then directly derived from the resulting local rewards at each neuron via multiplication with scalar factor. Consequently, the computational complexity of a single model update with LFP is the same as computing attributions via LRP (and the
We investigate I.FP with this reward function Appendix A.3
12

---

Published in Transactions on Machine Learning Research (06/2025)
Ducision Boundariio (Trot Sed)
Purformamce (Test Set)
Convergennon (Train Set)
Weight Distribution
LiPs
100
Finh Phitsont
Toa Accunicy [0]
80-
80
of Welphta
800
Trin Aucuaney
00-
600
00-
Output
100
10
10
10
25
75
6.5
1.0
LFP-c
100
100
Inystt
6,85
Cirecle Thstwoe
Ttl Aueunny [S]
[X]
Waghis
40-
00
30-
Output
-0
10
500
0.5
LFP
100
Muniees Wedghes (PS).
Input
Swiel Dolnow
Toa Ausurac (15)
80-
80
80-
Ttan Accuracy
60-
807
00-
80
LFP Gzod
9-0.0
Chrient
10
10'
10
10
300
1000
0.0
0,5
2.0
1R
Iteration
Threhhod 6
Figure 3: Proof-of-Concept results for LFP on toy data. Left: Training with LFP results in the expected decision boundaries. Second-to-Left: Under similar training conditions, LFP achieves comparable performance to gradient descent, although scales differently in terms of learning rate. The diamond marks the highest performance across learning rates; the remaining panels on the right plotted for this best performing configuration. Second-to-Right LFP converges in stable manner. Right: Distribution of weight values, given relative threshold 6 In each panel, the percentage of large positive (green), large negative (purple) and neutral (grey) weights for each threshold is shown on the left (areas are drawn cumulatively to sum up to one, with lines highlighting the border between areas). On the right of each panel, connections are colored accordingly, for 0 = 0.25. Compared to the initialization and the solution found by gradient descent, LFP finds 9-sparse solutions, with more weights being assigned "neutral" lower thresholds (number in the top right).
15
LFP
15
Grad
125
10
10
100
75
Iteration
102
5
50
0000
0
25
00.000
-5
-5
5
10
15
0
5
10
15
W11
Figure 4: Update behavior of LFP-c and gradient descent a two-parameter toy setting (wi and w2, no bias). The contours show constant values of the respective objective function (reward left and loss right, with lighter shades of magenta denoting more positive values and lighter shades of blue denoting more negative values). The training progress of seven differently initialized models is shown in orange. The same initializations Gradient descent simply updates all models towards the global optimum, measured by the lowest loss. In contrast, LFP distributes reward throughout the model, updating parameters depending on their contribution. This results in an implicit weight scaling, affects step size and update direction, and encourages finding a sparse solution, where possible. Refer to Appendix A.7.1 for experimental details.
used for both training schemes.
same as computing gradient descent update), which is in (1) given single forward pass (Achtibat et al., 2024). Le., theoretically, I.P requires one forward and one backward pass to update the model given single batch of data. Note
13

---

Published in Transactions on Machine Learning Research (06/2025)
100
100
MLP
LeNet
Test Accuracy [%]
60
60
40
40
20
20
0
10
10
10
10a
10a
10
10
10
10
10
10
10
10
10
Time (s)
Time (8)
LFP-c (Ours)
PSO
Feedback Alignment
Grad
dIADMM
Figure 5: Comparison of test accuracy time when training Multi Layer Perceptron (MLP) (left) and LeNet (right) using LFP various other optimization methods. The training time of LFP is in the same order of magnitude for other training approaches that perform a backward pass. Note that an implementation of dIADMM compatible with convolutional networks was not available. Time-axis is logscale. The diamonds mark the end of the first and last epoch for each method. Refer to Appendix A.7.2 for experimental details.
that in practice, our implementations of LFP rely on the LXT library (Achtibat et al., 2024), which simply overwrites the forward and backward passes and follows the above computational complexity. We also implement LFP for the zennit library (Anders et al., 2021), which utilizes a version of gradient checkpointing for increased memory efficiency, but in turn requires two forward passes and one backward pass per batch update.
To analyze computational overhead associated with LFP, we compare its performance and required clock time against stochastic gradient descent, feedback alignment (Lillicrap al., 2016), dIADMM (Wang al., 2019), and variant of Partiele Swarm Optimization (PSO) (Eberhart & Kennedy, 1995). We chose these methods based on their applicability to standard DNNs, distinctness in optimization strategy, and availability of implementation. Refer to Appendix A.7.2 for details on each method's 's hyperparamters. We train a simple MLP and LeNet for 50 epochs on MNIST using the above approaches, applicable. As shown in Figure 5, LFP has computational overhead comparable to e.g. gradient descent and feedback alignment, which also perform a backward pass.
3.5
LFP for non-ReLU Activations
We have shown in Scction 3.3, that LFP-0, as formulated in Equation 4, is equal to weight-scaled gradient descent, but may differ in the magnitude of updates. This does not hold for models whose activation functions are not partially linear (as well as for the LFP-s rule applied in practice), in which the updates caused by LFP and gradient descent may differ more significantly (cf. also Appendix A.4). Consequently, LFP generates meaningful update signals when applied to such models.
investigate empirically in the following Section whether
Table compares performances of LFP-trained models across various activation functions (ReLU, SiLU, ELU, Tanh, Sigmoid, and Heaviside Step Function, from left to right). These activations are further illustrated in Figure A.11. Note that among these, LFP-0 would equal weight-scaled gradient descent only for ReLU activations. Refer to Appendix A.7.3 for further experimental details.
We observe that LFP on ReLUU-activaee models outperforms all other activations (except for the VGG-like model, where ELU wins instead). However, with SiLU, ELU and Tanh activations LFP generally also converges, albeit with slightly lower performance depending the model and data. This is interesting, there is no equivalence between LFP and gradient descent for these activations (cf. Theorem 1, which relies on a subset of piece-wise linear activations), but LFP still arrives at a good solution.
For the remaining activation functions, Heaviside and Sigmoid, I.P leads to (close-to) randomly performing models in this experimentS. With LFP being applicable Reaviside-activatte models in theory, this result is initially surprising.
NNte that this random baseline varies strongly between R8 and VGG-16 for the ISIC2019 dataset. This dataset contains extremely imbalanced classes, with one class "NY" containing approximately half the total amount of samples. Dopending on which class is favored, accuracy of randomly performing models can vary significantly.
14

---

Published in Transactions on Machine Learning Research (06/2025)
Table 3: Accuracy LFP with different activation functions. Mean and standard deviation over three seeds were evaluated. For all models except VGG-like, LFP on ReLU-models outperforms (underlined) all other activations. However, for several not piece-wise linear functions (SiLU, ELU, Tanh) LFP achieves accuracies that are close that, showing that LFP is also able to train models with not partially linear activation functions. For reference, we also provide gradient descent results in grey.
Activation
Model
Data
ReLU
SILU
ELU
Tanh
Sigmoid
Heaviside
82.2:0.4
77.1
82.7+0.4
78.8=0.2
10.0
10.0
Cifar10
84.1+:0.4
85.3+0.3
85,2
80.7+0.1
10.0+0.00
16.0+00.5
VGG-like
49.0
45.7
51.0+0.3
20.6+0.6
1.0+0.0
1.0:0.0
C0
52.0+00.6
55.8++0.6
55.5++0.4
51.1+0.3
1.0+0.00
2.4+-011
72.9+0.2
72.6+0.5
0.5
1.0
0.5+0.0
0.5
CUB
71.6.0.11
71.740.3
69.910.44
5.343.9
0.540.0
2.8+0.11
86.5+0.2
84.8
80.0
50.620.0
50.6+0.0
50.6+0.0
VGG-16
ISIC2019
87.1+0.22
86.9+0.1
86.910.3
50.6+0.0
50.6+000
54.5
91.7+00.2
91.2+00.5
91.0+1.4
30.9+15,4
14.9+0.0
14.9+0.0
Food-11
91.9+-0.2
91.2+00.0
90.740.1
31.34-3.2
14.9+0.0
33.0++0.2
66.7+H0.3
54.2+0..
47.4+0.3
12.4+1.5
0.5+0.0
0.5+0.0
CUB
70.4+0..3
63.5+0.6
47.940.3
16.5+0.3
3.740.1
1.5+0.1
85.1+0.66
80.3+0.2
77.3+0.5
72.9+0.7
17.7+0.0
17.7+0.0
ResNet-18
ISIC2019
86. 66.0.10.6
84.8+0.2
82.410.3
78.820.3
69.5
54.5+0.3
90.9::0.5
86.8+0.5
82.4+0.4
76.0=0.7
11.0+0.0
11.0+0.0
Food-11
91.74-0.7
88.7+0..3
86.4
82.2+0.3
71.2+00.5
29.8+-0.2
especially combined with the above-random performance of gradient descent. We hypothesize that such models may be difficult to train in practice, since the Heaviside function has no decreasing slope before evaluating to zero, and thus, in classical ANN architectures, leads more easily to dead neurons than other, comparable activations, e.g., ReLU, We investigate this effect more closely Section 3.6 and provide a solution for LFP. We further show that Heaviside activations cause issues for LFP when different model type is used, i.e., in the context of SNNs in Section 4.2, which accumulate stimuli over time and thus may be more robust to dead neurons.
Sigmoid, on the other hand, is equal to a scaled and shifted Tanh function. As LFP is generally able to train Tanh- activated models, this illuminates a requirement of LFP: Activation functions need to map positive values to [0, co] and negative values to [-o0, O]. Otherwise, pre-activation and post-activation may be differently signed, and the accumulated (post-activation) reward (ef. Equation 3, rı) cannot be used directly as the (pre-activation) reward (cf. Equation 2, ry) in order further backpropagate feedback 10, We note, however, that this requirement is rarely not fulfilled in state-of-the-art deep learning models; consequently, it only impacts the applicability of LFP to non-deep- learning machine learning applications in practice. The Tanh activation fulfills this requirement, but Sigmoid does not. In comparison, for gradient-based training. fulfilling this property is not strict requirement, but nevertheless advantageous, as evidenced by the large performance gap between Tanh and Sigmoid activated models (Sigmoid-activatee models achieve above-random performance only for ResNet-18) for the gradient-descent baseline.
In general, we observe that the optimal configurations (i.e., underlined values in Table 3) for gradient-descent slightly outperform the optimal configurations of LFP. This difference varies between models and datasets, but exceeds 1% only in three settings. We attribute this performance gap the additional implicit weight-scaling of LFP, which may impact accuracy slightly negatively, but provide advantages in terms of model sparsity (cf. Section 4. In summary, we find that LFP is able to train models whose activation functions are not partially linear; indicating that it functions as a training paradigm in settings where it is not equal to weight-scaled gradient descent (also ef. Section 4.2, where the condition on activations from Theorem is also not fulfilled).
Note that we investigate the reason behind LFP failing train Hcaviside-activaee DNN' in Section 3.6, provide solution, and demonstrate its efficacy Heaviside-activatee SNN (cf. Section 4.2).
10 pre pre-activation and post-activation have different signs, the LFP formulas could adapted heuristically by simply taking the oppositely signed post-activation reward pre-activation reward
15

---

Published in Transactions on Machine Learning Research (06/2025)
100
100
Zero Activations %
Test, Accuracy [%]
80
MLP
60
60
No Noise
LFP-c
20
20
Noise
Grad
100
100
Zoro Activations [%6]
Test Accuracy [%]]
80
LeNee
60
60
20
20-
LFP- [No Noise)
LFP-E [Noise]
Grad [No Noise
Grad [Noise]
0
20
30
40
Epochs
Figure 6: Effect of adding noise to activations during training LFP and gradient descent performance Heaviside- activated DNNs. (Top row): Small MLP: (Bottom row): LeNet. We report the test accuracy of the final model (left) and the percentage of zero activations (averaged over all batches within an epoch) after the last Heaviside for the first 50 epochs (right). Models with noise applied to activations during training are shown as dotted hatch and line, respectively. Adding noise to activations during training helps (only) LFP, vastly increasing the achieved test performance.
3.6 Training Heaviside-activated DNNs with LFP
Although propagating rewards through Heaviside activations with LFP is feasible in theory, LFP does require the computation of gradients, the results presented in Table show negative result. This finding is initially unexpected, particularly in comparison to the gradient descent trained baseline models, which perform above random. Note, however, that the models evaluated in Table 3 were pre-trained on ImageNet using gradient descent and employ linear activation in the final layer. It is therefore reasonable to expect that gradient descent would achieve above random performance in these tasks by leveraging the pre-trained lower-layer parameters while updating only the final layer.
For LFP, we hypothesize that it fails effectively train the Hcaviside-activatee DNNs in this experiment due to the emergence of substantial number of dead (i.e., always zero-activating) neurons during the initial training phase. Since such neurons neither contribute nor propagate rewards backward, they effectively obstruct both forward and backward information flow, thereby preventing the updating of lower layers. As discussed previously. this property makes the algorithm more efficient and realizes a property of biological learning (Pozzi et al., 2020). We further observe that LFP successfully trains the SNNs discussed Section 4.2, despite their reliance on Heaviside activations. We attribute this discrepancy to the noisy inputs and dynamic, time-dependent nature of SNNs that accumulate membrane potential over time.
If this hypothesis is correct, initial increase in inactive neurons should be observable when training Heaviside- activated DNNs with LFP, but no such change should occur with gradient descent due to the zero-derivatives of the Heaviside function. Furthermore, introducing a small degree of noise to activations during training (there seems to be evidence for noisiness in biological neurons as well (Buhmann & Schulten, 1987)) should mitigate the issue of inactive ncurons, thereby enabling LFP to produce meaningful, albeit slightly noisy, updates. To evaluate this hypothesis, we conduct experiments on the MNIST dataset, as illustrated Figure 6. We test three-layer MLP with full Heaviside activations, including the final layer, and a LeNet with Heaviside activations all layers except the last. The MLP comprises linear layers with 120, 84, and 10 neurons, respectively. The LeNet architecture consists of two convolutional
16

---

Published in Transactions on Machine Learning Research (06/2025)
layers with 16 channels and kernel size of 5, each followed by max- max-pooling with stride of 2. Two subsequent linear layers contain 1 120, 84, and 10 neurons for classification. Both models are trained with a learning rate of 0.1 and a batch size of 128 for 300 and 400 epochs, respectively.
As shown in Figure 6, a rapid increase in inactive neurons occurs within the first few iterations when using LFP, whereas no such effect can be observed for gradient descent. Moreover, introducing minor noise to activations effectively mitigates this issue for LFP, leading to vastly improved test accuracy in the final feeviside-activatee model (Note that no noise is applied during testing). Furthermore, despite the final layer of LeNet being linearly activated, gradient descent achieves only random performance that model. This suggests that the above-randond performance of gradient descent in Table 3 can be attributed to the advantageous pre-trained weights in conjunction with training of the linearly activated final layer.
Note, however, that a limitation of this noise-based approach is the increased training time, requiring 300 epochs for the MLP and 400 epochs for the LeNet. Different noise, or more informed "drop-in" strategy may be able to resolve this, however, we leave investigation into this to future work.
4 Applications
In the following, we will consider two specific upplications for LFP, based on the above observations:
4.1 Application 1: Sparse and Prunable Models
In Section 3.3, we observed that in the investigated toy settings, LFP seems to lead to sparser models than gradient descent, i.e., the resulting models have few comparatively large weights and many weights that are close to zero. Sparser models utilize the available parameters more efficiently, in the sense that larger number of connections can be pruned (i.e., removed) before performance deteriorates, allowing for reduced memory requirements when storing the model. In this Section, we explore this model sparsity property of LFP in more detail. Refer to Appendix A.7.4 for details on the experimental setup.
For this purpose, we first confirm that our observations regarding weight distribution from Section 3.3 extend to larger scale models as well. The layer-wise normalized weight distribution for LFP- and gradient-trained ResNet-18 models is visualized in Figure (top). The bottom plot shows the average Gini coefficient (Hurley Rickard, 2009) of the visualized distribution at each layer, as measure of sparsity. Note that we canonized (see Appendix A.7.4) the BatchNorm layers of the ResNet into the preceding convolutional layers to account for their implicit re-scaling of weight magnitudes. Results for more models are available in Figure A.6. We find that indeed, compared to gradient-trained models, LFP-trained models are sparser, with more weights close to zero and few large weights, as well as higher Gini indices. Le., relative to the respective weight magnitude in each layer, the visualized percentiles up to the 75th are lower for LFP than for gradient descent.
However, the fact that the weight distribution of an LFP-trained model is closer to zero does not necessarily imply that its weights are sparser, in the sense that less weights are relevant. We therefore study further how this changed weight distribution affects the prunability of the resulting models. Here, we first employ magnitude-basee pruning criterion akin to Han et al. (2015). If a model retains performance for longer while being pruned under this criterion, it either has a better connection between weight magnitude and weight importance or is practically sparser, with more weights being safely removable. To test whether the latter case applies, we thus additionally employ a relevance-based pruning criterion (Voita et al., 2019; Ycom et al., 2021; Hatefi et al., 2024). The pruning criteria are described in more detail in Appendix A.7.4. The results of this analysis are visualized in Figure 8. L.F--rrid models generally retain performance better than gradient-trained ones under magnitude-based local pruning (leff) and global pruning (middle), i... the curve only starts decreasing at a higher pruning rate. This implies that both within each layer, and globally across the whole model, there is better weight peggiitdd-impootane connection, or that more weights can be removed from the resulting model. Since LFP-trained models also perform better under the relevance pruning criterion (right), the latter is the case. Results for additional models and datasets are available in Figure A.9. Note that we observed the final LFP-trained models to perform slightly worse than gradient-traiee trainee models during this experiment (cf. Figure A.9), which we attribute to slightly slower convergence due to the increased sparsity. Furthermore, there are certain few combinations of dataset, model, and pruning criterion, where gradient- trained models outperform the LFP-trained models in terms of prunability (for instance, CUB, ResNet-34, and relevance-based pruning). Interestingly, these
17

---

Published in Transactions on Machine Learning Research (06/2025)
1.16
0.90
Gini Coefficient Weight Magnitude
0.2
0.1
8.9
0.4
convl
layer1 1yve110.com co.mv
layerz 1.0. w....o22222
layer 1.1 1.covvl
layer 1.1 L.onv2
layer2.0 O. convvl
layer2 O. 0.conv2
layer2. Leonvl
layer2. Leouv2
layer 0. 0.covvl
Layer3. 0.conv2
1ayer3, Leovvl
layer3, 1. Louvv2
layert, 0.cov1
layerd comv2
layord.0 downsmmplee..
layer4.1 L.o.voll
layer4.1 1.cov22
layer2.0 O. d.d.onsanlle....
layer3 0 downsample
LFP-g Grad
Layer
Figure 7: Sparsity of LFP-trained models vs. gradient-trained models. Top: Distribution of weight magnitudes, nor- malized by the maximum absolute value per layer. Data is shown for ResNet-18 18 models, trained on the CUB dataset using either LFP or gradient descent (Grad). BatchNorm layers were canonized into the preceding convolutional layers. Black horizontal lines of each bar denote, from the bottom to the top, the 0-th, 25th, 50th, 75th, and 100th percentile of weight magnitudes in each layer. Bottom: Gini coefficient of normalized weights at each layer, as measure of sparsity. A higher Gini coefficient implies higher sparsity. Relative to the layer-wise maximum magnitude, LFP-trained models have larger amount of smaller weights close to zero in each layer, indicating increased sparsity compared to the gradient- trained models. This is confirmed by the Gini coefficient, where the score of the LFP-trained models is larger or equal to that of gradient-trained models. Results are averaged over three seeds. Refer to Figure A.7 for unnormalized weight distributions, and Figure A.6 for weight distributions additional models.
restricted magnitude-base based local pruning and celevance-based global pruning. Nevertheless, trained models seem to retain performance better in the vast majority of settings. Also note that, since LFP is equivalent to weight-scaled gradient descent in ReLU models (cf. Theorem 1) the above results also align with the observations of Kim et al. (2020).
In combination, the above results demonstrate how LFP results increased network sparsity as the model is incentivized to utilize the available connections efficiently. LFP-trained models are thus more resistant against pruning, and can retain performance even when larger amount of parameters is removed.
4.2 Application Gradient-Free Training
As discussed previously, LFP functions as a gradient-free learning algorithm, which makes it readily applicable to models that contain non-differentiable components. Consequently, LFP well-suited for training a broader range of models than those trainable through gradient-based methods, including some overlap of models that both methods can be applied to.
In this section, demonstrate the versatility of LFP by applying it to train Spiking Neural Network (SNN), neuromorphic recurrent neural network architecture. SNNs process information in the form of binary signal sequences known spikes, mimicking the functionality of biological neurons. When implemented specialized neuromorphic hardware, SNNs enable event-based and energy-efficient processing while requiring less memory compared to conven- tional network architectures (Maass, 1997; Ponulak & Kasinski, 20.1). However, the binary activation functions in SNNs present challenge: their gradients are either undefined or zero, rendering direct application of gradient-based learning methods infeasible. In practice, this issue can be mitigated by replacing the network during the backward pass with differentiable approximation. Such approximations, however, could be extremely inefficient when implemented
18

---

Published in Transactions on Machine Learning Research (06/2025)
Maguitude-
Maguituudo Global Prusing
Relevance- baseed
Magnitude-based
Magnitude- based Global Prusing
Relevance- Global Pruniug
Local Pruning
Global Pruning
Local Pruning
VCC--lbe: Cifar1
80-
VGG- 1GC-100 CUB
50
Acourocy 1965
Anotrey (%)
20
LFP
Grad
20
00
90
100
0
50
87
60
100
30
10
61
30
100
0
20
60
03
100 [M]]
80
07
80
50
0
80
00
80
105
Smallee: Wenghts Praned [1]
Smalleet Weights Prennd
(9)
Smalies Ieferrancee Franed
55
Smaller
Winghts Prined
Strallee: Winghts Prined (1]
Stallest Relevannces Praned
1%
Magnitudo- based
Maguitudos
Relevance- Global Pruning
Local Pruning
Global Pruning
ResNat-18: Food- 11
59-
1%
Accerazy
00
411
60
101
300
20
60
101
100
21
40
101
80
100
Staallen
Weaght Prinool [5]] Braallent Wenghes Prinol (8) Sanillod Relreanzza Pranedd
1%
Figure 8: Test set accuracy over the percentage of pruned weights. BatchNorm layers were canonized into preceding convolutional layers prior to pruning (ef. Appendix A.7.4). Results are shown for three pruning criteria (left to right: pruning weights with the smallest magnitude within each layer, pruning weights with the smallest magnitude globally, and pruning weights with the smallest relevance globally). LFP-trained models are able to retain performance for longer when pruned based on weight magnitude, both locally and globally. Interestingly. trained models also retain performance better under the relevance-based pruning criterion, indicating that the resulting models are indeed sparser and use fewer weights to solve given task. Results are averaged over three seeds, with the shaded area showing the standard deviation across seeds. Refer to Figure A.9 for results on additional models and datasets, and to Appendix A.7.4 for more details w.r.t. the pruning algorithms.
MLP
LeNet
100
100
Test Accuracy [96]
Tost Accuracy [%%]
80
LFP-s
60
60
Grad
40
40
Sur.
Grad
20
20
0.0
0.0
0.001
0.01
0.1
1.0
10
0.001
0.01
0.1
1.0
10
LR
Figure 9: Final test accuracies after three epochs of training with different learning rates. Left: SNN based on a fully- connected MLP architecture, right: SNN with a LeNet backbone. The diamond marks the highest performance. LFP achieves high accuracies across wide range of learning rates. The top performance of LFP-s and surrogate- gradient descent (Surr.+Grad) are comparable, where the latter yields a slightly higher top accuracy. Direct application of gradient descent (Grad) does not yield any improvement at all (since learning here is not possible de 0). More details the hyperparameters and setup are provided in Appendix A.7.5. Results are averaged over three seeds, with the shaded area showing the standard deviation across seeds.
directly in hardware, as the (binary) activation functions would need to be replaced by continuous surrogates (Pfeiffer & Pfeil, 2018). LFP offers training paradigm for SNNs that overcomes this limitation by propagating rewards directly through the non-differenniaall spiking activations.
To demonstrate the effectiveness of LFP, we trained two types of SNN architectures on the MNIST handwritten digit classification task: a fully-connected network and a convolutional LeNet architecture. See Appendix A.7.5 for further details. For comparison, we also trained both architectures using surrogate-enabled gradient descent.
Figure 9 displays the final test set accuracies obtained for various learning rates. We find that LFP-g-baser training achieves high accuracies across wide range of learning rates. The highest accuracies obtained via I.FP and surrogate-
19

---

Published in Transactions on Machine Learning Research (06/2025)
Deeper2024
2es
100
100
LFP-5
80
Grad
Tost Accuracy (%%
80
Test Accuracy
Surr. + Grad
60
40
40
20
20
0-
0
10
20
30
40
50
0
10
20
30
40
50
Epoch
Epoch
Figure 10: Test accuracies epochs of training two larger SNN-architectures Cifar10 data. Architectures are inspired by the equally named ones from https:/ //t://gi hubb com/ aiiiiiiiiii wwwediintttrrsaaeeee Results are plotted for the learning rate which yielded the best performing run amongst the learning rates we investigated. LFP outperforms both gradient descent and surrogate gradient descent after a few epochs. More details on the hyperparameters and setup are provided in Appendix A.7.5. Results are averaged over three seeds, with the shaded area showing the standard deviation across seeds.
100
LFP-6
Test Accuracy [%]]
80
Grad
Surr. Grad
60
R-STDP
40
20
20000
40000
60000
80000
Time (s)
Figure 11: Evaluation of train accuracy trajectories for the Deeper2024 SNN trained on Cifarl0 with LFP, R-STDP, and gradient-base based training enabled by substantial model augmentation. It important to note that R-STDP sequentially trains each layer, thus train accuracy metrics only become available upon reaching the final layer, which occurs after approximately 7500 seconds. Due to the large training time of R-STDP we report results only for ten epochs in this figure. While both LFP and surrogate gradient descent achieve similar performance levels (which increase even further with additional epochs, cf. Figure 11), R-STDP performance remains close to random. Refer to Appendix A.7.5 for experimental details.
enabled gradient-basse training are comparable, albeit LFP results in slightly lower top accuracy for both trained architectures. Consistent with the experiments in Section 3.3, we observe that LFP performance saturates at lower learning rates compared to gradient-bart based training. Also for other hyperparameters, such as the sequence length used to encode data and the decay rate of the internal state of the spiking neurons (see Appendix A.6), LFP and gradient descent show different sensitivities. Specifically, for the LeNet architecture, LFP performs worse than surrogate-enabled gradient descent when encoding the training data with smaller sequence lengths, while performs better for higher decay rates of the internal neuron states, Figure A. in the Appendix.
We further extend this experiment by training two larger convolutional SNN architectures Cifar10 data (Figure 10). Notably, LFP outperforms both gradient descent and vanilla gradient descent after a few epochs on both models. We also applied LFP with surrogate in the backward pass as a sanity check, which yielded the exact same curve as LFP without surrogate and is thus not visualized in the figure
In addition to performance, we compare the training efficiency of different methods. Here, we additionally apply R-STDP (Mozafari et al., 2018), an alternative gradient- learning framework for SNNs that independently trains each layer based solely its respective inputs and outputs, discussed in Section 2. The findings are illustrated
20

---

Published in Transactions on Machine Learning Research (06/2025)
in Figure 11. LFP has similar time complexity to gradient descent and is faster than R-STDP. In this setting, LFP outperforms both gradient descent and R-STDP in terms of accuracy (also cf. Figure 10).
Overall, our results show that LFP-based training of SNNs efficiently achieves high accuracies comparable to (or even exceeding) those obtained via surrogate surrogat--enabled gradient-base training for different architectures across various hyperparameters and different underlying architectures. This makes LFP promising alternative for SNN training, especially in hardware implementations where surrogate gradients might be impractical.
5 Discussion
In this work, we introduce LFP, a novel XAI-based paradigm for training neural networks that decomposes a global reward signal into neuron-wise local rewards update parameters without requiring the computation of gradients.
We show empirically and theoretically, that in supervised classification settings, LFP converges under the right choice of hyperparameters. While our convergence proof relies on models containing piecewise linear activations, we demonstrate experimentally that LFP also converges for other activations, such as SiLU, ELU, and Tanh. We further identify several strengths of LFP, among these, the increased sparsity of information representation in the resulting model, and the independence from the differentiability of the model or objective. Based on these properties, we investigate two applications: The increased prunability of LFP-trained models due their sparsity and the approximation -free training of SNNs. In the former setting, we show how LFP-trained models use fewer weights to solve given task and retain better performance higher pruning rates compared to sefffeent-deeenn--rie able to train SNNs with performance trade-off compared to (approximative) gradient descent, but without requiring approximation of the Heaviside step activations during the backward pass. In summary, we provide a proof-of-concept for the novel LFP training paradigm, observing that the method has several applications and with future research beyond this work further potential to develop.
models. In the latter setting, LFP is
5.1 Strengths and Limitations of LFP
Consequently, we summarize the strengths and limitations of LFP as follows:
Strengths. Firstly, LFP can utilize both differentiable and non-differentiable objective functions. While differentiable objectives as employed e.g. for supervised gradient descent can be reformulated as rewards for LFP, the reverse is not always the case. Despite this, LFP closely related to gradient descent, with similar computational efficiency and convergence properties, but requires no gradient computation and can thus train non-differentiable models. This includes, e.g., Heaviside step function-activatee SNNs, where LFP converges to similar (or even better) performances as (approximative) gradient descent but does not require approximation in the backward pass, easing the adoption of neuromorphic hardware. Secondly, LFP finds sparse solutions without compromising accuracy. The resulting models consequently retain performance better under pruning. In combinations, these properties have promising implications towards utilizing LFP for energy-efficient Al in future work - especially in state-of-the-art applications such as deploying Large- Language models in energy- and memory-restricted applications.
Limitations. Nevertheless, there are several limitations to the applicability of LFP: Firstly, it assumes that the model consists of neurons ((h(a)) where h(a)) is a linear function of a and & an optional nonlinearity. This is the case, e.g., for neural networks, but does not include the same wide range of functions optimizable by gradients. Nevertheless, this assumption is met by deep learning applications, where LFP is best suited, Secondly, while activations do not need to be differentiable, they do need map positive values to [0, oc] and negative values to [-o0, 0), although this requirement is usually satisfied by deep learning models in practice. Thirdly, connections that do not contribute the forward pass will not be updated and will not propagate feedback backward. This originates from the LFP assumption of zero as a neutral value, inherited from LRP. Consequently, the backward pass through and update of a connection is blocked by either the corresponding activation or parameter being zero (cf. gradient descent, where backward passes are only blocked through zero parameters at a connection and, vice versa, parameter updates are only blocked through zero activations, offering more options to escape dead neurons). Note, however, that this behavior is closer to the biological reality (Pozzi et al., 2020), enables sparse and thereby energy-efficient updates, and - if desired - can largely be mitigated in practice by utilizing a momentum term or drop-in strategies such as adding noise to activations in the forward pass. Finally, the proposed reward propagation through BatchNorm layers (cf. Section 3.1.4) is a novel contribution and needs further testing in different models and in company with different L.FP rules. However, in our experiments, models
21

---

Published in Transactions on Machine Learning Research (06/2025)
that contained BatchNorm layers reached comparable accuracies in experiments whether they were trained by LFP or gradient descent, which makes the rule seem promising for I.FP- and I.RP-applications alike.
5.2 Future Work
This paper focuses on introducing Layer-wise Feedback Propagation, demonstrating its convergence, and suggesting some applications of this novel training method. For LRP, which LFP leverages to distribute rewards, there exist several rules specific explaining certain types of models layers. Not all of these rules may translate well LFP (due to the diverging goals of explaining training, cf. Appendix A.5), or they might require non-trivial adaptations. Further LFP-rules for BatchNorm layers and transformer architectures (ef. Achtibat et al. (2024) and Appendix A.9) nevertheless seem worthwhile to explore in follow-up works, as they would enable the application of LFP to a wider range of architectures and state-of-the- settings, In this work, we utilize LRP to obtain local rewards for the update in Equation 4. Exploration into alternative sources for this local reward seems promising, e.g. ones that do not rely on a backward pass, especially for training efficiency SNN-applications. Similarly, we investigate LFP in-depth for supervised classification in this In the future, exploration of other learning problems (such as regression, ef. Appendix A.8) and comparison with larger number of training techniques would be interesting, especially in the context of reinforcement learning, which LFP is related to. We furthermore leave in-depth investigation of additional hyperparameters, e.g., the choice of or thorough exploration of potential reward functions to future research.
Acknowledgments
This work was supported by the European Union's Horizon Europe research and innovation programme (EU Horizon Europe) as grants [ACHILLES 189689). TEMA (101093003);; and the European Union's 's Horizon 2020 research and innovation programme (EU Horizon 2020) as grant iToBoS (965221).
This work was further supported by the Federal Ministry of Education and Research (BMBF) as grant BIFOLD (01IS18025A) 01IS180371I) and the German Research Foundation (DFG) research unit DeSBi [KI-FOR 5363] (459422098). This research project is supported by the National Research Foundation, Singapore and Infocomm Media Development Authority under its Trust Tech Funding Initiative. Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not reflect the views of National Research Foundation, Singapore and Infocomm Media Development Authority.
References
Reduan Achtibat, Maximilian Dreyer, Ilona Eisenbraun. Sebastian Bosse, Thomas Wiegand, Wojeiech Samek, and Sebastian Lapuschkin. From attribution maps to human-understandable explanations through concept relevance propagation. Nature Machine Intelligence, 5(9): 2023.
Reduan Achtibat, Sayed Mohammad Vakilzadeh Hatefi, Maximilian Dreyer, Aakriti Jain, Thomas Wiegand, Sebastian Lapuschkin, and Wojciech Samek. AttnLRP: Attention-aware aware layer-wise relevance propagation for transformers. In Ruslan Salakhutdinov, Zico Kolter, Katherine Heller, Adrian Weller, Nuria Oliver, Jonathan Scarlett, and Felix Berkenkamp (eds.), Proceedings of the 41 International Conference on Machine Learning, ICML 2024, volume 235 of Proceedings of Machine Learning Research, pp. 135-168. PMLR, 21-27 Jul 2024.
Christopher Anders, David Neumann, Wojeiech Samek, Klaus-Robert Müller, and Sebastian Lapuschkin. Software for dataset-wide xai: From local explanations to global insights with Zennit, CoRelAy, and ViRelAy. CORR, abs/2106.13200 2021.
Lei Jimmy Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. CoRR, abs/ (bb//6607.06400, 2016.
Sebastian Bach, Alexander Binder, Grégoire Montavon, Frederick Klauschen, Klaus-Robert Müller, and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PLoS ONE, 10(7):0130140, 2015.
David Baehrens, Timon Schroeter, Stefan Harmeling, Motoaki Kawanabe, Katja Hansen, and Müller. How explain individual classification decisions. Journal of Machine Learning Research, 11:1803-1831 2010.
22

---

Published in Transactions on Machine Learning Research (06/2025)
Andrew G. Barto and Thomas G. Dietterich. Reinforcement learning and its relationship to supervised learning. Handbook of Learning and Approximate Dynamic P Programming, 10:9780470544785, 2004.
Sergey Bartunov, Adam Santoro, Blake A. Richards, Luke Marris, Geoffrey E. Hinton, and Timothy P. Lillicrap. Assessing the scalability of biologically-motivateed deep learning algorithms and architectures. In Samy Bengio, Hanna M. Wallach, Hugo Larochelle, Kristen Grauman, Nicolò Cesa- Bssa-Bianchi, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 31: Anmual Conference on Neural Information Processing Systems 2018, NeurlPS 2018, December 3-8, 2018, Montréal, Canada, pp. 9390-9400, 2018
David Bau, Bolei Zhou, Aditya Khosla, Aude Oliva, and Antonio Torralba. Network dissection: Quantifying inter- pretability of deep visual representations. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, pp. 3319-3327, IEEE Computer Society, 2017.
Daniel Becking, Maximilian Dreyer, Wojeiech Samek, Karsten Müller, and Sebastian Lapuschkin. ECQ*: Explainability- driven quantization for low-bit and sparse dnns. In Andreas Holzinger, Randy Goebel, Ruth Fong, Taesup Moon, Klaus-Robert Müller, and Wojeiech Samek (eds.), xxAI - Beyond Explainable Al - International Workshop, Held in Conjunction with ICML 2020, volume 13200 of Lecture Notes in Computer Science, pp. 271-296. Springer, 2022.
Yoshua Bengio, Thomas Mesnard, Asja Fischer. Saizheng Zhang, and Yuhuai Wu. Stdp presynaptic activity times rate of change of postsynaptic activity. CoRR, abs/1509.0588 2015.
Usha Bhalla, Alex Oesterling. Suraj Srinivas. Flávio Calmon, and Himabindu Lakkaraju. Interpreting CLIP with sparse linear concept embeddings (splice). In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomezak, and Cheng Zhang (eds.), Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems 2024, NeurlPS 2024, Vancouver, BC, Canada, December 10- 15, 2024, 2024.
Giovanni Briganti and Olivier Le Moine. Artificial intelligence in medicine: today and tomorrow. Frontiers in Medicine, 7:509744, 2020.
Andy Brock, Soham De, Samuel L. Smith, and Karen Simonyan. without normalization. In Marina Meila and Tong Zhang (eds.), Proceedings of the 38th International Conference Muchine Learning, ICML 2021, volume 139 of Proceedings of Machine Learning Research, pp. 1059-1071. PMLR, 2021.
large-scale image recognition
Joachim Buhmann and Klaus Schulten. Influence of noise on the function of a "physiological" neural network. Biological cybermetics, 5665):313-327, 1987.
Miguel Á. CCarreir-PPerpinal and Weiran Wang. Distributed optimization of deeply nested systems. Proceedings of the Seventeenth International Conference on Artificial Intelligence and Statistics, AISTATS 2014, volume 33 of JMLR Workshop and Conference Proceedings, pp. 10-19. JMLR.org, 2014.
Shiming Chen, Wenjie Wang, Beihao Xia, Xinge You, Qinmu Peng, Zehong Cao, and Weiping Ding. CDE-GAN: cooperative dual evolution- based generative adversarial network. IEEE Trans. Evol. Comput., 2565):98610000, 2021.
Paul F. Christiano, Jan Leike, Tom B. Brown, Miljan Martic, Shane Legg, and Dario Amodei. Deep reinforcement learning from human preferences. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio. Hanna M. Wallach, Rob Fergus, V. N. Vishwanathan, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems, NIPS 2017, pp. 4299-4307, 2017.
Djork-Amé Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network learning by expo- nential linear units (elus). In Yoshua Bengio and Yann LeCun (eds.), 4th International Conference on Learning Representations, ICLR 2016, 2016.
Noel C. F. Codella, David A. Gutman, M. Emre Celebi, Brian Helba, Michael A. Marchetti, Stephen W. Dusza, Aadi Kalloo, Konstantinos Liopyris, Nabin K. Mishra, Harald Kittler, and Allan Halpern. Skin lesion analysis toward melanoma detection: A challenge at the 2017 international symposium on biomedical imaging (isbi), hosted by the international skin imaging collaboration (ISIC). In 15th IEEE International Symposium on Biomedical Imaging, ISBI 2018, pp. 168-172. IEEF, 2018
23

---

Published in Transactions on Machine Learning Research (06/2025)
Mare Combalia, Noel C. F. Codella, Veronica Rotemberg, Brian Helba, Verónica Vilaplana, Ofer Reiter, Allan C. Halper, Susana Puig, and Josep Malvehy. BCN20000: dermoscopic lesions in the wild. CoRR, abs/1908.02288, 2019.
Peiyu Cui, Boris Shabash, and Kay C. Wiese. Evodnn an evolutionary deep neural network with heterogeneous activation functions. In IEEE Congress on Evolutionary Computation, CEC 2019, pp. 2362-2369. IEEE, 2019.
AV Demidovskij, MS Kazyulina, IG Salnikov, AM Tugaryov, Al Trutnev, and SV Pavlov. Implementation challenges and strategies for hebbian learning in convolutional neural networks. Optical Memory and Neural Networks, 32 (Suppl 2):5252-$264, 2023.
Georgios Detorakis, Travis Bartley, and Emre Neftci. Contrastive hebbian learning with random feedback weights. Neural Nenworks, 11::1-14, 2019.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In 9th International Conference on Learning Representattonss ICLR 2021. OpenReview.net, 2021.
Maximilian Dreyer, Jim Berend, Tobias Labarta, Johanna Vielhaben, Thomas Wiegand, Sebastian Lapuschkin, and Woj- ciech Samek. Mechanistic understanding and validation of large AI models with semanticlens. CoRR, abs/2501.0553 2025.
Russell Eberhart and James Kennedy. A new optimizer using particle swarm theory. In 95 Proceedings of the sixth international symposium on micro machine and human science, pp. 39-43, Icce, 1995.
Sami Ede, Serop Baghdadlian, Leander Weber, An Nguyen, Dario Zanca, Wojciech Samek, and Sebastian Lapuschkin. Explain to not forget: Defending against catastrophic forgetting with XAL. In Andreas Holzinger, Peter Kieseberg, A Min Tjoa, and Edgar R. Weippl (eds.), Machine Learning and Knowledge Extraction 6th IFIP TC TC 12, WG 8.4, WG 8.9, WG 12.9 International Cross-Domain Conference, CD-MAKE 2022, volume 13480 of Lecture Notes in Computer Science, pp. 1-18. Springer, 2022.
Stefan Elfwing, Biji Uchibe, and Kenji Doya. Sigmoid-weighted linear units for neural network function approximation in reinforcement learning, Neural Nenworks, 107:3-11, 2018
Maxence Ernoult, Julie Grollier, Damien Querlioz, Yoshua Bengio, and Benjamin Scellier. Updates of equilibrium prop match gradients of backprop through time in an RNN with static input. In Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d' Alché-Buc, Emily B. Fox, and Roman Garnett (eds.), Advances in Neural Informa- tion Processing Systems 32: Annual Conference Neural Information Processing Systems 2019, NeurlPS 2019, December 8- 14, 2019, Vancouver, BC, Canada, pp. 7079-7089, 2019.
Maxence Emoult, Fabrice Normandin, Abhinav Moudgil, Sean Spinncy, Eugene Belilovsky, Irina Rish, Blake A. Richards, and Yoshua Bengio. Towards scaling difference target propagation by learning backprop targets. In Kamalika Chaudhuri, Stefanie Jegelka, Le Song, Csaba Szepesvári, Gang Niu, and Sivan Sabato (eds.), International Conference on Machine Learning, ICML 2022, 17-23 July 2022, Baltimore, Maryland, USA, volume 162 of Proceedings of Machine Learning Research, pp. 5968-5987. PMLR, 2022.
Jason Kamran Eshraghian, Max Ward, Emre Neftci, Xinxin Wang, Gregor Lenz, Girish Dwivedi, Mohammed Ben- namoun, Doo Seok Jeong, and Wei D. Lu. Training spiking neural networks using lessons from deep learning. CoRR, abs/2109. 2021.
Wei Fang, Zhaofei Yu, Yanqi Chen, Timothée Masquelier, Tiejun Huang, and Yonghong Tian. Incorporating learnable membrane time constant to enhance learning of spiking neural networks. In 2021 IEEE/CVF International Conference on Computer Vision, ICCV 2021, Montreal, QC, Canada, October 10-17, 2021, pp. 2641-2651 IEEE, 2021.
Thomas Fel, Thibaut Boissin, Victor Boutin, Agustin Martin Picard, Paul Novello, Julien Colin, Drew Linsley, Tom Rousseau, Rémi Cadène, Laurent Gardes, and Thomas Serre. Unlocking feature visualization for deeper networks with magnitude constrained optimization. CoRR, abs/2306.06805, 2023a.
24

---

Published in Transactions on Machine Learning Research (06/2025)
Thomas Fel, Agustin Martin Picard, Louis Béthune, Thibaut Boissin, David Vigouroux, Julien Colin, Rémi Cadène, and Thomas Serre. CRAFT: concept recursive activation factorization for explainability. In JEEE/CVE Conference Computer Vision and Pattern Recognition, CVPR 2023, Vancouver, BC, Canada, June 17-24, 2023, pp. 2711-2721. IEEE, 2023b.
Ruth C. Fong and Andrea Vedaldi. Interpretable explanations of black boxes by meaningful perturbation. In IEEE International Conference on Computer Vision, ICCV 2017, pp. 3449-3457. IEEE Computer Society, 2017.
Nicolas Frémaux and Wulfram Gerstner. Neuromodulated beneeetiminnddepeeneee plasticity, and theory of three-factor learning rules. Frontiers neural circuits, 9:85, 2016.
Hiroshi Fukui, Tsubasa Hirakawa, Takayoshi Yamashita, and Hironobu Fujiyoshi. Attention branch network: Learning attention mechanism for visual explanation. In JEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, pp. 10714. Computer Vision Foundation IEEE, 2019.
Mohammadnavid Ghader, Saeed Reza Kheradpisheh, Bahareh J. Farahani, and Mahmood Fazlali. Backpropagation-free spiking neural networks with the forward-forward algorithm. CoRR, abs/2502.20411, 2025.
Tom Goldstein, Brendan O'Donoghue, Simon Setzer, and Richard G. Baraniuk. Fast alternating direction optimization methods. SIAM J. Imaging Sci., 703)1188-1623,, 2014.
Liv Gorton. The missing curve detectors of inceptionv 1: Applying sparse autoencoders to inceptionvl early vision. CoRR, abss/2406003662. 2024.
Manas Gupta, Arulmurugan Ambikapathi, and Savitha Ramasamy. Hebbnet: simplified hebbian learning framework to do biologically plausible learning. In IEEE International Conference Acoustics, Speech and Signal Processing, ICASSP 2021, Toronto, ON. Canada, June 6-11, 2021, pp. 3115-3119, IEEE, 2021.
Song Han, Jeff Pool, John Tran, and William J. Dally. Learning both weights and connections for efficient neural network. In Corinna Cortes, Neil D. Lawrence, Daniel D. Lee, Masashi Sugiyama, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 28: Anmual Conference on Neural Information Processing Systems, NIPS 2015, pp. 1135-1143, 2015.
Sayed Mohammad Vakilzadeh Hatefi, Maximilian Dreyer, Reduan Achtibat, Thomas Wiegand, Wojciech Samek, and Sebastian Lapuschkin. Pruning by explaining revisited: Optimizing attribution methods to prune cnns and transformers. CoRR, abs/2400.12268. 2024.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Puttern Recognition, CVPR 2016, pp. 770-778. IEEE Computer Society, 2016.
Donald O. Hebb. The organization of behavior: A neuropsychological theory. June 1949.
Geoffrey E. Hinton. The forward-forward algorithm: Some preliminary investigations. CoRR, abs/2212.113345, 2022.
Fred Hohman, Haekyu Park, Caleb Robinson, and Duen Horng (Polo) Chau. Summit: Scaling deep learning in- terpretability by visualizing activation and attribution summarizations, JEEE Trans. Vis. Comput. Graph., 26(1); )): 1096-1106, 2020.
Jie Hu, Rongrong Ji, Qixiang Ye, Tong Tong, Shengehuan Zhang, Ke Li, Feiyue Huang, and Ling Shao. Architecture disentanglement for deep neural networks. CoRR, abs/2003. 132668 2020.
Robert Huben, Hoagy Cunningham, Logan Riggs, Aidan Ewart, and Lee Sharkey. Sparse autoencoders find highly interpretable features in language models. The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024.
Niall P. Hurley and Scott Rickard. Comparing measures of sparsity. IEEE Trans. Inf. Theory, 55(10):473 4741, 2009.
25

---

Published in Transactions on Machine Learning Research (06/2025)
Sergey loffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Francis R. Bach and David M. Blei (eds.), Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, volume 37 of JMLR Workshop and Conference Proceedings, pp. 448-456. JMLR, 2015.
Adrien Journé, Hector Garcia Rodriguez, Qinghai Guo, and Timoleon Moraitis. Hebbian deep learning without feedback. In The Eleventh International Conference on Learning Representations, ICLR 2023, Kigali, Rwanda, May 1-5, 2023. OvenReview.net, 2023.
Jacques Kaiser, Hesham Mostafa, and Emre Neftci. Synaptic plasticity dynamics for deep continuous local learning (decolle). Frontiers in Neuroscience, 14:424, 2020.
Been Kim, Martin Wattenberg, Justin Gilmer, Carrie J. Cai, James Wexler, Fernanda B. Viégas, and Rory Sayres. Inter- pretability beyond feature attribution: Quantitative testing with concept activation vectors (TCAV). In Proceedings of the 35th International Conference on Machine Learning. ICML 2018, volume 80 of Proceedings of Machine Learning Research, pp. 2673-2682. PMLR, 2018.
Jangho Kim, KiYoon Yoo, and Nojun Kwak. Position-based scaled gradient for model quantization and pruning. In Hugo Larochelle, Marc' Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.). Advances Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, 2020.
Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Yoshua Bengio and Yann LeCun (eds.), 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA. May 7-9, 2015, Conference Track Proceedings, 2015.
Maximilian Kohlbrenner, Alexander Bauer, Shinichi Nakajima, Alexander Binder, Wojeiech Samek, and Sebastian Lapuschkin. Towards best practice in explaining neural network decisions with LRP. In 2020 International Joint Conference on Neural Networks, IJCNN 2020, pp. 1-7. IEEE, 2020.
Matthew Kowal, Achal Dave, Rares Ambrus, Adrien Gaidon, Konstantinos G. Derpanis, and Pavel Tokmakov. Un- derstanding video transformers via universal concept discovery. In IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2024, Seattle, WA, USA, June 16-22, 2024, pp. 10946-10956. IEEE, 2024.
Alex Krizhevsky. Learning multiple layers of features from tiny images. Master's thesis, University of Toronto, Department of Computer Science, 2009.
Axel Laborieux, Maxence Ernoult, Benjamin Scellier, Yoshua Bengio, Julie Grollier, and Damien Querlioz. Scaling equilibrium propagation to deep convnets by drastically reducing its gradient estimator bias. CoRR, abs/2101.05536, 2021.
Gabriele Lagani, Fabrizio Falchi, Claudio Gennaro, and Giuseppe Amato. Comparing the performance of hebbian against backpropagation learning using convolutional neural networks. Neural Comput. Appl., 34(3))6503-6519, 2022.
Jérémic Laydevant, Danijela Marković, and Julie Grollier. Training an ising machine with equilibrium propagation. volume 15, pp. 3671. Nature Publishing Group UK London, 2024.
Yann Le Cun. Learning process in an asymmetric threshold network. Disordered systems and biological organization, pp. 233-240. Springer, 1986.
Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proc. IEEE, 86 (6(11))2278-224 1998.
Mong-HYunn Lee, Saizheng Zhang, Asja Fischer, and Yoshua Bengio. Difference target propagation. In Annalisa Appice, Pedro Pereira Rodrigues, Vitor Santos Costa, Carlos Soares, João Gama, and Alípio Jorge (eds.). Machine Learning and Knowledge Discovery Databases European Conference, ECML PKDD 2015, Porto, Portugal, September 7-11, 2015, Proceedings, Part I, volume 9284 of Lecture Notes in Computer Science, pp. 498-515. Springer, 2015.
26

---

Published in Transactions on Machine Learning Research (06/2025)
Jin Ha Lee, Ik hee Shin, Sang gu Jeong. Seung-Hk Ik Lee, Muhamamad Zaigham Zaheer, and Beom-Su Sco. Improvement in deep networks for optimization using explainable artificial intelligence. In 2019 International Conference on Information and Communication Technology Convergence, ICTC 2019, pp. 525-530. IEEE, 2019.
Simon Letzgus, Patrick Wagner, Jonas Lederer, Wojciech Samek, NobustRobert Müller, and Grégoire Montavon. Toward explainable artificial intelligence for regression models: A methodological perspective. IEEE Signal Process. Mag., 39(4):40-58, 2022.
Timothy P Lillicrap, Daniel Cownden, Douglas B Tweed, and Colin Akerman. Random synaptic feedback weights support enror backpropagation for deep learning. Nature communications, 7(1):13276, 2016.
Scott M. Lundberg and Su-In Lee. unified approach to interpreting model predictions. In Isabelle Guyon, Ulrike von Luxburg, Samy Bengio, Hanna M. Wallach, Rob Fergus, S. V. Vishwanathan, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 30: Annual Conference Neural Information Processing Systems, NIPS 2017, pp. 4775-4774, 2017.
Wolfgang Maass. Networks of spiking neurons: The third generation of neural network models. Neural Networks, 10 19):1699-1671, December 1997. ISSN 0893-6080.
Erwann Martin, Maxence Emoult, Jérémie Laydevant, Shuai Li, Damien Querlioz, Teodora Petrisor, and Julie Grollier. Eqspike: spike-driven equilibrium propagation for neuromorphic implementations. volume 24. Elsevier, 2021.
Thomas Miconi. Hebbian learning with gradients: Hebbian convolutional neural networks with modern deep learning frameworks. CoRR, abs/2107.01729 2021.
Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin A. Riedmiller. Playing atari with deep reinforcement learning. CoRR, abss/132..502. 2013.
Grégoire Montavon, Sebastian Lapuschkin, Alexander Binder, Wojeiech Samek, and Klaus- Müller. Explaining nonlinear classification decisions with deep taylor decomposition. Pattern Recognition, 65:211-222 2017.
Grégoire Montavon, Alexander Binder, Sebastian Lapuschkin, Wojeiech Samek, and Claus-Robert Müller. Layer-wise relevance propagation: An overview. In Wojciech Samek, Grégoire Montavon, Andrea Vedaldi, Lars Kai Hansen, and Klaus-Robert Müller (eds.), Explainable AI: Interpreting, Explaining and Visualizing Deep Learning, volume 11700 of Lecture Notes in Computer Science, pp. 193-209. Springer, 2019.
Franz Motzkus, Leander Weber, and Sebastian Lapuschkin. Measurably stronger explanation reliability via model canonization. In 2022 IEEE International Conference on Image Processing, ICIP 2022, Bordeaux, France, 16-19 October 2022, pp. 516-520. IEEE, 2022.
Javier R Movellan. Contrastive hebbian learning in the continuous hopfield model. In Connectionist models, pp. 10-17. Elsevier, 1991.
Milad Mozafari, Saced Reza Kheradpisheh, Timothée Masquelier, Abbas Nowzari- Nowzari-Dalini, and Mohammad Ganjtabesh. first-spike-based visual categorization using reward-modulated STDP. IEEE Trans. Neural Networks Learn. Syst., 99(12):6178-6199 2018.
Vineel Nagisetty, Laura Graves, Joseph Scott, and Vijay Ganesh. xAI-GAN: Enhancing Generative Adversarial Networks via Explainable AI Systems. CoRR, 10438 2020.
Arild Nøkland. Direct feedback alignment provides learning in deep neural networks. In Daniel D. Lee, Masashi Sugiyama, Ulrike Luxburg, Isabelle Guyon, and Roman Gareett (eds.), Advances in Neural Information Processing Systems 29; Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pp. 1037-1045, 2016.
Erkki Oja. Neural networks, principal components, and subspaces. lnt. J. Neural Syst., 1(1):61-68, 1989.
27

---

Published in Transactions on Machine Learning Research (06/2025)
Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul F. Christiano, Jan Leike, and Ryan Lowe. Training language models to follow instructions with human feedback. In Sanmi Koyejo, S. Mohamed, A. Agarwal, Danielle Belgrave, K. Cho, and A. Oh (eds.), Advances Neural Information Processing Systems 35; Annual Conference on Neural Information Processing Systems 2022, NewrIPS 2022, 2022.
Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Edward Z. Yang, Zachary De Vito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d' Alché-Buc, Emily Fox, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurlPS 2019, pp. 8024-8004000 8035, 2019.
Michael Pfeiffer and Thomas Pfeil. Deep Learning With Spiking Neurons: Opportumities and Challenges. Frontiers in Neuroscience, 12, 2018. ISSN 1662-453X.
Filip Ponulak and Andrzej Kasinski. Introduction to spiking neural networks: Information processing, learning and applications. Acta Neurobiologiae Experimentalis, 7144):409-433, 2011. ISSN 1689-0035.
Isabella Pozzi, Sander M. Bohté, and Pieter R. Roelfsema. Attention-gated brain propagation: How the brain can imple- ment reward- basedd error backpropagation. In Hugo Larochelle, Marc" Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.), Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurlPS 2020, 2020.
Marco T. Ribeiro, Sameer Singh, and Carlos Guestrin. "why should I trust you?": Explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD International Conference Knowledge Discovery and Data Mining, SIGKDD 2016, pp- 1135-11444 ACM, 2016.
Robin Rombach, Andreas Blattmann, Dominík Lorenz, Patrick Esser, and Björn Ommer. High-resolution image synthesis with latent diffusion models. In IEEE/CVE Conference on Computer Vision and Puttern Recognition, CVPR 2022, pp. 10674-10685 IEEE, 2022.
Vincent Roulet and Zaid Harchaoui. Target propagation via regularized inversion for recurrent neural networks. Trans. Much. Learn. Rex., 2023, 2023.
David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Williams. Learning internal representations by error propagation. Technical report, California Univ San Diego La Jolla Inst for Cognitive Science, 1985.
Muhammad Sabih, Frank Hannig, and Jürgen Teich. Utilizing explainable AI for quantization and pruning of deep neural networks. CoRR, abs/2008.0909 00902, 2020.
Tim Salimans, Jonathan Ho, Xi Chen, and Ilya Sutskever. Evolution strategies as a scalable alternative to reinforcement learning. CoRR, abs/1 703.0036433 2017.
Andrew P. Sansom. Torch PSO, 8 2022.
Shibani Santurkar, Andrew Ilyas, Dimitris Tsipras, Logan Engstrom, Brandon Tran, and Aleksander Madry. Image synthesis with single (robust) classifter. In Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d' Alché-Bue, Emily B. Fox, and Roman Gamett (eds.), Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, pp. 1260-1271, 2019.
Benjamin Scellier and Yoshua Bengio. Equilibrium propagation: Bridging the gap between energy- models and backpropagation. Frontiers Comput. Neurosci., 11:24, 2017.
Dominik Schiller, Tobias Huber, Florian Lingenfelser, Michael Dietz, Andreas Seiderer, and Elisabeth André. Relevance- based feature masking: Improving neural network based whale classification through explainable artificial intelligence. In Gernot Kubin and Zdravko Kacic (eds.), 20th Annual Conference of the International Speech Communication Association, Interspeech 2019., pp. 2423-24422 2427.2427. ISCA, 2019.
28

---

Published in Transactions on Machine Learning Research (06/2025)
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. CoRR, abs/1707.06233 707.06347, 2017.
H. Sebastian Seung. Learning in spiking neural networks by reinforcement of stochastic synaptic transmission. Neuron, 40(6):0063-1073, 2003.
Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In Proceedings of the 34th International Conference on Machine Learning, ICMI. 2017, volume 70 of Proceedings of Machine Learning Research, pp. 3145-3153. PMLR, 2017.
Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409. 1556, 2014.
Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. CoRR, abs/1312.6034, 2013.
Manjot Singh, Adalbert Fono, and Gitta Kutyniok. Expressivity of spiking neural networks through the spike response model. In UniReps: the First Workshop on Unifying Representations Neural Models, 2023.
Leslie N. Smith and Nicholay Topin. Super-convergence: Very fast training of residual networks using large learning rates. CoRR, abs/ 700./7707771111 120, 2017.
Leslie N. Smith and Nicholay Topin. Super-convergence: Very fast training of neural networks using large learning rates. In Artificial intelligence and machine learning for multi-domain operations applications, volume 1006, pp. 369-386. SPIE, 2019.
Kimia Soroush, Mohsen Raji, and Behnam Ghavami. Compressing deep neural networks using explainable ai. In 13th International Conference on Computer and Knowledge Engineering, ICCKE 2023, pp. 636-641. IEEE, 2023.
Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin A. Riedmiller. Striving for simplicity: The all convolutional net. In Yoshua Bengio and Yann LeCun (eds.), 3rd International Conference on Learning Representations, ICLR 2015, 2015.
Erik Strumbelj and Igor Kononenko. Explaining prediction models and individual predictions with feature contributions. Knowledge and Information Systems, 41(3):647-665, 2014.
Felipe Petroski Such, Vashisht Madhavan, Edoardo Conti, Joel Lehman, Kenneth O. Stanley, and Jeff Clune. Deep neuroevolution: Genetic algorithms are a competitive alternative for training deep neural networks for reinforcement learning. CoRR, abs/1712.065677 2017.
Jiamei Sun, Sebastian Lapuschkin, Wojeiech Samek, Yunqing Zhao, Ngai-Man Cheung, and Alexander Binder. Explanation-guided training for cross-domain few-shot classification. In 25th International Conference on Pattern Recognition, ICPR 2020, pp. 7609-7616. IEEE, 2020.
Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In Proceedings of the 34th International Conference Machine Learning, ICML 2017, volume 70 of Proceedings of Machine Learning Research, pp- 3319-33133333 3328. PMLR, 2017.
Richard S. Sutton, David A. McAllester, Satinder Singh, and Yishay Mansour. Policy gradient methods for reinforcement learning with function approximation. In Sara A. Solla, Todd K. Leen, and Klaus-Robert Müller (eds.), Advances in Neural Information Processing Systems 12: 23th Annual Conference on Neural Information Processing Systems, NIPS 1999]. pp. 1057-1063. The MIT Press, 1999.
Hidenori Tanaka. Daniel Kunin, Daniel L. K. Yamins, and Surya Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. In Hugo Larochelle, Mare' Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.), Advances in Neural Information Processing Systems 33; Annual Conference on Neural Information Processing Systems 2020, NeurlPS 2020, 2020.
29

---

Published in Transactions on Machine Learning Research (06/2025)
Yu Tang, Zhigang Kan, Dequan Sun, Linbo Qiao, Jingjing Xiao, Zhiquan Lai, and Dongsheng Li. ADMMIRNN: Training RNN with stable convergence via an efficient ADMM approach. In Frank Huiter, Kristian Kersting, Jefrey Lijftijt, and Isabel Valera (eds.), Machine Learning and Knowledge Discovery in Databases European Conference, ECML PKDD 2020, volume 12458 of Lecture Notes in Computer Science, pp. 3-18. Springer, 2020.
Gavin Taylor, Ryan Burmeister, Zheng Xu, Bharat Singh, Ankit B. Patel, and Tom Goldstein. Training neural networks without gradients: A scalable ADMM approach. In Maria-Florina Balcan and Kilian Q. Weinberger (eds.), Proceedings of the 33nd International Conference on Machine Learning, ICMI. 2016, volume 48 of JMLR Workshop and Conference Proceedings, pp. 2722-2731. 1.M-27.......000. JMLR.org, 2016.
Robun Tripathi and Bharat Singh. RSO: A gradient free sampling based approach for training deep neural networks. CoRR, abs/2005 0055005500555.... 2020.
Philipp Tschandl, Cliff Rosendahl, and Harald Kittler. The HAM10000 dataset: A large collection of multi-source dermatoscopic images of common pigmented skin lesions. CoRR, abs/ N001180311117 2018.
Twan van Laarhoven. L2 regularization versus batch and weight normalization. CoRR, abs/1706.05350, 2017. 2017
Johanna Vielhaben, Stefan Bluecher, and Nils Strodthoff. Multi-dimensional concept discovery (MCD): A unifying framework with completeness guarantees. Trans. Mach. Learn. Res., 2023, 2023.
Flena Voita, David Talbot, Fedor Moiseev, Rico Sennrihh, and Ivan Titov. Analyzing multi-head self-attention: Specialized heads do the heavy lifting, the rest can be pruned. In Anna Korhonen, David R. Traum, and Lluís Mårquez (eds.), Proceedings of the 57th Conference of the Association for Computational Linguisties, ACL 2019, pp. 5797-5808. Association for Computational Linguisties, 2019.
Catherine Wah, Steve Branson, Peter Welinder, Pietro Perona, and Serge Belongie. The caltech-uesd birds-200-201 dataset. Technical report, California Institute of Technology, Jul 2011.
Junxiang Wang, Fuxun Yu, Xiang Chen, and Liang Zhao. ADMM for efficient deep learning with global convergence. In Ankur Teredesai, Vipin Kumar, Ying Li, Rómer Rosales, Evimaria Terzi, and George Karypis (eds.). Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, pp. 111-119. ACM, 2019.
Junxiang Wang, Hongyi Li, and Liang Zhao. Accelerated gradient-free neural network training by multi-convex alternating optimization. Neurocomputing, 487:130-143, 2022.
Zhipeng Wang and Mingbo Cai. Reinforcement learning applied to single neuron. CoRR, Mas/1505.044 2015.
James C. R. Whittington and Rafal Bogacz. An approximation of the error backpropagation algorithm in a predictive coding network with local hebbian synaptic plasticity. Neural Comput., 29(5): 1ee1112222222 1262, 2017.
Seul-Ki Yeom, Philipp Seegerer. Sebastian Lapuschkin, Alexander Binder, Simon Wiedemann, Klaus-Robert Müller, and Wojciech Samek. Pruning by explaining: A novel criterion for deep neural network pruning. Pattern Recognition, 115:107899, 2021.
Jinshan Zeng, Tim Tsz- Lau, Shaobo Lin, and Yuan Yao. Global convergence of block coordinate descent in deep learning. In Kamalika Chaudhuri and Ruslan Salakhutdinov (eds.), Proceedings of the 36th International Conference on Machine Learning, JCML 2019, volume 97 of Proceedings of Machine Learning Research, pp. 7313-7323. PMLR, 2019.
Ruihan Zhang, Prashan Madumal, Tim Miller, Krista A. Ehinger, and Benjamin I. P. Rubinstein. Invertible concept- based explanations for CNN models with non negatiee concept activation vectors. In Thirty-Fifthi AAAI Conference on Artificial Intelligence, AAAI 2021, Thirty-Thire Conference on Innovative Applications of Artificial Intelligence, IAAI 2021, The Eleventh Symposium on Educational Advances in Artificial Intelligence, EAAI 2021, Virtual Event, February 2-9, 2021, pp. 11682-11690. AAAI Press, 2021.
Luisa M. Zintgraf, Taco S. Cohen, Tameem Adel, and Max Welling. Visualizing deep neural network decisions: Predic- tion difference analysis. In 5th International Conference on Learning Representations, ICLR 2017. OpenReview.net, 2017.
30

---

Published in Transactions on Machine Learning Research (06/2025)
Andrea Zunino, Sarah Adel Bargal, Pietro Morerio, Jianming Zhang, Stan Sclaroff, and Vittorio Murino. Excitation dropout: Encouraging plasticity in deep neural networks. Int. J. Comput. Vis., 129(4):1139-1155, 2021.
Shiliang Zuo. Notes on worst-case inefficiency of gradient descent even in RR? CoRR, ubs/2008.07513,, 2020.
A Appendix
A.1 Proof-Of-Concept with Additional Activations
In Section 3.3 we demonstrated the convergence of LFP for Rel.U-activated models in toy settings. Here, we investigate the efficacy of LFP for training models with other activations of which several not piece-wise linear and thus not covered under Theorem 1.
We use the same experimental setup as for Figure (also ef. Section A.7.1), but insert an additional activation after the last linear layer. Otherwise, due to the simplicity the toy data, a learning algorithm may solve the given tasks while ignoring previous layers, and thus bypass activation functions that we vary in this experiment.
Results shown in Figure A.1. LFP generally results in the expected decision boundaries. Nevertheless, there is some variation between activation functions. Specifically for Heaviside, while the test accuracy is clearly better than random, and the model has clearly been somewhat optimized to solve the task, accuracy and resulting boundaries are considerably worse compared to other activation functions. Furthermore, during training, we observed high dependence on initialization for Heaviside-activated models - even in the simple toy settings considered here. We hypothesize that while the update signals are sensible, Heaviside activations make standard neural network training simply too unstable (but this may not be the case for other types of architectures). This corresponds well our results in Sections 3.5, 3.6, and 4.2.
LelkyRel..
Hlob Datawet
Cirele Datoset
06.9
0963
39.03
15.33
6855
Swirl Dattonee.
Figure A.1: Additional decision boundaries for the three toy datasets from Figure 3 with other, non-ReLU activation functions (also cf. Figure A. 11). The test accuracy of the corresponding model shown in the upper right corner of each plot. LFP able to train models with all of these activations not only the piece-wise linear ones covered by Theorem
31

---

Published in Transactions on Machine Learning Research (06/2025)
A.2 Proof of Theorem
Proof. In the interest of preciseness, let a denote the i-th neuron in the (-th layer of the network and wij [++]] the weight
corresponding to the connection of neuron a!" to dj af+"l, Similarly, ret denote the reward corresponding neuron d
and ri [[+]]] the reward corresponding to the weight at the connection of neuron a. !] to aj [++1]_ We show that the equation
11 = 3 da
Σ
dog re
(A.1)
10 Oc
holds for all hidden layers of the network by inverse induction from the last layer before the ouiput / = L to the first layer
= 1. For calculating the output activations Oc, we use a linear activation function s.t. Og = =[[+1]] E3 aj /. |+++]]
je
Hence
d
C
aj wo
14 1
10
do Te
Σ
14)
re
da
[1]]
Oe
daj 14
Oc
Ge [1+1]
Σ jj
||+ Te
[4]
ILtaj ro = =
[++1
For the induction step, assume now that the equality in Equation A.1 holds for layer 1 + 1. The following equation follows from the formula for relevance propagation:
[++1]
1 [++1]
Σ
ij 1+
11
|+11|
do
Te
[++]
1+1]
da
Oc
j
ReI.U(=
[+1]
do
re
a
|111]
Wij
da
[+1]
Oc
ag
|
Σ
1 1z2
[+1] > O)w
1+1]
dog
re
da
[+1]
1]
Oc
da [+1]]
Σ doc
|1|
Σ
do
a
da! (4)
datttl]
oe
da
[]]
Oe
Thus by induction Equation A.1 holds for all hidden layers 1. We apply Equation A. 1 to the formula for the reward [441) Fij
[++]] [++1]
[++|]
[++1]
w
a
ReLU(zft1)
[[+1]]
Σ
do. Te da
iig
=) [++1] rj
|+1|
U+11| dalft1l oe
2
|+1|| !1l
1
[[+1|
0) Σ do
myy a;
da
[+ll Or
[|+1] da [+1]]
do, Te
w.s !
1+
da
[++]]
[|+1]
doa
Ye
wij
[++]]
dwij
32

---

Published in Transactions on Machine Learning Research (06/2025)
Inserting the reward defined in the statement of the theorem, we derive the following form of the reward:
dc doc
[++1|
11-11
do
Or
rij w
duci dc
[+1
Oc
[1+1]
dw
[++1]
The update step of LFP in Equation is given by
1m
11+1 [+]]]
d w
2j [+]1
Im
+ |+1]]
1
[++1
w
[+1]]
11+11
|+11] [+11
[++]]
1
25
so the update is equivalent to weight-scaled gradient descent:
[++1] 3)
10
=
+ 17
w 1++1
w [++1
[++1]
[+-1]
kg
+ 17
kj
Wa [1+1]
[1+1
[++1] dc
17
w [++1]
wij
dw duob+11 [+1]
[I+1]
| 1]
dl
17
[++]]
du
Note that while we proved the statement for ReLU functions with linearly activated outputs, fact holds that for weight-scaled gradient descent with any activation function (x{2 LFP-0-reward with equivalent weight updates.
do)(2()
2/. Theorem yields an equivalent
dsf
A.3 LFP with Reward from Equation 17
While we observed reward #3 from Table 2 to converge well in our experiments, LFP can also backpropagate rewards that do not have a corresponding loss function in the sense of Theorem 1, such as non-differentiable rewards, and still converge. To shortly demonstrate this, we repeat the experiment from Figure on the first toy dataset ("Blob Dataset", cf. Appendix A.7.1) with the reward function from Equation 17.
As shown in Figure A.2, LFP is also able to converge in this setting under the right choice of hyperparameters (e.g., learning rate 3 4). However, training is comparatively unstable and highly dependent hyperparameters (cf. Figure 3, where training is far more stable and 100% accuracy is reached for more than one learning rate under the same conditions using different reward). As the reward from Equation 17 does not employ convergence mechanism and leverages less fine-grained information of the closeness of the prediction to the ground truth (cf. reward reward #3 from Table 2), this to be expected.
Nevertheless, this result shows that LFP converges in settings beyond those where it is equivalent weight-scaled gradient descent (cf. Theorem 1).
A.4 Differences between LFP and Gradient Descent Updates
Theorem indicates equivalence between LFP and gradient descent under specific conditions, that are generally not met in practice (e.g., utilize LFP-e, which violates one of the conditions). Here, show that if Theorem is not met,
33

---

Published in Transactions on Machine Learning Research (06/2025)
100
100
Test Aocuracy [%6]
80
LFP-8
Train Accuracy [%)
80
60
40
20
20
0-
0
10
10
10
10
102
25
50
75
LR
Iteration
Figure A.2: LFP with reward #2 from Table 2 on toy data ("Blob Dataset"). Middle: Test accuracies over learning rates. The marker denotes the best-performing setting. Left: Decision boundary for the best-performing setting. Right: Train accuracy over training iterations for the best pers-performing setting. While training seems unstable compared to e.g. the results of Figure 3, there exists a choice of hyperparameters where LFP using this reward solves the task well. Note that the reward used here does not have a corresponding loss function in the context of Theorem 1. Results are averaged over 5 randomly drawn instances of the toy data, with the shaded area showing the standard deviation across draws.
LFP employs fundamentally different update strategy, even extremely simple models. For instance, the condition of specific piece-wise linear activations is not met by the SiLU non-linearity.
For this reason, we train a SiLU-activated one-neuron model for 10 iterations on a single datapoint using both LFP and gradient descent, with the respective criterion aimed at either maximizing or minimizing the neuron's 's output. This mimicks the optimization of single neuron larger model, given all inputs and other parameters are kept constant. Weight initializations W1 (0.5, 0.5) and W2 = (-1. -1) are deliberately placed to evaluate the pre-activation to the right and left of the SiLU minimum for the single used datapoint, (1, For maximization, we use an L.P- Fewrrd of sign(o.) oz) (1 (o.)) and gradient descent loss of (logitts) For minimization, we use the respective negative criterion.
As shown by Figure A.3, weight updates of LFP do not follow the gradient when erossing into the decreasing area of the SiLU function (top). This is detrimental when optimizing for the minimum (top left), since the minimum is crossed as weights are constantly updated decrease the pre-activation output. However SiLU has an upper bound of zero with decreasing pre-activations, and consequence, the resulting error missing the minimum is negligible (cf. the minor decrease in reward). I.e., in the worst case, SiLU will evaluate to zero and the neuron will simply not contribute to the output anymore. On the other hand, when optimizing for the (infinite) maximum (top right), this interaction of LFP with SiLU has a positive effect, as the model is updated in the correct direction of the global maximum (towards positive pre-activations), no matter the initialization. Interestingly, we observe a similarly ambivalent behavior for gradient descent. Here, updates are performed in the theoretically correct direction of the function slope, and the correct minimum is found (bottom left), however, in the maximization task, the success of gradient descent is iniiaalization-deeendenn, with W2 becoming stuck in local optimum (bottom right).
Consequently, both learning algorithms follow different update strategies with their respective strengths and weaknesses in their interaction with SiLU, with LFP finding the correct but unreachable maximum, while gradient descent converges to the correct minimum.
A.5 A note on LRP-Rules
LFP utilizes LRP to propagate reward signals through the model. LRP introduces several specialized rules (Montavon et al., 2019; Achtibat et al., 2024) targeted at explaining specific types of layers architectures, c.g., distinguishing between positive and negative contributions. One may thus ask whether these rules can be extended to LFP as well. The goals of LFP (training) and LRP (explaining) are not the same. Therefore, while some underlying paradigms of LRP-rules, such as numerical stability (cf. Section 3.1.3) align between both goals and the corresponding rules consequently translate well to LFP, several others do not. For instance, distinguishing between positively and negatively contributing connections would lead updating those connections different degrees, potentially destabilizing training and resulting in suboptimal solutions. We therefore do not extend most of these rules LFP. Nevertheless, it may
34

---

Published in Transactions on Machine Learning Research (06/2025)
LEP Minimization
Minimum
LFP Maximization
Maximumee
4
Output
2-
2-
0
0-
Iteration
10
10
W2
W1
W2
07
-10
10
5
0
-10
-5
0
Pre-Activation Output
Pre-Activation Output
Gradient Descent- Minimization
Minimum
Gradient Descent Maximization
Maximum
4
4
Output
Activation
2
Criterion
2-
0-
0
Iteration
10
10
W2
W
10
0
-00
0
Pre-Activation Output
Pre-Activation Output
Figure A.3: Interaction of LFP (top) and gradient descent (bottom) with SiLU activation functions, shown toy model consisting of single, SiL-tactivated neuron trained on single datapoint as input. The task is to minimize (left) or maximize (right) the neuron output. The respective optimum is shown in green, the post-activation output in blue, and the respective criterion (reward or loss) in orange. Starting from two different weight initializations (W1 and W2), model updates over 10 iterations are shown in red, For LFP, when crossing into the area left of the SiLU minimum, weights are updated in the (theoretically) wrong direction. We observe, however, that this behavior can both detrimental (top left) and beneficial (top right) to finding the optimum. This non-monotoncous area can furthermore be detrimental to gradient descent well, depending the initialization (bottom right). We show in Table 3 that LFP is able to train SiLtivactd models without issue
make sense (or even be necessary in order to apply LFP to state-of-the-an art models) to develop completely new layer- or mechieecure-dependeett rules for I.P (e.g., see Section 3.1.4, Appendix A.9, as well as Achtibat et al. (2024)), however, we leave further research into this direction to future work.
A.6 Spiking Neural Networks
Spiking neural networks (SNNs) (Maass, 1997; Ponulak & Kasinski, 201 are special type of recurrent network built out of spiking neurons that model biological processing in real brains more closely than conventional neurons in DNNs. Spiking neurons have membrane potential U e R that dictates whether neuron sends out a discrete spike or remains inactive. The output of neurons in a SNN can be modeled using the Heaviside step function:
HUI - 0) -
ifU >
(A.2)
else
35

---

Published in Transactions on Machine Learning Research (06/2025)
where
U = 1] - - 0).
(A.3)
In Equation A.3, the hyperparameter 3 (0, controls the decay rate of the membrane potential, while 0 R represents the threshold that determines the membrane potential required for the neuron to fire. The matrix W represents the learnable parameters associated with the input connections from the preceding layer's output X X[4- The final term in Equation A.3 resets the membrane potential after the neuron fires. For further details, refer to Maass (1997) and Eshraghian et al. (2021).
A.7 Details Experiments
Of the experiments in this work, the ones in Sections 3.3, 3.4, and 3.6, as well as Appendix A.1, A.3, A.4, A.8, and A.9 ran on local machine, while all other experiments ran on an HPC Cluster.
The local machine used Ubuntu 20.04.6 LTS, an NVIDIA TITAN RTX Graphics Card with 24GB of memory, an Intel Xeon CPU E5-2687W V4 with 3.00GHz, and 32GB of RAM.
The HPC-Cluster used Ubuntu 18.04.6 LTS, an NVIDIA A100 Graphics Card with 40GB of memory, an Intel Xeon Gold 6150 CPU with 2.70GHz, and 512GB of RAM. Apptainer was used to containerize experiments on the cluster.
The code for all experiments was implemented in python, using PyTorch (Paszke al.. 2019) for deep learning, including weights available from torchvision, well as snnTorch (Eshraghian al., 2021) for SNN applications. matplotlib was used for plotting. The implementation of LFP builds upon zennit (Anders al., 2021) and LXT (Achtibat et al., 2024), two XAI-libraries.
Seeds were chosen using the SRANDOM shell command, and the following function was used to set them for the experiments:
import torch
2 import numpy
3 import
4 import random
5
def cet__randon__ee seeds (seed)
7
forch.manual.. (eenuull_seee__eeeee (seed)
8
forch.cuda..ie wadda.aanuall... seed seed(sed))
torch. wandddaamaa__eeeeeeeee (seed)
Ep. random, seed (seed)
random. seed
torch. manual __sedd (seed)
os. os.envirre ron PYTHHHHSSSSER ]=str
brrchhbacceddd.ccom www.bcdeedd...cd....boonnnreeeai bew.hmannbbchaak-aaaeeeee
16
torch. www.bbaccccccuu.ooooooe cudan. wtt.:nn.deeeermmiiiiieeeee.
17
barch.backende cudnn. www....nabeeeddee...... anabled-Fallln
A.7.1 Proof-of-Concept
Small ReLU-activated MLPs were trained on three toy datasets with LFP-s and reward #3 from Table (as well as stochastic gradient descent with categorical cross-entropy loss) using a batch-size of 128 and momentum of 0.95. The MLPs each consist three dense layers with 32, 16, and n neurons, respectively, and are visualized to the right of Figure 3. refers to the number of classes, which vary between and depending on the dataset. The models were trained for large number of different learning rates, chosen according the following formula: 10', with 3). We used the following toy datasets:
[1,2.... .... 10) and [-10, -9, ...,
Blob Dataset: 1000 training samples and 100 test samples were drawn using the scikit-learn function skdata. make_blobs with two classes, centered at [1, 1] and [2, 2]. respectively, and a cluster standard deviation of 0.2. Models were trained on this dataset for 10 epochs.
Circle Dataset: 10000 training samples and 500 test samples were drawn using the scikit-learn function skdataa. make_ cikeeee with two classes, using cluster standard deviation of 0.2 and a scale factor of 0.05. Models were trained this dataset for 10 epochs.
36

---

Published in Transactions on Machine Learning Research (06/2025)
Swirl Dataset: 10000 training samples and 500 test samples were drawn for three classes in the shape of a swirl, similar to the toy dataset used in Yeom et al. (2021). Models were trained on this dataset for 15 epochs.
Refer to the supplied code'! for more specifics on dataset generation. We did not employ seeding for this experiment but instead averaged all results over five different versions of each dataset.
For the results shown in Figure 4, we instead used a version of the Blob Dataset with classes centered at [-1, -1] and [1, 1]. respectively. We further employed single-neuron model without bias trained using either gradient descent and binary cross- cros--etropyy loss LFP-s and reward #4 from Table 2. We trained this model for one epoch using a learning rate of 0.5, batch size of 8, and no momentum. Initial weights were set manually at [0, 4]. [4, 0j. [2,4], [4, 2]. [-4, - -4,
[-4, 4]. and [4, -4] to cover some different proportions of W1 to W2 Results are shown for one seed only.
A.7.2 Computational Cost of LFP
We trained a small three-layer MLP and LeNet for 50 epochs on the MNIST dataset. The MLP consists of 120, 84 and 10 neurons, respectively. The LeNet utilizes two convolutional layers with 16 channels and kernel size of 5, followed by two maxpooling layers, respectively. For classification, three linear layers (120, 84, 10 neurons) with two 50% dropout layers between are used. Both models utilize ReLU activations, except for the last layer.
These models trained using the following methods and hyperparameters:
LFP-s. We utilize batch-size of 128, learning rates 0.1 and 0.01 for the MLP and LeNet, respectively, momentum of 0.9, an SGD optimizer and the reward #3 from Table 2.
Gradient Descent. We utilize a batch-size of 128, learning rates 0.1 and 0.01 for the MI.P and LeNet, respectively, a momentum of 0.9, an SGD optimizer and a categorical crossentropy loss.
Feedback Alignment. We adapt an implementation" of the original method Lillicrap et al. (2016) and utilize a batch-size of 128, learning rates 0.1 and 0.01 for the MLP and LeNet, respectively, momentum of 0.9, an SGD optimizer and a categorical crossentropy loss.
PSO. We adapt an implementation (Sansom, 2022)!3 13 of the original method (Eberhart & Kennedy, 1995) and utilize a batch-size of 1000, cognitive and social coefficients of 2, an inertial weight of 0.8, 1000 particles, a search space of [-0.1, 0.1] and categorical crossentropy loss as a measure of fitness. To encourage exploration, we decay cognitive and social coefficients in each particle by a factor of 0.95 for every iteration where the particle or swarm optimum, respectively, was not updated. Coefficients are reset to the initial value when an update occurs, to encourage search near the new optimum.
dIADMM. We utilize the implementation" 14 from the original paper Wang et al. (2019), only adapting the number of neurons in the MLP to match the MLP used in the other methods. An implementation compatible with the LeNet was not available.
A.7.3 Non-ReLU Activations
For this experiment, we applied LFP-c with reward #3 from Table 2 and stochastic gradient descent with categorical crossentropy loss to three different model architectures: randomly initialized "VGG-like" model, consisting of three convolutional blocks with two kernel-size 3 and stride convolutional layers and a kernel-size 2 and stride 2 max-pooling layer each, followed by three fully-connected layers with two 50% dropout layers in-between. In order, the convolutional layers have the following number of channels: 32, 64, 128, 128, 256, 256. The linear layers have the following number of neurons: 1024, 512, number of classes. We further used the VGG-16 (Simonyan & Zisserman, 2014 4) and ResNet-18 18 (He et al., 2016) models, initialized by ImageNet weights available in torchvision (Paszke et al., 2019).
Out of the above models, we trained the VGG-like model on the CIFAR1O and CIFARIO0 tasks (Krizhevsky, 2009) for 50 epochs with batch size of 128 using a one-cycle learning rate schedule (Smith & Topin, 2017) with a max learning
haw.ree----eileeeee------eeeeeee Layers
37

---

Published in Transactions on Machine Learning Research (06/2025)
rate of 0.1, and gradient (in this case reward) norm clipping with a max norm of 3. The VGG-16 and ResNet-118 models were trained on the Caltech-UCSD Birds-200-2011 (CUB) (Wah et al., 2011), ISIC 2019 (Tschandl et al., 2018; Codella et al., 2018; Combalia et al., 2019) skin lesion, and Food-11 classification datasets. Here, models were trained for 100 epochs with a batch size of 32, employing the one-cycle learning rate schedule (Smith & Topin, 2019) with a max learning rate of le- (exeept for VGG-16 on Food-11, which performed better with a max learning rate of le te="), and a weight decay of 1e-4.
All models were trained multiple times, with ReLU, SiLU (Elfwing al., 2018), ELU (Clevert et al., 2016), Tanh, Sigmoid, and Heaviside step functions for hidden layer activations. Results averaged over three randomly generated seeds.
For more details regarding data and training hyperparameters, please refer to the supplied code.
A.7.4 Application 1: Sparse and Prunable Models
For this experiment, we utilized the same datasets as detailed in Appendix A.7.3: Non-ReLU Activations. In addition to the models used in Appendix A.7.3: Non-ReLU Activations (only the ReLU-activated versions), we also employed ResNet-32 (He et al., 2016) and VGG-16 with BatchNorm (VGG-16-2
(Simonyan & Zisserman, 2014) for the CUB, ISIC2019, and Food-11 11 datasets. To these, we applied LFP-c with reward #3 from Table 2 and stochastic gradient descent with categorical crossentropy loss. We further used the same training setups as in Appendix A.7.3: Non-ReLU Activations, except for slightly different learning rates: On both CIFARIO and CIFARI00, we trained with max learning rate of 0.1. For VGG-16 and VGG-I6-BN, we used max learning rate of 1e-3 and for ResNet-18 and ResNet-32, a max learning rate of 5
For visualizing the weight distributions in Figures 7, A.6, A.7, and A.8, we first apply BatchNorm canonization as described below, and then divide the unsigned weights by their maximum value.
For pruning, we only consider methods without subsequent re-training or fine-tuning of the model and always prune given percentage of connections (as opposed to, e.g., pruning all connections with some importance score below a given threshold). We only consider unstructured pruning, and only apply pruning convolutional layers, done by Yeom et al. (2021). We also canonize all BatchNorm layers into the preceding convolutional layers before computing pruning criteria (resulting in functionally equivalent model), for two reasons: firstly, to be able to correctly apply the relevance-based pruning criterion (Yeom et al., 2021), and secondly, to be able to apply the global magnitude-based pruning criterion, since BatchNorm layers can lead to arbitrary weight magnitudes in the preceding layer as they are invariant to weight scale (van Laarhoven, 2017). To determine the pruning criterion, we applied the following algorithms:
Magnitude-bused Pruning: Here, connections are simply pruned based on the magnitude of their weights, similar to Han et al. (2015). It is assumed that the lowest magnitude weights are the least important, and consequently, they are removed first. We consider both local and global variants of magnitude-basse pruning. The former applies the pruning criterion wiser-wiee, removing the same percentage of connections from each layer at each pruning step. The latter considers all layers at the same time when computing the pruning criterion, removing a percentage of connections from the whole model at each pruning step. Global pruning usually performs better but can lead to layer collapse (Tanaka et al., 2020).
Relevance-based Pruning: As suggested by Yeom al. (2021), we also apply global Sievaance-based pruning criterion. Specifically, we apply LRP-s to the model (this is different to Yeom et al. (2021), who use LRP-> summing relevances of each connection across the whole test dataset. The absolute summed relevance of each connection is used as a criterion for pruning.
All results in this experiment are averaged over three randomly generated seeds. For more details regarding data, training, and pruning hyperparameters, please refer to the supplied code.
A.7.5 Application 2: Spiking Neural Networks
For the results in Figure 9, LeNet and multilayer perceptron (MLP) architectures were trained on the MNIST dataset (LeCun et al., 1998) for image classification. The LeNet architecture comprised two successive convolution blocks
htt 15ttpp:// e. coom//aaaett//veeeeeeeee 1
38

---

Published in Transactions on Machine Learning Research (06/2025)
followed by final MLP block. Each convolution block contained convolution layer (12 and 64 channels, respectively)
with 5x5 kernels, stride 1, and no input padding. These were followed by max-pooling layers (2x2 kernels, stride 2) and Leaky Integrate-and and-Fire (LIF) activation functions (described in Equation A. A.2-Equation A.3). The final MLP classification block consisted of dense layer with 1,024 LIF neurons, followed by another LIF non-linearity. The MLP architecture consisted of three dense layers each followed by the LIF non-linearity. The dimension of the hidden layers was set to 1,000.
For the LIFs activation function, we adapted the implementation from Eshraghian et al. (2021). To enable gradient-based training, employed surrogate function R + R in the backward pass, defined as:
s(x)
1 25 x
We furthermore used a fixed LIF threshold of 0=1 and varying the decay factor 3 to values of 0.3, 0.6, and 0.9. The sequence length L was varied across 5, 15, and 25 time steps. Both networks were trained for three epochs using a batch size of 128. For optimization, we used the stochastic gradient descent algorithm. Learning rates of 10-3, 10-2, 5 10 7.5 10-2, 0.1, 0.25, 0.5 and 0.8 were investigated combination with the see-cycle-Ir-scheduue proposed in Smith & Topin (2019). For stability, in this experiment, the backward pass was normalized by the maximum absolute utilized the adaptive gradient clipping strategy proposed in Brock et al. (2021). The experiments were performed across three different random seeds, with results averaged.
value between layers. Additionally,
For the gradient-based training, the categorical cross-entropy loss was employed between the one-hot encoded target
classes and the output spikes per step. The resulting values were averaged across the batch and the number of steps to obtain the final 16ss
The LFP training methodology requires reward function. For the SNNs experiments, the static MNIST images are encoded into the required input sequence through constant encoding. Specifically, given image X; Rwxxxe is fed sequentially into the network n times, yielding the input X xRR*xxxxx When presented with the input X, the SNNs produces output sequence (oR,i)==1 per class, where 1 < k & m is the class index. This can be written as output matrix O R". The predicted class of the model is determined by accumulating the spikes for each class and taking the maximum. For a given model output with corresponding target label ye E IN, we rewarded the network with the matrix Rn.m, elementwise defined via
1-o Oc, 7) yc Te,==
(A.4)
o1 10 111 if yo
where a denotes the sigmoid function. This reward function encourages spikes for the correct class while discouraging spikes for others, yet tolerates some spikes across all classes to yield more stable signal that is less affected by noise.
For the experiments in Figures 10 and 11, we utilized the implementation of Mozafari et al. (2018) in www. gi grithub. com/ wwtaaaiinntatasaaeeeeeeaaaaaaaat for the R-STDP training. Here, the Cifar10 data was encoded as pre- viously outlined for MNIST. We implemented two convolutional neural networks, utilizing 25 time-steps per sample and 3 0.9, adapting the deeper2024 and resmet2024 models from the R-STDP codebase. In conducting gradient-based and LFP training, we modified the architectures by adding a final fully connected layer to facilitate prediction. In our revised architectures, each block is composed of convolutional layer, succeeded by max pooling layer and Lly-rryer. R-STDP only the (original) deeper2024 model from the R-STDP codebase.
To enable based training, we employed shifted arctan surrogate function in the backward pass, as per (Fang et al., 2021). We investigated learning rates of le 5e 4, and 1 for gradient descent and LFP, where the setting where the maximum accuracy was reached (Ir 5e 4) are reported in the figure. For R-STDP we used the hyperparameters of the reference implementation, only changing the number time-steps to 25. We trained the LFP and gradient descent models for 50 epochs each. For R-STDP, each layer was separately trained for 10 epochs. Refer to the "mplementation" for further details.
39

---

Published in Transactions on Machine Learning Research (06/2025)
MSE
Prodictions
3-
2-
04
20
40
60
80
100
0
Epochs
Ground Truths
Figure A.4: LFP- LFF-regression on the California Housing dataset. We report the MSE on the test set (left) and a scatter plot of (test set) prediction vs. ground truth house prices (right). Note that house price 5 is equally distributed across variation of the most predictive features the dataset (despite strong correlation with house price and c.g. median income overall) causing the random behavior of predictions at ground truth
A.8 Extending LFP to Regression
In this work, we have focused on applying LFP for classification. In the following, we shortly outline how LFP can be extended to regression models. This requires two adaptations from the classification- fortiiattionultiionnn in the paper: (1) A different reward function and (2) (possibly) a reference point correction in the last, linearly activated layer.
The former (1) is relatively trivial. Given some examples (z, y) of the ground truth function y == g(x), and the model output oe, suitable initial rewards Og include, e.g., O₂ (ye- oz) sign(oe) and r. (Ve oz) sign(ox). Note that does not correspond to a class, but rather output dimension of the regression model here. These rewards consider the direction of the difference between ground truth and prediction, and are proportional to rewards derived from gradient descent with MSE and MSE-squared in the sense of Theorem 1, respectively.
The second (2) adaptation more complex. LFP in the present classification setting implicitly utilizes reference point of zero when evaluating contributions, measuring how [[-1] shifts 2j
[(+1) away from zero (the reference point). For the last, linearly activated layer of regression models, zero may not always be an ideal choice, and may require a dedicated rule for successful application regression scenarios. For applications reference activation value is well motivated and explained in Letzgus et al. (2022). Choosing a suitable reference value for LRP depends on the intended explanation target. However, setting such reference during active training, might be non-trivial, it strongly affects the magnitude and direction of parameter updates, and should be investigated in dedicated future work.
LRP in regression settings, the choice of
We provide an initial experiment training a small MLP regressor for 100 epochs on the California Housing Dataset with LFP (predicting house prices). The MLP consists of three layers with 256, 128, and 1 neurons, respectively, Except for the last, linearly activated layer, we use ReLU activations, and apply dropout with a probability of 50% after the first two linear layers during training. We utilize a batch size 128, a learning rate of 0.05, a momentum 0.9, and Tk = (yt- - )² sign (ox) and do not change the reference value from zero. In this example, the application LFP can be considered successful, achieving final MSE of 0.33 on the test set. Notably, in this simple application, adaptation of the reference value does not seem necessary.
A.9 Extending LFP to Transformer Models
While we do not investigate this in-depth in this work, the following Section briefly discusses how LFP could be extended train mate-of-the-an transformer architectures.
These models mainly employ GeLU, SiLU or ReLU activations, which are handled by LFP out of the box, as they are sign-pressee preneerreervigg (c.g., cf. Table 3 for ReLU and SiLU; GeLU has similar shape as SilU). They further employ LayerNorm (Ba et al., 2016) instead of BatchNorm. LayerNorm normalizes across features instead of the batch, and can thus be handled using the same rule as we used for BatchNorm (equation 11 and equation 12), except with mean and variance computed across features instead of samples.
16This corresponds the "cross entropy spike loss" in the implementation Eshraghian al. (2021).
ht tps / //gitt thub. . com/1 readarweber ayerwi se- feedback feedback--poppgettice
40

---

Published in Transactions on Machine Learning Research (06/2025)
100
Train Acsuracy 196]
Test Accuracy [%]]
80
80
60-
60
40
40
LEP-c
Grad
01
10
10a
10
10
10a
10
10
Time (8)
Time (s)
Figure A.5: LFP performance on VIT over clock time (s). We report training (left) and test (right) accuracy for gradient descent and LFP. While LFP provides a valid training signal even in such deep architectures, it is outperformed by gradient descent, emphasizing the need for further research into more optimal propagation rules. Results are averaged over 3 seeds, with standard deviation highlighted around each line.
In transformer models, the main challenge for LFP is propagation through attention layers, specifically the highly nonlinear softmax function in the attention. The issue is described and solved in Achtibat et al. (2024) for LRP, but obtaining neuron contribution (which LFP relies on) specifically for attention layers still an active field of research.
The below experiment shows LFP applied to a Visual Transformer (Dosovitskiy et al., 2021), handling GeLU and LayerNorm as described above, and otherwise adapting the rules suggested by Achtibat al. (2024). These can be directly translated LFP since they do alter propagation through any parameterized operations. We utilize model pretrained on ImageNet and fine-tune it small bean disease classification dataset 19 for 100 epochs, altering all parameters except for the embeddings. We utilize a batch-size of 32, momentum of 0.9 and learning rate of 2e with an Adam (Kingma & Ba, 2015) optimizer. While LFP provides meaningful training signal, with only a slight increase in training time per epoch, it is outperformed by gradient descent in this experiment and converges much slower, emphasizing the need for further research to extend it to state-of-the tht model architectures.
A.10 Additional Figures
Pnntpss://hogginggaac... -
41

---

Published in Transactions on Machine Learning Research (06/2025)
VGG-Like: CIFARIO
1.16
0.90
Gini Cooficiien Weight Magnitude
0.34
LFP-5 Grad
0.00
0.3
featuros.0 0
features 2-
features.5 5
featuress. 7
features. 10-
featuree. 12
classifier.O
classifier.3
classifier.G
VGG-16: ISIC2019
Layer
1.15
0.90
Weight Magnitude
0.25
Giai Coeffiiinnt
0.00
0.4
featuressO0
feacuros.2 2
features.5
features.7 7
features, 10
Reakures.11 12
features. 14
feakures. 17
features.2 2.1
feohures:244 24
features 26
features.22 28
classiffer:.
classifler.3
classeifter:
features.
ResNNel-34:
Food-11
Layer
1.16
0.90
JT IT
Weight Magnitude
0.29
0.15
Gini Confficiont
0,00
0.8
0.3
conv
ticn o0 convl
couno
conne
conn -
coome i
coom 2
conn
coom
cone
layor's cone
lsyerce is ciuoe
3. dauee
layer3, 4. 4.nvi sonvl
layer3, 4.....2222 cowv
lsyerrk. s..ovv -
layer3.5 5.co222
layerd 4.0. con't
-
1.O. conv?
layer w.0......dao downsampl pomnaappee 00000
layerd, 1. I.o.v. convl
1syeri.1 conx?
1ayer1. 1.2.cooo convil
1ayor4.2 2.por.2.ccoov.. conv2
fc-
2.
layer
laaer
loyers
layerd
leyerde
Jayort
layerde
Isyerd
L.vez3.0.
Jayerzz
layer&
Layer
Figure A.6: More normalized unsigned weight distributions, confirming observations on Figure 7.
42

---

Published in Transactions on Machine Learning Research (06/2025)
ResNeet-1: CUB
10.20
0.33
Weight Magnitude
0.33
0.17
Giai CoufFeient
0,00
convl
layer 0..onv]
layer1 1.O. 0.comy2
layer1 Leonv]
layer1 1.1 Leanv2
layer (l.oovllll
layer2.0 2.0.0. 0.comv2
layer Leavvl
layer2. Loanv2
1ayer 3.0.0 0.oovvl
Layer3.0 0...0. couvv
layer3.1 Loovvl
layer3. 1. Leonv2
loyerd, 4.0. convl
layer 0. conv2
layer 4.1. Leovvl
layer4.1 Leony22
Layer2.0.dk wwdddoonsmmllee..
layer3 downssample.
laper44. A. B.verr...owwssanniig. d.d.dommmmmppa
LFP-g Grad
Layer
Figure A.7: Original unsigned weight distributions, without maximum value normalization. (cf. Figure 7).
43

---

Published in Transactions on Machine Learning Research (06/2025)
VGG-Like: CIFARIO
13:24
1.52
Gini Cooficiien Weight Magnitude
0.52
LFP-c Grai
0.26
0.00
0.3
featuros.0 0
features.2 2-
features 5
featuress. 7
features. 10-
features..1 12
classifier.O
classifier.3
classifier.G
VGG-16: ISIC2019
Layer
4.89
0.32
Weight Magnitude
0.32
0.16
Giai Coefficient
0.00
0.4
features.O0
feacuros.2 2
features.5
features.7 7
features, 10
Reakures.12 12
features. 14
feakures, 17
features.21 21
feohures:244 24
features 26
features, 28
classiffer::
classifler.3
classiifter:
features,
ResNNel-4:: Food-11
Layer
4.67
Weight Magnitude
0.15
0.07
Gini Coofficiont
0,00
0.8
0.3
convy
layer Of convl
conve
couno
conne
coome
coom
e 2.
ceaeee di A couoo
bo Teepiiii
poyens cone
conoo
dono
peeeeee Ss cone
layord cone
layere, 4.oo22
aoverika covvi
Jayer33 sonv?
layert 4.O. conv'
aayert U. conv?
Jayer 1.0....dddoo wow.rr..wwwwii..... 0
downsamples
layerd, couvt 1
lsverdl conx?>
1syer112 1.2.col convll
1ayor4.2 2.yord.2.conv2. conv2
fc-
i
4.4
laaer
layort
poyerd
Layer2
Aayeza
Layer
Figure A.8: Original unsigned weight distributions, without maximum value normalization. (cf. Figure A.6).
44

---

Published in Transactions on Machine Learning Research (06/2025)
Maguiiudde-beee Pruning
Maguitude-bascd Global Pruming
Relevance-bused
Maguitude-bused
Magaltude-basee Pruning
Relevance- based
Glohal Proming
Pruming
Pruning
Roonst-1K CUB
VGG-10 10: Fbod-11
80-
Accussy (88
Artunayy [4]
00-
60-
20
40
90
100
0
20
47
60
100
20
40
60
80
100
20
40
05
80
100
20
40
01
80
100
0
20
40
63
50
100
Stallet Weigles Pranel (S Staaleei Weigtos Praned
(95) Smallest Redevaacees Prinet
1%)
Staallst Wenghts Prined (5] Smallest Weights Pomed
(4
Smoillet Reberanee Pruned (4)
RowNat- ISIC2010
VGG-18 18: ISIC2010
Acconsyy 181
40
Avrumry [4]
60
40-
40
80
50
60
100
20
80
00
100
20
40
80
40
100
Stoolieet Welgtns Praned PI Snodlees Weights Praned
(9) Smalles Relevances Prancd
Suallot Welghte Proned 744)
Smallest Weight Franed
74] Smooleet Releranoe Praned [4]
100
VGG-16-BN: 16---6-BN: CUB
1.0
RowNer--W4: CUB
Aucunery
60-
01
Weighos
Weighos
Weeghte
Weighte
Row Nott--i Funil-11
1001
100
VGG- 16-BN; BN: Food-
Arrinayy (5)
60
00
100
20
Sccolles
Saxillot
Welghes
Row/Net---t: 1S1C20115
VGG- 16 BN; 1SIC2019
Accumiy [5]
60
200
60
00
50
130
20
60
50
150
20
00
50
100
30
60
100
20
40
90
100
0
40
60
80
100
Scrallest
Wenghts Pruned
[3] Smallest Werghts Pruned
[5] Smallett Relevanees
Pruned
18
Smallet Wrights Franed
1% Smaleet Weights Praned
(%)
Smallest Relevances Praned
150
VCC--lia:: Cilar 120
Arrumey (86)
101
60
LFP-s
Grad
100
20
150
87
50
100
Smalloo Wingite Pruned
[X] Smailest Wrrghtt Prined
Smallet Relevaness Pruced
Figure A.9: Pruning results, extending Figure 8. Note that we report the weighted accuracy for ISIC2019, due to the severe imbalance that dataset. While there is slight variance depending on the setting, and there are specific cases where gradient- -rainnnt-- models seem more prunable at least for one out of the three criteria, the general trend from Figure 8 holds, with LFP-trained models retaining accuracy for longer in the majority of cases.
45

---

Published in Transactions on Machine Learning Research (06/2025)
MLP
LeNet
100
Test. Arcuracy (6
Test Accuracy 1%
L.P--c
Grad
Surt.
Grad
20
0.0
5
15
25
13
25
Steps per Predictiinn
Steps Prediction
MLP
LeNet
100
100
Test Acturary [%]
Test Accurcy [%6]
LFP-
80
80
Grad
Surr.
Grad
40
20
20
0.0
0.0
0.3
0.6
0.9
0.3
0.6 /
0.9
Figure A.10: Final test set accuracies for different hyperparameter settings MLP and LeNet based SNNs. Top row: Variation with sequence length of the encoded data. Values used: 5, 15, and 25 steps. Bottom row: Variation with decay factor 3. Values used: 0.3, 0.6, and 0.9. Three training methods (LFP-s, gradient descent (Grad), and surrogate-enabled gradient descent (Surr. Grad)) are compared in each graph.
HeLU
LoakyReL,U
Tuab
Sigmoid
Hoaviside
Eapes
Ingstt
Lagret
Eaput
Figure A.11: Illustration of the activation functions used in Section 3.5 and throughout the paper.
46


Reviews:
[{"review_id": "CNVuBYeAhR", "reviewer": "Reviewer_AAUM", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths:\n\n1) Research into gradient-free learning algorithms is interesting from a flexibility, computational, and biologically plausibility angle.\n2) Local update rules (like Hebbian learning) win Nobel prizes.\n\nWeaknesses:\n\n1) My main concern reading the paper is that the learning rule seemed very similar to BackProp, and indeed in Theorem 1 shows that it is equivalent up to rescaling when using ReLUs. In fact it seems carefully crafted to behave like BP when using ReLUs. When using other nonlinearities it is roughly equivalent to using backprop but ignoring the nonlinearity gradients in the chain rule (and including a term with the activations that will zero out the rewards if the activations are zero). Table 3 shows that the method usually performs best when the nonlinearity is ReLU, which makes me question its utility.\n\n2) \"No differentiation\". There are error (or reward) signals being passed back through the network. In biological learning literature differentiation-free usually means avoiding the need for \"weight-transport\": when y_j = sum_i W_ij x_i on the forward pass, avoiding computing anything with the transpose of W, for example avoiding computing a term line sum_j W_ij r_j . However I believe you do have that term in your update when you compute r_i = sum_j r_ij. Therefore I believe there is differentiation of linear parts of the NN, so I am worried about the claim of no differentiation.\n\n3) The paper hinted that it would work well with non-differentiable nonlinearities (mentioning heaviside as a motivating example). I was surprised in Table 3 when the method did not work at all with heaviside (and in fact backprop somehow managed to do better? was it managing to at least train the final layer?). This really confused me as I thought the main motivation was handling these types of networks.\n\n4) Missing some citations to bio-plausible learning literation (see next section).", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper introduces LFP, a supervised training algorithm for training layer neural networks. The claim is that LFP does not require differentiation, which allows for more diverse model architectures with non-differentiable activation functions. A proof was given for convergence when using ReLUs. Empirically, it results sparser parameters. Computationally it is equivalent to backprop.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "1. More care in defining the update rule. Please include layer indices on all r, w, z, etc.\n\n2. Please have a look as biologically plausible learning rules, \"Assessing the Scalability of Biologically-Motivated\nDeep Learning Algorithms and Architectures\" is a good read. It mentions similar algorithms that you may be interested in: \"Feedback alignment\", \"Target Propagation\", and \"Difference Target-Propagation\".\n\n3. Please rebut my concerns about not needing differentiation. What exactly do you mean by that and why is it worth avoiding it?\n\n4. Please work on the story. The method does not seem to work with the only non-differentiable nonlinearity which I thought was the main point of the approach.", "broader_impact_concerns": "No ethical concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "drk5PdzJN9", "reviewer": "Reviewer_t9tc", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strengths: \n(a) The authors present an interesting perspective on differentiation-free model training, highlighting the concept of reward-based learning at the neuronal level.\n(b) The methods discussed is highly relevant for on-chip learning scenarios.\n\nWeaknesses:\n(a) The performance of this approach is not comparable to current sota, even considering gradient free approaches like equilibrium propagation. Thus scalability is a concern.\n(b) To further strengthen the case for the proposed method, additional experiments on SNNs could have been conducted, comparing the approach against training paradigms such as STDP, Decolle, BPTT with surrogate gradients, etc.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The authors propose a training methodology called Layer-wise Feedback Propagation (LFP), which trains the underlying network by distributing rewards to individual neurons based on their contributions. This approach enables a greedy optimization strategy, strengthening or weakening connections based on their contributions (without using differentiation operation), to enhance learning efficiency. The authors validate the proposed approach through a combination of theoretical analysis and empirical studies, demonstrating its effectiveness.", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "(a) Additional literature review and comparison with other gradient free training approaches such as equilibrium propagation.\n(b) Clock time comparison in experiments with other training approaches. This is to understand any computational overhead associated with training with this approach.\n(c) If possible please add some additional experiments on SNNs. \n\nQuestions:\n(a) How will the authors approach training regression based models with this technique?\n(b) How to tackle activations like gelu, which are widely used in transformer-based architectures. Also, how to incorporate Layernorm?", "broader_impact_concerns": "There are no strong concerns on the ethical implications of the work.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "FZIYuSlf9e", "reviewer": "Reviewer_LAuB", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "Strength:\n\n- The method seems to be able to train neural networks without using gradients, under some conditions.\n\n- The method seems to work.\n\n- Importantly, while this method is highly restricted in terms of activation functions and outcomes, these limitations are clearly and honestly described in detail.\n\nWeaknesses:\n\n- The restrictions on the method are indeed quite strong. In particular, there are strong constraints on allowable activation functions (am I correct that they should always preserve the sign of the incoming net input?) and the \"reward\" function must be carefully chosen to produce adequate results.\n\n- The method can result in \"dead\" neurons that stop updating, though IIUC the reason is quite different than in traditional SGD training  (zero output rather than zero gradient).", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper proposes a new method for training neural networks that does not require gradients (though it still uses a backward pass).\n\nThe method relies on a concept of \"reward\", quite distinct from how this term is generally used. For a given neuron, this \"reward\" specifies whether we want the neuron to amplify its current firing (negative or positive), or whether we want it to do the opposite (fire less if its firing was positive, fire more if it was negative).\n\nThe authors propose rules which can backpropagate this \"reward\" through a multi-layer architecture (i.e. compute the \"reward\" for layer l-1 from rewards for layer l), under certain conditions on the activation function.\n\nThey also propose a weight update rule based on this reward and the activations of the neurons (and the current weights). Somehow this rule happens to be a \"reward\"-modulated Hebbian rule, but where the post-synaptic output *divides* the pre-synaptic input, instead of multiplying it.\n\nUnder some conditions, and with a suitably chosen top-level \"reward\", this rule is equivalent to gradient descent.\n\nVarious experiments show that this method can train deep neural networks, again under some conditions on the activation function. It can handle non-differentiable objectives and activation functions that would make  gradient descent unusable, though also introduces new challenges (e.g. no updates if activation is zero).", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "Overall the paper is clear and self-contained.\n\nIIUC your update rule looks like a \"reward\"-modulated learning rule, except that now the post-synaptic output divides the pre-synaptic input, instead of multiplying it. Please elaborate a bit on that. The connection, and the difference, are too glaring to not be mentioned.\n\np. 7: \"Equations equation\"", "broader_impact_concerns": "No broader impact concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: Overall the reviewers found the method interesting, and the work well-written. Concerns raised by the reviewers rested in the potential similarities to backpropagation in restricted cases, and the "no differentiation" terminology used to describe the method given the methodology. Further concerns included the substantial restrictions/limitations of the method e.g. activation functions, and missing literature in both the bio-plausible and gradient-free training approaches. The authors responded to almost all of the reviewer's concerns effectively and did incorporate some of those changes into the manuscript during the rebuttal itself to address the concerns.

Post-rebuttal, all reviewers found their concerns adequately addressed, with the sole exception of some questions remaining on the scalability of the method. Reviewer recommendations post-rebuttal noted that while the methodology itself might be counter-intuitive, has significant limitations, and imposes significant restrictions, all of these limitations/restrictions were clearly discussed by the authors in the paper. Given this, the work was judged to be within the TMLR acceptance criteria. 

While I'm aware many of the changes requested by reviewers during the rebuttal period were already updated in the manuscript, due to the large number of changes and >12 page length of the paper I have chosen to accept with a minor revision to ensure all the requested changes are completed before acceptance, and also in order to allow the authors to further address scalability of the method in particular on deeper/closer to state-of-the-art architectures.
Decision: Accept (poster)