A Robust Backpropagation-Free Framework for Images
Authors: Timothy Zee
Alex Ororbia
Ankur Mali
Ifeoma Nwogu
Venue: Accepted by TMLR ()

Abstract: While current deep learning algorithms have been successful for a wide variety of artificial intelligence (AI) tasks, including those involving structured image data, they present deep neurophysiological conceptual issues due to their reliance on the gradients that are computed by backpropagation of errors (backprop). Gradients are required to obtain synaptic weight adjustments but require knowledge of feed forward activities in order to conduct backward propagation, a biologically implausible process. This is known as the "weight transport problem''. Therefore, in this work, we present a more biologically plausible approach towards solving the weight transport problem for image data. This approach, which we name the error-kernel driven activation alignment (EKDAA) algorithm, accomplishes through the introduction of locally derived error transmission kernels and error maps. Like standard deep learning networks, EKDAA performs the standard forward process via weights and activation functions; however, its backward error computation involves adaptive error kernels that propagate local error signals through the network. The efficacy of EKDAA is demonstrated by performing visual-recognition tasks on the Fashion MNIST, CIFAR-10 and SVHN benchmarks, along with demonstrating its ability to extract visual features from natural color images. Furthermore, in order to demonstrate its non-reliance on gradient computations, results are presented for an EKDAA-trained CNN that employs a non-differentiable activation function.

Published in Transactions Machine Learning Research (11/2023)
A Robust Backpropagation-Free Framework for Images
Timothy Zee
lsz2759 Gril. edu
Department of Computer Science Rochester Institute of Technology
Alexander G. Ororbia
ago cec.ccsrit.ee edu
Department of Computer Science, Department of Psychology Rochester Inslitule of Technology
Ankur Mali
unkururjanmmiiOOa...cc
Department of Computer Science and Engineering University of South Florida
Ifeoma Nwogu
inwogu@duffalo.c edu
Department of Computer Science Universily at Buffalo, SUNY
Reviewed on OpenReview: https: // openreview. net/ forum? id= LegrOußzeN
Abstract
While current deep learning algorithms have been successful for wide variety of ar- tificial intelligence (AI) tasks, including those involving structured image data, they present deep neurophysiological conceptual issues due to their reliance on the gradi- ents that are computed by backpropagation of errors (backprop). Gradients are re- quired to obtain synaptic weight adjustments but require knowledge of feed-forward activities in order to conduct backward propagation, biologically implausible pro- coss. This is known as the "weight transport problem". Therefore, in this work, we present a more biologically plausible approach towards solving the weight transport problem for image data. This approach, which name the error-kernel driven ac- tivation alignment (EKDAA) algorithm, accomplishes through the introduction of locally derived error transmission kernels and error maps. Like standard deep learn- ing networks, EKDAA performs the standard forward process via weights and ac- tivation functions; however, its backward error computation involves adaptive error kernels that propagate local error signals through the network. The elficacy of EK- DAA is demonstratod by performing visual-recoguition tasks on the Fashion MNIST, CIFAR-10 and SVHN benchmarks, along with demonstrating its ability to extract visual features from natural color images. Furthermore, in order to demonstrate its non-reliance on gradient computations, results are presented for an SKDAA-trained CNN that employs non-differentiable activation function. Our library implemen- tation can be found at: https: : // github. com/ hen/ttze///e EXDAA-Releaa

---

Published in Transactions Machine Learning Research (11/2023)
1 Introduction
One of the most daunting challenges still facing neuroscientists is the understanding of how the neurons in the complex network that underlies the brain work together and adjust their synapses in order to accomplish goals (Südhoff & Malenka 2008). While artificial neural networks (ANNs) trained by backpropagation of errors (backprop) present practical, feasible implementation of learning by synaptic adjustment, it is largely regarded by neuroscientists as biologically implausible for various reasons, including the implausibility of the direct backwards propagation of error deriva- lives for synaptic updates. Furthermore, this form of learning breaks fundamental requirement for pelooicalll--lausibbe (bio-plausible) learning; backprop requires access to the feed-forward weights in order pass back error signals to previous layers. This property, known as the weight transport problem (Grossberg) 1987), renders backprop to be poor candidate base learning rule for building realistic bio-inspired neural modeling frameworks. In terms of bio-plausibility, it more likely that differences in neural activity, driven by feedback connections, are used in locally effecting synap- tic changes (Lillicrap ct al., 2020). Such difference-based networks overcome some of backprop's major implausibilities in a way that is more naturalistic and more compatible with the current understanding of how brain circuitry operates. Although few classes of algorithms have been proposed to address the specific challenge of error gradient propagation in training ANNs, fewer still have been proposed to handle the highly structured data found in large-scale image datasets. Current-day convolutional neural networks (CNNs) and Visual Transformeres (ViTs) continue to set the benchmark standards for difficult vision problems (Mnih et al., 2013 He et al., 2016 Doso-
vitskiy et al., 2020), and they do so using backprop, with symmetric weight matrices in both the feedforward and feedback pathways.
1.1 Bio-plausible Machine Learning
In this work, create learning rule that addresses the weight transport problem for image data, leveraging spatial relationships with convolution. As a result, we introducc a more bio-plausible error synaptic feedback mechanism that we deem the (learnable) error-kernel, which generates target activities for feature maps within CNN to "align" to. We call this learning mechanism error-kernel driven activation alignment (EKDAA).
The Weight Transport Problem. In our learning scheme, the forward pathway relies on tradi- tional weight matrices/Lensors whereas the backward pathway focuses on error kernels and maps, thus climinating two-way symmetric weight structure inhcrent to backprop-trained networks. This, in effect, resolves the weight transport problem.
While currently known bio-plansible methodologies have not reached the modeling performance of backprop and have yet to be scaled to large datascts such as ImageNet (Deng et al. 2009), we believe investigating bio-plausible learning rules are key in the future of neural modeling- FKDDA notably opens the door to a wider varicty of neural structures, potentially cnabling lateral neural connections, where forward heward/backwardd /backward propagation no longer carry the traditional meaning. We successfully train convolutional network on image data, using the signum function (which has a derivative of zero everywhere except at zero, i.e., its derivative is a Dirac delta function). Learning with the signum showcases how EKDAA facilitates the use of bio-plausible activation functions. The signum function behaves similarly to the action potential of biophysical neuron, i.c., acts as a hard activation where the incoming signal is either propagated or killed, abiding to Dale's law for neurons [Eccle 1976
Lillicrap et al.] 2020
2

---

Published in Transactions Machine Learning Research (11/2023)
Loss
Loss
dv,
N2
4
H
H
5
(a) Backpropagaaton
(b) EKDAA
Figure 1: The signal flow for backprop and EKDAA. The forward pass (solid blue arrows), the backward pass (solid orange arrows), and the weight update (gray dashed lines). For layer N, HN denotes its pre-activation while NN represents its post-activation. e is the convolutional error kernel, and E is used to transpose the error signal to the appropriate size when propagating backwards.
Bio-plausibility and Convolution. The convolution opcrator is a powerful mechanism for ex- tracting spatial features from images and video, exhibiting key properties for signal updates that can be integrated into a bio-plausible convolutional network. In a backprop model, deconvolution is used for both layer-wist wise gradient updates and deconvolution of filter updates, and can be computed by differentiating each value of the filter with respect to every element of the matrix that the filter touches during the convolution pass. However, gradient updates can also be computed without the need to take direct derivatives on elements by directly employing a convolution of the same matrices that the derivatives would be taken on. As a result, the update signals are computed as:
A We m.n.s + X AX 81
mas
AXÉ m.n:: + Ax4+1 A. Flip W m..
(2)
where, W w...: the weight matrix for a layer I with feature map element [m, n),, X X the correspouding model layer output. AWL W..... is the error signal weight matrix for layer 1, AX is the error signal from the output of layer I, and Flip is the transpose of a matrix with respect to both the and y axis. The convolution operator is represented with *. Therefore, convolution works within a Hcbbian model and can be used as a powerful fcature extractor without the need for computed derivatives. The symmetrical process of convolution in the inference and training passes may further be considered to be a more bio-plausible means of processing visual information in comparison to the dense transforms used in standard feed-forward models. Convolution and deconvolution also are operators that are agnostic as to whether a learning rule is or is not weight symmetric. In essence, there are no inherent rules that dictate that deconvolution must deconvolve on the exact same weight matrices that are convoluted on in a system's 's forward pass.
2 Related Work
Although Hebbian learning (Hebb. 1949) is one of the carliest and simplest biologically plausible learning rules for addressing the credit assignment problem, extending them to the CNN has not yet been well-developed. Our proposed approach aims to fill this gap.
3

---

Published in Transactions on Machine Learning Research (11/2023)
In addition to Hebbian-based learning, other work includes alternative convolution-based schemes, such as those found in (Akrout ct al., 2019), that are based on the Kollen-Pollack (KP) method, which have yielded promising results on larger, more extensive benchmarks without the need for weight transport. These schemes create weight mirrors based on the KP method and incorporate it into the convolutional framework. Other training approaches are based on local losses (Nokland
& Eidnes 2019: Grinberg et al., 2019 Guerguiev et al., 2017: Schmidhuber 1990 Werbos 1982
Linnainmaa 1970); are methods that take the sign of the forward activities (Xiao et al. 2018
are schemes that utilize noise-based feedback modulation (Lansdell et al.) 2019); or use synthetic
gradients (Jaderberg et al.) 2017) to stabilize learning for deeper networks. These approaches have demonstrated better or comparable performance (to backprop) on challenging benchmarks that require the use of convolution. However, there are significant dependencies in the model's forward activitics used to guide the backward signal propagation, hence, these approaches belong to a different class of moblems//llorithhng than what we address in this work.
The Bottleneck Approach. Another key effort in this area, inspired by information theory, is the Hilbert-Schmidt independence criterion (HSIC) bottleneck algorithm (Ma et al. 2019), based on the Information Bottleneck (IB) principle (Tishby et al. 2000). HSIC performs credit assignment locally and layer-wise, seeking hidden representations that exhibit high mutuality with target values and less mutuality with inputs (presented) to that layer, i.c., this scheme is not driven by the information propagated from the layer below. Approaches based on the bottleneck mechanism are considered to be the least bio-plausible. Other efforts (Salimans et al., 2017) utilize an evolutionary strategy to search for optimal weights without gradient descent. Although powerful, these approaches exhibit slow convergence, requiring many iterations in order to find optimal solutions.
Feedback Alignment. Notably, an algorithm named Random Feedback Alignment (REA) was proposed in (Lillicrap et al., 2016), where it was argued that the use of the transpose of the forward weights (We for any layer 2) in backprop, meant to carry backwards derivative information, was not required for learning. This work showed that network weights could be trained by replacing the transposed forward weights with fixed, random matrices of the same shape (B for layer e), ultimately side-stepping the weight transport problem (Grossberg) 1987).
Direct Feedback Alignment (DFA) (Nokland, 2016). and its variants (Han et al. 2020 Crafton et al.
2019 Chu et al. 2020), was inspired by RFA (Lillicrap et al.) 2016), but, in contrast, DFA directly propagates the error signal; it creates a pathway directly between the output layer to internal layers as opposed to a layer-wise wiring format, as in RFA. Notably, across multiple ar- chitectures, it was observed that networks trained with DFA showed a steeper reduction in the classification error when compared to those trained with backprop. To compare these bio-plausible feedback alignment-basct training paradigms with EKDAA, we extended the corresponding pub- lished efforts and implemented CNN versions of FA, DFA, and other related variants. Details of their performance on the several benchmark image datascts investigated in this study are provided in Section 4
Target Propagation. Target propagation (target prop, or TP) (Lee et al. 2015) is another approach to credit assignment in deep neural networks, where the goal is to compute targets that are propagated backwards to each layer of the network. Target prop essentially designs each layer of the network as an auto-encoder, with the decoder portion attempting to learn the inverse of the encoder, modified by a linear correction to account for the imperfectness of the auto-encoders themselves. This corrected difference (between encoder and decoder) is then propagated throughout the network. This process allows difference target prop (DTP) (Lee et al. 2015) and variants
Bartunov et al. 2018 Ororbia & Mali 2019 (e.g., DTP--) to side-step the sexihhinn/explodnngg
4

---

Published in Transactions Machine Learning Research (11/2023)
gradient problem. However, TP approaches are expensive and can be unstable, requiring multiple forward/backward backward passes in cach layer-wise encoder/ pecoder/decoder in order to produce useful targets.
Representation Alignment. Local Representation Alignment (LRA) (Ororbia et al. 2018 and recursive LRA (Ororbia et al., 2023) represent yet another class of credit assigmment methods,
inspired by predictive coding thcory (Rao & Ballard, 1999 Clark 2015: Salvatori et al. 2023) and is similar in spirit to target prop. Under LRA, each layer in the neural network has target associated with such that changing the synaptic weights in a particular layer will help move layer-wise activity towards better matching a target activity value. LRA was shown to perform competitively to other local learning rules for fully-connected models, but extending/ saapuddin/appyyinng it to vectorized natural images like CIFAR-10 resulted in significant performance degradation.
3 Error Kernel Credit Assignment
In implementing the EKDAA algorithm, desirably, the forward pass in the CNN remains the same. However, the backward pass uses a form of Hebbian learning that creates targets for each layer (as shown in Figure I which results in error signal that can be used to make weight adjustments. In convolutional layers, locally computed error kernels transmit signals by applying the convolution of the error kernel with the pre-activation of that layer, aiming to align the forward activations accordingly. In the fully connected case, an error matrix is multiplied by the pre-activation layer to generate targets allowing for the computation of pscudo- gradients that can be used to train the forward activations. While EKDAA is similar to TP in that it creates targets to optimize towards in an encoding/ /deciningeeddiggg fashion, EK- DAA introduces the novel idea of encoding an error signal with a learned kernel. Similar to FA, EKDAA finds suc- cess with using random weights for projecting error signal changing layer-wise dimensionality as weight matrices in the forward and backward pass are asymmetric. In contrast to TP and LRA approaches, with our proposed algorithm, EK- DAA, the forward and backward activitics share as minimal information as possible; this helps the model to better over- come poor initialization and stabilization issues. In this sec- tion, we describe the forward pass in our notation and then present the details of the EKDAA learning approach.
AW m,a
2 mas Flip(emus))
z m2
Figure 2: Kernel update to learn the filters We m.m.: with EKDAA. - the nth post-activation of layer L 2-1, is deconvolved on the mth error ker- nel e of layer L, propagating the error signal to update A AWé m.n..."
Notation. We denote standard convolution with the sym- bol * and doconvolution with symbol O. Hadamard product is denoted by C while represents matrix/vector multiplication. ()T denotes the transpose operation. Flip(X) is a function for flipping tensor and is defined taking the transpose of X over both the x-axis and y-axis such that the value of an element Xi, after flipping results in the location Xæ-in-j- Flatten(z) means that the input tensor z is converted to a column vector with number of rows equal to the number of elements that it originally contained while UnFlatten(z) is its inverse (i.e., it converts the vector back to its original tensor shape). We use the notation to indicate extracting a slice of a certain dimension in tensor object, i.e., Vj.:: means that we extract all scalar elements in the jth slice of the three dimensional tensor V. Finally, dcnotes equality while <- denotes variable assignment.
Inference Dynamics. Given an input (color) image x, inference in a CNN consists of running feedforward pass through the underlying model, computing the activities (or nonlinear feature
5

---

Published in Transactions on Machine Learning Research (11/2023)
maps) for each layer L, where the model contains Le convolutional layers in total. The CNN is paramcterized by a set of synaptic tensors θ = [W', w .... Whe, Wy) where the last paramcter Wy y is two-dimensional tensor (or matrix) meant to be used in softmax/maxinn mmaximmm entropy classi- fier. All other tensors W
2,,...., are four-dimensional and of shape w E R N This means that any tensor W houses N₂ sets of N filters fitter/kernell /ernels of shape he x wig. The bottom
tensor W which takes in as imput an image, would be of shape W E RNN XNNohi where No is the number of input color channels, e.g., three, for images of size ho x wp pixels.
The mth feature map of any convolutional layer l is calculated as a function of the No-1 feature maps of the layer below (n E N there are N imput channels to the mth channel of layer t). initialized as h h = 0, in the following manner (bias omitted for clarity):
This is done, with h him
2-1 b + -hma:: + We m,n; magss
Vn.
(3)
m,:: = 26 (6(hmm.))
(4)
where W W m,n.;, denotes the specific filter / /ernel that is applied to input channel n when computing values for the mth output channel/map. Note that of is the activation function applicd to any output channel in layer E, e.g., ('(v)= = max(0, Max (or average) pooling is typically applied directly after the nonlinear feature map/channel has been computed, i.e., z f- Pmpl (m....
Learning Dynamics. Once inference has boen conducted, we may then compute the values needed to adjust the filters themselves. To calculate the updates for each filter in the CNN, EKDAA proceeds in two steps: 1) calculate target activity values for each feature map in each layer (shown in Figure 2 which this is then used to compute the error neuron maps, a type of neuron specialized for computing mismatch signals inspired by predictive processing brain theory (Clark, 2015 Salvatori et al., 2023), and, 2) calculate the adjustments to each filter given the error neuron values. To do SO, we introduce a specific set of filter parameters that we call the error kernels, each denoted as E m for every map and layer in the CNN. This means that including the error kernels as part of the CKDAA-learmne error kernel is the same shape as its corresponding convolutional filter, i.c., E NoxN, 1 (except Ey, which has the same shape as the transpose of Wy).
CNN parameters yields o = (W*, E W E²,... WLC ELc, W,, yo Ey Each
Assuming that the tensor target activity y' is available to layer L, we compute each channel's error neuron map as e --yff (yf... 2....) Using this mismatch signal, we then work our way down to layer appropriate error kernel. Once the projection is complete, if pooling has been applied to the output of each convolutional layer, we then up-sample the projection before computing the final target. This process proceeds formally as follows:
by first convolving this error neuron map to project it downwards, using the
c m - (y =m....)
55)
d d d EEmmns O m Vm Ne
(6)
n
d f-- Pupl Pup(dh (dhad) 1/ (If max-pooling used)
(7)
n,;,
y yn.. 80-1(h (h (d
(8)
where we see that m denotes the up- sa-samn operation (to recover the dimensionality of the map before max-pooling was applied). If pooling was not used in layer L f- 1, then Equation 7 is
omitted in the calculation of layer é-1's target activity. Notice that the update rule has a recursive nature; it requires the existence of y which in turn would have been created by applying Equations to the layer above, l f+1 1. Thus, the base case target activity y", which would exist at the very
6

---

Published in Transactions Machine Learning Research (11/2023)
Algorithm 1 EKDAA for a CNN with max-pooling and fully-connected maximum entropy output.
// Feodforward inference
// Calculate weight updates via EKDAA
Input: sample (y, x) and θ function INFER(X, ()
Input: Statistics A, larget y, 8, and θ function CALCUPDATES(A O) ,,., ,,,..,, h by, z" ,..,, zt0, Zy + A, =
Pass data thru convolution stack
Get image input channels
// Compute softmax weight updates
2n... Xn,i; An E No
Cg (y kyy
for l= = 1 to Le do
AW, By (Flatten(z4e))
Calculate feature maps for layer l
A,, (>(A y)
h m.:: 0, vm E Ne
y = 8z (Flatten (h
ey,)
for m 1 to NE do
1/ Compute convolutional kernel updates ybe + UnFlatten(y"e))
h
m.:: f h + W
2 f-1 Vn
z m.:. of (km..))
for { = Le to do Ne do C (y m.i m
m + pmp((mmts) (mmis))
for m
h, W Flatten(z*e), by = (hyy
A [(h .... hec hy), (z) ,,, g 2ny3
d' = 0, vn Ne-1
Return A
for to N do for 1 to No do d=1 + d +
Mnii 2 100-(hhh- (h
B$ Bup (d
for m Ne do for 1 to No-1 do 2-11 Flip m. AE m.m.i = (AW m.)
AW
= (AWo, AE Whe AELe Wy Ey}
Return A
top (or highest level) of the CNN, and, in the case of supervised classification, which is the focus of this paper, this would be the target label vector y associated with input image x.
Once targets have been computed for each convolutional layer, the adjustment for each kernel in each layer requires specialized local rule that entails convolving the post-activation maps of the level below with the error neuron map at l. Formally, this means:
1-1 AW mani: mn * Flip(em...)
(9)
AE m.n.i = (AW m.n...)
(10)
which can then subsequently be treated as the gradient to be used in either a stochastic gradient descent update, i.e., Wé Wm.i: Wt. m.n.: XA W
m.n.... more advanced rule such Adam
(Kingma & Ba 2017 or RMMprop (Tieleman & Hinton 2012
In Algorithm [ we provide a mathematical description of how EKDAA would be applied to a deep CNN specialized for classification. Note that, while this paper focuses on feedforward classification, our approach is not dependent on the type of task that the CNN is required to solve. For example, one could readily employ our approach to construct unsupervised convolutional autoencoders, to craft alternative convolutional architectures that solve other types of computer vision problems, e.g., image segmentation, or to build complex models that process time series information, i.c., temporal/recurrent convolutional networks. One key advantage of the above approach is that the

---

Published in Transactions on Machine Learning Research (11/2023)
Algorithm 2 EKDAA for fully-connected and maximum entropy output layers.
// Feedforward inference
// Calculate weight updates via EKDAA
Input: sample (y, x) and θ function INFER(X. ()
Input: Statistics A, larget y, 9, and θ function CALCUPDATES(A
8 =x x
> x could be Flatten(z4o)
3 ,,, by, z. ...... zLPc, By f A, y²= // Compute softmax weight updates
h ,,,..,,
// Calculate fully-connected layers
for = to LFc do
Cy - (y bn)
h we.z
AW, y By (zbrc) T A.,, = -
x (hh)),
y cluce 6 (h l.se (())
// Calculate softmax outputs
1/ Compute fully-connected weight updates for l LFC to 1 do
hy Wy (ztre), Zy (hy))
A = {(h ..., hrre, hy), (z", ..., LFc b,y)
c = -y - z²)
Return
y = 0 10--1hh- hh-11 - ef))
AW = cd (Z AE -WA
= (AWo, AE ,... Who ABLE, W, En}
Return A
test-time inference of an EKDAA-trained CNN is no slower than a standard backprop-trained CNN, given that the forward pass computations remain the same. EKDAA also benefits from model stabilization in comparison to BP. Even if the incoming pro-activations contain extreme values due to poor initialization, FKDAA credit assignment will still give usable error signals Iearn from; this is due to the fact that such signals mercly represent difference between target and actual activities (subtractive Hebbian learning) rather than differentiable values as in backprop.
Fully-Connected Synaptic Updates. As made clear before, EKDAA trains systems composed of cnvvoluttio/poollngg operators (Algorithm D] however, it can also be used to train fully / denselyy connected transformations. Specifically, for fully-connected layers, EKDAA recovers an LRA-based scheme Ororbia Mali (2019) as shown in Algorithm 2 i.e., EKDAA is a generalization of LRA (LRA was developed for fully-connected layers). In gcneral, like backprop, EKDAA converges to loss function minima because its seeudo-gradients, which are a function of the error signals, satisfy the condition that for a given weight matrix, Wn: AW, < AAW, 90%, where AW is the exact calculated derivative for matrix Wz. Although the approximate gradients are almost never equal to backprop's exact gradients, they are always within 90 degrees and, thus, they tend towards the do not
direction of backprop's (steepest) gradient descent. Note that EKDAA's take steps towards the loss surface minima as greedily backprop's 's gradients do; however, over many training iterations, they converge to loss surface points similar to those found by backprop.
4 Experimental Setup and Results
4.1 Datasets and Experimental Tasks
To understand learning capacity for model fitting and generalization under EKDAA, we design and train several models and test them against three standard datascts, Fashion MNIST Xiao et al. 2017 (FMNIST), CIFAR-10 (Krizhevsky et al., 2014), and SVHN (Netzer et al. 2011
Fashion MNIST, while only being a single channel (gray-scale) image datasct at a [28 28] res- olution, has more complicated pixel input space than MNIST, facilitating better analysis of the convolutional contribution to overall network performance. SVHN and CIFAR-10 images
8

---

Published in Transactions on Machine Learning Research (11/2023)
Dataset Algorithm
Memory Required (MBB
Computation Time (Sec)
FMNIST/BP
1517.29
96.36 +/- 1.79
FMNIST/EKDAA
2574.25
96.39 +/-9.16 9.16
SV
4723.84
316.84 +/- 19.91
SVHN/EKDAA
4728.03
268.95 +/- 54.56
CIPAR-10/BP
4723,84
319.72 /- 13.59
CIEAR-10/EDDAA
4728.03
271.99 /- 11.58
Table 1: Memory and computation time required for backprop and EKDAA models. GPU memory and average computation time with variance is recorded per 1000 updates with 10 trial runs.
of shape [32 x 32] pixels and are represented in three color channels, containing more complicated patterns and motifs compared to the gray scale Fashion MNIST (SVHN even contains many im- ages with distractors at the sides of the character that the image is centered on). Fully-connected layers are not strong enough to learn the spatial relationships between pixels, and, as a result, convolutional filters will be required to learn the key patterns within the data that would help in distinguishing between the various classes.
Taken together, the FMNIST, CIFAR-10, and SVHN datasets allow us to study how well EKDAA learns filters (when engaged in the process of data fitting) and also how effective it is in creating models that generalize on visual datasets. Additionally, we show that our networks can be trained using non-differentiable activations, such the signum function, or, more formally: signum (x) if x > 0,0 if x = 0, -1 if x < 0. In this case, we train all convolutional and fully-connected layers using signum as the activation function, except for the softmax output layer, in order to investigate how well an EKDAA-driven network handles non-differentiable activity without specific tuning.
Technical Implementation. We design CNNs for the Fashion MNIST, CIFAR-10, and SVHN datasets. The FMNIST CNN consists of three convolutional layers before flattening and propagat- ing through one fully-connected softmax layer. The filter size is [3 x 3] for all convolutional layers with the first layer starting with one channel, expanding to 32, then to 61, and ending at 128 filters. The fully-connected layers start after flattening the filters, which are then propagated through 128 fully-connected nodes before ending at 10 outputs (one per image class). Max-pooling with a kernel of [2 x 2] and stride of 2 was used at the end of the first and second layers of convolution.
The CIFAR-10 and SVHN models use six layers of convolution and are inspired by the blocks of convolution and pooling layers used in the VGG family of networks (Simonyan & Zisserman, 2014). First, two convolutional layers are used before finally passing through a max-pooling layer with a kernel of [2 x 2] and a stride of two. Three of these mini-blocks of two convolution layers, followed by a max-pooling layer, are used to build the final network. The first three layers of convolution use 64 filters while the last three layers use 128 filters. All layers use filter size of [3 x 3). After traversing through the last convolutional layer, the final neural activitics are flattened and propagated through a single nod-node, fully-connected layer before shrinking down to 10 output nodes (which are subsequently run through softmax nonlinearity). Both Fashion MNIST, SVHN, and CIFAR-10 models use a very small amount of fully-connected nodes and instead use multiple large filter layers to learn and extract distributed representations (see Appendix for details).
Each model was tuned for optimal performance and several hyper-parameters were adjusted, i.e., batch size, learning rate, filter size, number of filters per layer, number of fully-connected nodes per layer, weight initialization, optimizer choice, and dropout rate (details can be found in Appendix). The same architecture was used for both the EKDAA model and the other learning mechanisms that it was compared against. Models were optimized using stochastic gradient descent with momentum and Pascanu re-scaling (Pascanu et al. 2013) was applied to all layer-wise weight updates.

---

Published in Transactions Machine Learning Research (11 (11/2023)
FMNIST
SVHN
CIFAR-10
Train Acc
Test. Acc
Train Acc
Test Acc
Train Acc
Test
BP
95.31 0.18
89.97 = 0.14
90.98 0.23
88.62 = 0.10
83.33 = 0.22
71.08 0.08
BP (FC)
92.91 + 0.39
87.02 = 0.41
84.36 = 0.12
79.81 = 0.22
67.05 = 0.34
55.03 = 0.29
LRA-E (FC)
93.59 + 0.26
87.58 = 0.33
80.17 + 0.08
73.24 = 0.19
58.10 = 0.28
55.51 + 0.42
EKDAA
95.83 + 0.33
90.01 = 0.11
84.31 + 0.21
82.27 = 0.19
75.05 = 0.27
63.38 + 0.12
EKDAA. Sig.
94.00 0.14
88. + 0.06
79.43 1 0.09
76.87 0.13
64.22 0.12
59.71 1 0.08
HSIC Ma et al. 2019
88.30 =
59.50 1
FA
95.30 + 0.51
89.10
79.18 + 00.22
76.50 = 00.18
77.50 + 0.25
58.80 = 0.11
DFA
93.99 1 0.32
88.90 0.10
82.50 1 00.24
80.30 1: 00.21
79.50 +: 0.20
60.50 0.08
SDFA
94.10 0.28
89.00 L 0.10
84.50
1 00.23
81.40 1 00.19
80.00 1 0.19
59.60 0.06
DRTP
93.50 0.40
87.99 1 0.15
85,21 T 00.21
81.90 00.20
79.50 1 0.22
58 20 0.14
Table 2: Train and test accuracy on the selected datasets. Mean and standard deviation over 10 trials reported. Note: The signum (sig.) function is included to demonstrate that we are able to successfully train a non-differentiable activation with EKDAA and obtain reasonable performance. BP results are shown to serve as a best case scenario when training with optimal gradicnts.
All models were trained on the original datasets, at the original resolutions, without any augmenta- tion or pre-training. Unlike backprop, EKDAA did not benefit from extensive heuristic knowledge on optimal parameterization, making grid search for parameters ineffective as the hyperparam- eter tuning limits would be significantly wider than with backprop. As a result, for tuming, the learning rate was tuned from the range le-1 to le-4, number of filters were tuned from the range 32 to 128, dropout was tuned from 0 to 0.5, and the activation function was evaluated to be either the hyperbolic tangent (tanh) or the linear rectifier (relu). The final meta- parameterr setting for EKDAA was a learning rate of 0.5c 3, 0.9 momentum rate, tanh for activation, and dropout rate of 0.1 for filters and 0.3 for fully-connected layers (complete model specifications are in the Appendix). All model weights were randomly initialized with system time as a sced. For EKDAA, the error kernels were randomly initialized with the Glorot uniform weight initialization scheme Glorot & Bengio, 2010). Furthermore, all models were trained on a single Tesla P4 GPU with 8GB of GPU RAM and ran Linux Ubuntu 18.04.5 LTS, using Tensorflow 2.1.0. The code for this work has been designed in a novel library that allows for defining convolutional and fully-connected models with the ability to quickly change the learning mechanism between BP and EKDAA. The library also allows for defining new custom lcarning rules for analysis. While this codebase offers an advantage for analyzing learning mechanisms, it has been custom written without the optimization techniques that common librarics have implemented. This codebase takes advantage of Tensorflow tensors when possible but has a custom defined forward and backward pass that is not nearly as memory or computationally efficient as it could be. Our library implementation can be found at: https: // thub. com/ tzee/
addition to train and test accuracy, we compare the GPU memory usage and computation time required to train EKDAA and backprop. Results for this are shown in Table ! Overall, EKDAA shows slight improvement in computation time as models become larger and, overall, only results in a minor increase in required memory to run the same model than backprop. Overall, EKDAA's architecture does not exhibit worse computational requirements than those of backprop.
4.2 Results and Discussion
We analyzed EKDAA by comparing it to several bio-inspired learning schemes such as HSIC (Ma) ct al. 2019), RFA (Lillicrap et al.] 2016), DEA (Nokland) 20166,, sparse direct feedback alignment (SDFA) (Crafton et al.) 2019), and direct random target projection (DRTP) (Frenkel et al. 2021) (see Appendix for baseline details). The results are presented in Table 2 (we also added two fully-
10

---

Published in Transactions Machine Learning Research (11 (11/2023)
Epoch 0
Epoch 10
Epoch 20
Epoch 30
Epoch 40
Epoch 50
Figure 3: t-SNE visualization depicting the learned representations of EKDAA, shown for Epoch (initial weights) through and up to the final training epoch for FMNIST.
connected baselines - an MLP trained by backprop and one trained by LRA-E (Ororbia & Mali 2019 Comparable BP results are shown only to provide intuition how well the constructed models could perform if trained with precise gradients. We find EKDAA performs competitively with the other algorithms and exhibits both increased train and test accuracy on the natural color images, i.e., SVHN and CIFAR-10. Additionally, when testing EKDAA with the signum activation, we find the resulting CNN operates with the non-differentiable function successfully on FMNIST.
Figure 3 shows the t-SNE plots of the outputs of the last layer of a CNN across epochs, to demonstrate how EKDAA disentangles the feature space of Fash- ion MNIST. The t-SNE plots were generated every 10th epoch and visualized using default t-SNE pa- rameters (i.e. no tuning) with a perplexity value of 30 and the maximum mumber of iterations set to 1000. Qualitatively, we find EKDAA successfully learns to group features together with primarily con- volutional layers, indicating the error kernels learned are indeed benefiting the CNN. Figure 1 shows the train and test learning curves of BP and EKDAA (plotting accuracy as function of epoch for the best configuration of the model using each algorithm).
Model Accuracy over Epochs on Fashion MNIST
Accuracy
Train
EXDAA Train
EXDAA Test
Best
Best EXDAA
Epochs
Figure 4: FMNIST train and test accuracy curves for BP and EKDAA.
While many biologically-plausibb. alternatives have also been developed to learn models of natural images, many of them incorporate error derivatives as part of the process and the architectures they are generally applied to have been designed with multiple, large fully-connected layers with only a few convolutional layers. We argue adding many fully-connected layers corrupts the input signal such that the model is engaged in a greedy optimization resulting in fitting to noise rather than extracting useful features. The role of convolution in such models is still debatable and, as result, it difficult to determine if model performance results from the bio-plausible lcarning mechanism or from the fully-connected layers. In contrast, EKDAA emphasizes the role of convolutional filters in extracting useful features while reducing fully-connected elements. Our results on the three datasets examined above validate that this approach still yields models that generalize well.
Limitations. The main limitation of the proposed EKDAA algorithm is currently its scalability to massive datasets, especially when compared with highly optimized tensor computations imple- mented standard deep learning libraries that support backprop-baad convolution/ corvolttion/deconvlltuio /econvoutioon operations. Due to the current lack of advanced optimizations compared to frameworks such as TensorFlow and PyTorch, supported by large tech companies, EKDAA is not as efficient, thus requiring more computational resources than the established frameworks. Based on our practical experience with our custom library that implements EKDAA, it does not scale easily to very large
11

---

Published in Transactions on Machine Learning Research (11/2023)
networks with many filters given our constrained computational budget and hardware. Specifically, wC used one Ubuntu 18.01 server with 8GB Tesla P1, an Intel Xcon CPU E5-2650, and 256GB of RAM. Future work includes further modularizing our EKDAA library, focusing to improve the algorithm's ability to scale to datasets like ImageNet (Deng et al. 2009). despite limited resources.
Broader Impacts. Backprop generally works well on a carcfully paramcterized network, yet it has a few drawbacks. For example, it requires computing gradients layer-by-layer, enforcing strict requirements on information flow, iee needing to propagate in only a feed-forward fashion (lateral connections make no sense for backprop). Local learning mechanisms do not have these restrictions, facilitating the exploration of novel network structures and exotic forms of propagation flow.
We introduce a novel framework for training images without the need for backprop. While our pro- posed scheme is limited with scale and speed compared to the highly optimized tensor computations implemented in modern deep learning libraries, this work serves as a foundation for exploring local learning for images. We introduce EKDAA, which learns error kernels from local layers to better represent image data in backprop-free manner. While various bio-plausible methodologies have been developed in recent years, their learning rules tend to focus on fully-connected layers. Some methods use convolution, but often fix randomly initialized filters or use backprop to train those layers. With learnable error kernels, we introduce way to transfer error signals through model's convolutional layers while not requiring gradient information like backprop. EKDAA updates are local and circumvent the weight transport problem. Continued work in this area may have pro- found impacts on future model development by alleviating backprop's 's severe restrictions while still providing the ability to model highly complex, high-dimensional data such as natural color images.
5 Conclusion
We have presented an initial exploration of a back-propagation--fre convolutional neural network lcarning algorithm. We implemented a local feedback mechanism that transmits information across layers to compute target activity values and relevant error neuron maps (independent of activa- tion function type), resulting in Hebbian-like update rules for the convolutional filters of a CNN. Specifically, this credit assignment process was made possible by introducing a mechanism that we call the error kernel, which provides a means to reverse filter error neuron activity signals and complements the normal filters used to extract features in convolutional models. We refer to our proposed process as the error-kernel driven activation alignment (EKDAA) method.
We compared various algorithms in training small CNN and found that EKDAA outperforms other bio-inspired alternatives on natural color images for classification on the datasets tested. No- tably, our method offers several benefits: 1) it resolves the major bio-implausibility of the weight transport problem, 2) works with non-differentiable activities, and 3) is relatively computationally efficient since it can operate in a layer-wise parallel/asya asycchooooouhs fashion. Our experiments demon- strate that FKDAA learns "good" representations during training and, furthermore, we found that an EtDAAAtrriined CNN acquires latent representations that improve over time (cpochs) as train- ing evolves. In addition, we find that EKDAA has similar computational and memory requirements backprop, while exhibiting similar convergence behavior. While there is still much to explore in future work, we have successfully presented an analysis of the novel EKDAA algorithm, yielding promising evidence that it can train convolutional networks without backprop. Future directions to expand this work involve expanding to larger, more complex architectures and imaging data, as well as a study of the properties a Hebbian-based algorithm like EKDAA offer over backprop. The implication of this could have far-reaching effects in the future designs of CNN architectures.
12

---

Published in Transactions Machine Learning Research (11/2023)
References
Mohamed Akrout, Collin Wilson, Peter C Humphreys, Timothy Lillicrap, and Douglas Tweed. Deep learning without weight transport. arXiv preprint arXiv:1904.0530 05391, 2019.
Sergey Bartunov, Adam Santoro, Blake Richards, Luke Marris, Geoffrey E Hinton, and Timo- thy Lillicrap. Asscssing the scalability of salogically-mooivatted deep learning algorithms and architectures. In Advances in Neural Information Processing Systems, pp. 3368-9378, 2018.
Tien Chu, Kamil Mykitiuk, Miron Szewezyk, Adam Wiktor, and Zbigniew Wojua. Training dnns in (1) memory with mem-dfa using random matrices. arXiv preprint arXiv:2012.11745,, 2020.
Andy Clark. Surfing uncertainly: Prediction, action, and the embodied mind. Oxford University Press, 2015.
Brian Crafton, Abhinav Parihar, Evan Gebhardt, and Arijit Raychowdhury, Direct feedback align- ment with sparse connections for local learning. Frontiers in neuroscience, 13:525, 2019.
Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on compuler vision and poltern recognition, pp. 218 118-255.11 IEEE, 2009.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arxiv:2010.1 11929, 2020.
John Carew Eccles. From electrical to chemical transmission in the central nervous system: the closing address of the sir henry dale centennial symposium cambridge, 19 september 1975. Notes and records of the Royal Society of London, 30(2):219-23)) 2200, 1976.
Charlotte Frenkel, Martin Lefebvre, and David Bol. Learning without feedback: Fixed random learning signals allow for feedforward training of deep neural networks. Frontiers in Neuroscience, 15:20, 2021.
Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neu- ral networks. In In Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS'00.. Society for Artificial Intelligence and Statistics, 2010.
Leopold Grinberg, John Hopfield, and Dmitry Krotov. Local unsupervised learning for image analysis. arXiv preprint arXiv: 100.0099080 2019.
Stephen Grossberg. Competitive learning: From interactive activation to adaptive resonance. Cog- nitive Science, 11(1):23 63, 1987. doi: http:///oooooor///01111//11111/0 100. URL 1551 1987 www.................
https://omliieelrraryy http://www.....o.o..o./ooo/o/aaa
Jordan Guerguicv, Timothy P Lillicrap, and Blake A Richards. Towards deep learning with segre- gated dendrites. Elife, 6:e22901, 2017.
Donghyeon Han, Gwangtae Park, Junha Ryu, and Hoi-jun Yoo. Extension of direct feedback alignment to convolutional and recurrent neural network for bio-plausible deep learning. arXiv preprint ar Xiv:2000 12830, 2020.
13

---

Published in Transactions Machine Learning Research (11/2023)
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceadings of the IEEE conference on computer vision and pattern recognition, pp- 770-778, 2016.
Donald Olding Hebb. The organization of behavior; a neuropsycholocigal theory. A Wiley Book in Clinical Psychology, 62:78, 1949.
Max Jaderberg, Wojciech Marian Czarnecki, Simon Osindero, Oriol Vinyals, Alex Graves, David Silver, and Koray Kavukcuoglu. Decoupled neural interfaces using synthetic gradients. In Inter- national Conference on Machine Learning, pp. 1627-1635. PMI.R, 2017.
Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2017.
Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. The cifar-10 dataset. online: http://uuun cs. toronto. adu/kriz/ciee cifar. html, 55, 2014.
BJ Lansdell, PR Prakash, and KP Kording. Learning to solve the credit assignment problem. arXiv preprint Xiv: 1::::1000.0000 1906. 00889, 2019.
Dong-Hynn Hyun Lee, Saizheng Zhang, Asja Fischer, and Yoshua Bengio. Difference target propagation, 2015.
Timothy Lillicrap, Adam Santoro, Luke Marris, Colin Akerman, and Gcoffrey Hinton. Back- propagation and the brain. Nature Reviews Neuroscience, 21 (6):333 -335-346, 2020.
TP Lillicrap, D Cownden, DB Tweed, and C Akerman. Random synaptic feedback weights support error backpropagation for deep learning. Nature Communications, 7(13276):1-10, 2016.
Seppo Linnainmaa. The representation of the cumulative rounding error of an algorithm as a taylor expansion of the local rounding errors. Master's Thesis (in Finnish), Univ. Helsinki, pp. 6 7, 1970.
Wan-Duo Kurt Ma, J. P. Lewis, and W. Bastiaan Kleijn. The hsic bottleneck: Deep learning without back propaaapo,g,,nn, 2019.
Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wier- stra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint orXiv:1912.5000 2013.
Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Read- ing digits in natural images with unsupervised fcature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldi stanford.edul
huuseuuberrs/ppp22211ouuuuue hww.shumbers.....ommm........... pdf
Arild Nøkland and Lars Hiller Eidnes. Training neural networks with local error signals. In International Conference on Machine Learning, pp. 1839-4850. PMLR, 2019.
Arild Nøkland. Direct feedback alignment provides learning in deep neural networks, 2016.
Alexander G Ororbia and Ankur Mali. Biologically motivated algorithms for propagating local tar- get representations. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 1651-, 2019.
14

---

Published in Transactions Machine Learning Research (11 (11/2023)
Alexander G Ororbia, Ankur Mali, Daniel Kifer, and C Lee Giles. Conducting credit assignment by aligning local representations. arXiv preprint arXiv:1803.01850 2018.
Alexander G Ororbia, Ankur Mali, Daniel Kifer, and C Lee Giles. Backpropagatiionfies deep learning with recursive local representation alignment. In Proceadings of the AAAI Conference on Artificial Intelligence, volume 37, pp. 9327-9335, 2023.
Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International conference on machine learning, pp. 1318-138. PMLR, 2013.
Rajesh PN Rao and Dana H Ballard. Predictive coding in the visual cortex: functional interpre- tation of some extra-classical receptive-field effects. Nature neuroscience, 2(1):79 87, 1999.
Tim Salimans, Jonathan Ho, Xi Chen, Szymon Sidor, and llya Sutskever. Evolution strategics as a scalable alternative to reinforcement learning. arXiv preprint arXiv:1703.03880 2017.
Tommaso Salvatori, Ankur Mali, Christopher L Buckley, Thomas Lukasiewicz, Rajesh PN Rao, Karl Friston, and Alexander Ororbia. Brain-inspired computational intelligence via predictive coding. arXiv preprint orXiv:2308.078. 07870, 2023.
Jürgen Schmidhuber. Networks adjusting networks. In Proceedings of Distributed Adaptive Neural Information Processing', pp. 197- 197-208, 1990.
Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint ar arxiv:1409 1556, 2014.
Thomas C Südhof and Robert C Malenka. Understanding synapses: past, present, and future.
Neuron, 60(3):169-17) 2008.
T. Ticleman and G. Hinton. Lecture 6.5 15-RRmsrop:: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.
Naftali Tishby, Fernando C Percira, and William Bialek. The information bottleneck method. arXiv preprint physics/0004000 2000.
Paul J Werbos. Applications of advances in nonlinear sensitivity analysis. In System modeling and optimization, pp. 762-770. Springer, 1982.
Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: novel image dataset for bench- marking machine learning algorithms, 2017.
Will Xiao, Honglin Chen, Qianli Liao, and Tomaso Poggio. aoaloicaally-plnsibbee learning algo- rithms can scale to large datasets. arxiv preprint arXiv:1811.03565 2018.
Appendix
A Experimental Setup Details
We performed a grid search for all of the models investigated in this work order find opti- mal meta-parameters and extract optimal behavior for cach. Primarily, tuned hyper-parameters included: batch size, learning rate, filter size, number of filters per layer, number of fully-connected
15

---

Published in Transactions Machine Learning Research (11/2023)
modes/units per layer, weight initialization, choice of optimizer, and the dropout rate. Note that this work does not aim to obtain statc-of-the-art image classification results. Rather, its intent is to present method that efficiently tackles the credit assignment issues in convolution neural net- work (CNN) by effectively operating with our proposed error kernel mechanism. Furthermore, our method offers additional flexibility in design choices (such as permitting the use of non-differentiable activation functions).
Meta-parameter Tuning:
We report our grid search ranges for each model's meta-paramelers in Tables 2 (EKDAA), 7 (DFA), 6 (FA), 9 (RDFA), and g (SDFA), respectively. Furthermore, in the "Best" column, we report the final values selected used for the models reported in the main paper.
Architecture Design: In Table 4 we present the architectures used across the learning algo- rithms investigated in this paper, i.e., the proposed EKDAA, A, feedback alignment (FA, also referred to as RFA in the main paper), direct feedback alignment (DFA), sparse direct feedback alignment (SDFA), and random direct feedback alignment (RDFA). We built the models for Fashion MNTST, SVHN, and CIFAR-10 to include several layers of convolution (conv), with a sizeable amount of filters, and only small (in terms of dimensionality) fully-connected (fc) layers to focus the learning process on adapting/ using the model kernels /filtes/filters to extract useful features from the input image signals. In particular, the model for SVHN and CIFAR-10 had multiple layers with 128 filters per layer and, before flattening the activities for the fully-connected layers, the image size was reduced using three max pooling layers in order to propagate forward the image to obtain a [4x4] resolution.
General Comments/ Discussion: With respect to the main paper's results, what is significant about our findings is that EKDAA demonstrates that adjusting the synaptic weight parameters of a CNN is possible using recurrent error synapses formulated as error kernels themselves. This means that the target feature map values (and the error neuron maps that calculate the distance between the original feature maps and these targets) inherent to backprop-free computational process provide useful teaching signals that facilitate the learning of useful neural vision architectures. The main results of our paper provide promising initial evidence that EKDAA can serve as potentially useful bio-inspired alternative to backprop for training CNNs on natural images.
B
Asset Usage
We build our codebase on top of TensorFlow 2.0 for fundamental functionality. TensorFlow is open-source with an Apache license. In addition, for analysis we use the publicly available Fashion- MNIST, SVHN, and CIFAR-10 datasets, all of which have licenses permitting unlimited and modification. In addition, none of the datascts used in this study entail any data that could be considered sensitive (thus not requiring data consent) or offensive.
16

---

Published in Transactions Machine Learning Research (11 (11/2023)
C
Notation
Variable
Definition
X
input to layer /
AX;
signal from the output of layer /
Y
ground truth corresponding X
Hi
pre-activation of layer post-activation layer weights layer
Zi
W
weights a layer with feature map [m, mi] weight updates for layer
AW;
Vane
extract all scalar elements in the jth slice of the 2nd order Tensor V
convolutional error kernels for layer I error signal update for error kernels for layer I error weights matrix for layer I
Ae
F
A Fi
signal update for learning rate for learnable parameter updates
weights matrix for layer /
complete of trainable parameters {Wo Wi, Eo eq ei)
complete of pre- and post- activations {ho h2, 20 21 tuneable parameter control signal strength through layers tuneable parameter control error signal strength for
Operator
Definition
equality
variable assignment
X
absolute value of X slice of tensor object
convolution operator deconvolution operator Hadamard product
matrix/vecton multiplication
transpose
activation function
softmax activator
Pmp
max pooling operator
Pup
up-sampling to pre-pooling size
(X)p(X)
transpose X across æ and axis
Flatten(X)
X is converted to an equivalent columu vector
UnFlatten(X)
X is reshaped into its pre-flattened shape
Table 3: Table of all notations with their respective definitions.
Model and Training Specifications
Layer
Fashion MNIST
Fashion MNIST Output
SVHN/CIFARE
SVHN/CIFAR-I 10 Output
LO
Input
28, 28, 1]
Input
3,32, 32,
L1
Couvl (1, 32) [3
28, 28, 32]
3] Conv2 (64, 64)
Couvl (3, 64)
b 32, 32, 64
L2
MaxP1 (2,
14,
[3 3]
b. 32, 64
L3
Conv2 (32, 64) 3]
14, 64
MaxP1 (2,
B. 16, 16, 64
T.4
MaxP2 (2,
64]
Conv3 (64, 64) [8
E. 16, 16, 64
Conv3 (64, 128) [3 x 3]
7, 128]
Conv4 (64, 128)
[3 3]
1, 16, 16, 128
Flatten()
6272
MaxP2 (2, 2)
E, 8, 8, 128
FC1 (6272, 128)
128]
Conv5 (128, 128)
x
E, 8, 8, 128
Softmax (128, 10)
f 10]
Conv6 (128, 128)
x 3
B, 8, 8, 128
L9
MaxP3 (2, 2)
F, 4, 4, 128
L10
Flatten()
1. 2048]
L11
FC1 (2048, 128)
1. 128]
L12
Softmax (128, 10)
8. 10
Table 4: Model architectures that were trained on Fashion MNIST, SVHN, and CIFAR-10. The layers of each model defined well as the outputs from each layer.
17

---

Published in Transactions Machine Learning Research (11 (11/2023)
Parameter
Range Min
Range Max
Interval
Activation Functions
Best
batch size
250
learning rate
le-5
1e-2
0.5
Ge-4
filter size
2
num filters
32
256
32
te_pe layer
128
128
128
weight init
glorot uniform, glorot normal
glorot uniform
optimizer
tanh, relu, signum
tanh
dropout
0.0
0.5
0.1
0.1 conv, 0.3 fc
Table 5: Hyper-parameter tuning ranges and best found parameters for EKDAA.
Parameter
Range Min
Range Max
Increment
Activation Functions
Best
batch size
32
learning rate
Ge-5
3e-2
0.5
Ge-4
filter size
3
2
3
num filters
32
256
fc fe_err__ layer 128
128
128
weight init
glorot uniform, glorot normal
glorot normal
optimizer
tanh, relu
relu
dropout
0.0
0.5
0.1
0.1 conv, 0.3 fc
Table 6: Hyper-parameter tuning ranges and best found parameters for FA.
Parameter
Range Min
Range Max
Increment
Activation Functions
Best
batch size
learning rate
Ge-5
3e-2
5e-3
filter size
3
7
3
num filters
32
256
32
fe_per__ayer layer
128
128
128
weight init
glorot uniform, glorot normal
glorot uniform
optimizer
tanh, relu
relu
dropout
0.0
0.5
0.1
0.1 conv, 0.2 fc
Table 7: Hyper-parameter tuning ranges and best found parameters for DFA.
Parameter
Range Min
Range Max
Increment
functions
Best
batch size
learning rate
5e-5
36-2
filter size
3
7
3
num filters
32
256
32
@e_eer___ layer
128
128
128
weight init
glorot uniform, glorot normal
glorot uniform tanh
optimizer
tanh, relu
dropout
0.0
0.5
0.1
0.1 conv, 0.1 fc
Table 8: Hyper-parameter tuning ranges and best found parameters for SDFA.
Parameter
Range Min
Range Max
Increment
functions
Best
batch size
32
learning rate
5c-5
3c-2
0.5
4e-3
filter size
3
num filters
32
256
32
fe_ fe_per__aar layer
128
128
128
weight_ init
glorot__unifort uniform, glorot_ normal
glorot glorot_normal normal
optimizer
tanh, relu
relu 0.2 conv, 0.3 fe
dropout
0.0
0.5
0.1
Table 9: Hyper-parameter tuning ranges and best found parameters for RDFA.
18


Reviews:
[{"review_id": "lwfDD9dANt", "reviewer": "Reviewer_BQsB", "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- EKDAA is a novel credit assignment algorithm and is of interest to the community.\n- EKDAA is empirically compared to a number of relevant biologically-inspired learning rules and performs comparably (indeed better for the specific architectures tested).\n- EKDAA is tested with a non-differentiable activation function and found to perform well.\n- The detailed algorithm is clearly presented. \n\n**Major Weaknesses**\n1. It is unclear which components of the proposed algorithm relate specifically to CNNs and which are contributions relevant for biologically plausible credit assignment in general. In my opinion, if these two were disentangled, for example in a section describing and applying EKDAA to fully connected layers, the paper would be strengthened considerably. \n2. The paper would be strengthened by a more careful and detailed contextualization of EKDAA with regard to existing work. To my understanding EKDAA is a hybridization of feedback alignment and target propagation: error maps are propagated backwards via random weights (eq 4) and then used to generate targets (eq 6). The authors should more clearly describe how EKDAA relates to existing work. \n3. Related to the above points, aside from the empirical results, there are no theoretical justifications given for why EKDAA should result in loss function minimization, nor why the error kernel parameters are updated as in (eq 8).\n4. I am concerned as to how strong the baselines are, eg. it is possible to obtain >90% test accuracy for cifar 10 with small resnets. \n5. The network architecture is custom to this work and it is unknown how EKDAA will work with other commonly used architectures. The authors rightly point that larger networks will require a larger computational budget, however for general interest I think it is important to demonstrate EKDAA generally performs well with other CNN architectures (for example including also more biologically inspired ones such as cornet). This is essential if the authors wish to claim that EKDAA outperforms other bio-inspired alternatives as they do in the conclusion. \n6. The authors state that in EKDAA the forward and backward activities share as minimal information as possible, and as a result this helps the model better overcome poor initialisation and stabilization issues. Could the authors clarify what they mean by information here, and either provide experiments or theory justifying this claim (there are currently neither in my opinion), or remove the statement. \n\n**Minor weaknesses**\n- Given that biological plausibility is a key motivating factor a discussion on how deconvolution operation relates to biology would strengthen the paper. \n- I expect that EKDAA will not scale to harder datasets like imagenet given the difference between BP on FMNIST vs SVHN.\n- Line 4 citation formatting error (Sudhof and Malenka 2008)\n- In section 2 related work 2nd paragraph, the authors claim that they are extending hebbian learning to CNNs. I do not think EKDAA approach fits the neuroscience definition of hebbian learning. Could this be clarified?  \n- In section 2 related work 3rd paragraph the authors list previous work and write that they belong to a different class of algorithms than their work because they require weight transport. This is inaccurate, eg Akrout 2019.\n- Statement that CNNs continue to set benchmark standards should be caveated given ViTs are SOTA in many applications.\n- Surrogate gradients are an alternative way to “appease backprop-centric optimization” with non-differentiable activation functions. As does Target prop. At times the paper suggests that EKDAA a (novel) solution by omitting this. \n- Inference dynamics paragraph, typo “the, the”.\n- End of section 2, query typo, should be “EKDAA introduces the notion of error an *map*”.\n- No empirical justification or citation is given for the claim that fc layers are not able to learn fashion mnist. Fc layers ((infinite width) are universal function estimators. \n- No link to the code.", "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 authors propose an algorithm for training convolutional neural networks called error-kernel driven activation alignment (EKDAA). EKDAA is motivated from the perspective of biologically plausible credit assignment for CNNs: instead of back propagation, parameter updates are computed using target feature maps calculated from errors that are propagated backwards through the network via error kernels. EKAA is compared to a number of (more than backprop) biologically plausible credit assignment algorithms on FMNIST, CIFAR-10, SVHN and is found to perform slightly better than these alternatives for the architectures used in this paper.  As far as I am aware this is a novel contribution to biologically plausible credit assignment literature.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "Addressing the major weaknesses listed above would be required for my recommendation for acceptance. Addressing the minor would strengthen the work.", "broader_impact_concerns": "None", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "awZSLlhrMH", "reviewer": "Reviewer_a4sM", "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": "The main strength of the paper lies in its empirical improvements over other backprop-free methods. Finding practical Hebbian-like learning rules is an important task for identifying biologically plausible learning rules.\n\nA weakness is that the rational behind the \"error-kernels\" is poorly explained. The authors write that the error-kernels are \" a type of neuron specialized for computing mismatch signals inspired by predictive processing brain theory Clark (2015),\" but given that this appears to be the paper's key contribution, a more thorough explanation of the motivation seems in order.\n\nIn light of the above, I may misunderstand the method, but I am not sure it lives up to the claims of being Hebbian-like or biologically plausible. My understanding is that a key feature of the Hebbian learning rule is its dependence only on local information. On the other hand, the proposed approach seems to partly mirror backpropagation (see eqns 3-6) by tracing back the signal from the last to the first layer, although using propagation via the error kernels instead of the weight matrices. Thus, the authors' claim that their method \"offers a direct, local Hebbian-like, non-differentiable rule, (thus circumventing backprop’s need for a global feedback pathway)\" seems misleading.\n\nThe claim that their method \"works well with systems based on convolution\" also seems exagerated since its use loses most of the benefits of convolutional layers in the CIFAR-10 experiments.\n\nRelated to the above, there are multiple vague claims of superiority of the proposed method, such as \n\n\"Oftentimes, appeasing backprop requires certain constraints that prevent us from easily designing mechanisms that facilitate sparsity, interpretability, adversarial-resistance, probabilistic interpretation, etc. Back-propagation requires computing gradients layer-by-layer enforcing strict requirements for propagation flow such as needing to propagate\nin only a feed-forward flow (i.e. lateral connections make no sense for back-propagation). Local\nlearning mechanisms do not have these restrictions and allow for exploration into novel propagation\nflow.\" \n\nThese claims should be substantiated further.\nIt appears that the proposed method also involves a backward flow of information. Further, reverse mode automatic differentiation can compute the gradient of any function that is the concatenation of differentiable functions so I am not sure what to make of these claims.\nSimilarly, the authors mention the vanishing/exploding gradient problem but it is unclear if the proposed method circumvents this problem or whether it simply doesn't occur due to the small size of the networks used. \n\nThe limited size of the experiments is further explained with \"The main limitation of the proposed EKDAA algorithm is currently related its scalability to massive datasets, especially when compared with highly optimized tensor computations\nthat are implemented in standard deep learning libraries that support backprop-based convolution/deconvolution operations.\" \n\nI think that this point should be explained in more detail. In particular, since the authors later suggest that the main bottleneck is memory. It is unclear to me what effect optimization has on the ", "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 reviewed work proposes an alternative for the backpropagation with the goal of being more biologically plausible. \n\nThe proposed approach, \"error-kernel driven activation alignment (EKDAA)\" learns \"error-kernels\" that are used to compute gradient-like quantities to update the network's weights.\n\nThe method is shown to perform slightly better than other backdrop alternatives on FMNIST, SVHN, and CIFAR-10.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "The concerns discussed as weaknesses above concern the core contribution of the paper. I believe they need to be clarified before the paper is published. I would furthermore encourage the authors to add a section providing a clear discussion of what, mathematically, their criteria for biological plausibility are. \n\nI look forward to the authors' response and hope it will help me better understand their contribution.", "broader_impact_concerns": "As discussed under weaknesses, some of the claims in the broader impacts appear overstated and/or excessively vague. ", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "20DTG4WK0p", "reviewer": "Reviewer_B7BR", "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": "The subject matter of this paper aligns with the interests of TMLR's audience, and the authors clearly articulate the work's motivation. However, several weaknesses detract from its overall impact.\n- The paper has several vague and not concise statements, making it challenging to follow. There are also numerous formatting issues (for example, inconsistency in the use of \\citep and \\citet) that disrupt the reading flow and should be addressed.\n- The authors should provide a stronger justification for why their proposed method works. The current version of the manuscript lacks a clear motivation for the equations introduced, and there is no justification or proof to support the method's effectiveness.\n- I have several concerns regarding the experimental results. These are elaborated in the \"Requested Changes\" section below.\n", "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": "This paper presents the Error-Kernel Driven Activation Alignment (EKDAA) algorithm, an approach aimed at solving the weight transport problem in deep learning algorithms. The weight transport problem refers to the fact that, in current deep learning algorithms, the computation of gradients via backpropagation requires knowledge of feed-forward activities. The EKDAA overcomes this issue by utilizing locally derived error transmission kernels and error maps to train Convolutional Neural Networks (CNNs). The paper demonstrates the effectiveness of EKDAA by applying it to Fashion MNIST, CIFAR-10, and SVHN benchmarks, showing higher performance than existing biologically plausible algorithms.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "- Certain sections of the paper, including the introduction, related work, and main methodology, require significant rewriting for enhanced clarity. This should also include fixing formatting issues (e.g., inconsistencies in the use of \\citet and \\citep) and typos (e.g., in Figure 2, where \"(Left:)\" should be changed to \"(Left)\").\n- As previously mentioned, I urge the authors to provide more robust justifications for the functionality of their proposed methods. These could take the form of additional theoretical analysis, examples, or comparisons with standard approaches.\n- The reported performance of networks learned with backpropagation is surprising, given that they typically approach near 100% accuracy on the training set. Is this a result of the authors using a smaller architecture than is standard for the task, thereby leading to an underparameterized model? Also, the higher performance of EKDAA over networks learned with backpropagation on the FashionMNIST dataset is intriguing and somewhat challenging to accept without additional evidence or explanation.\n- It appears that the search ranges for EKDAA and the baseline methods (e.g., Random FA and Direct FA) differ. Could the authors clarify the rationale behind employing different schemes for these approaches? In addition, it would be informative to know how many search spaces were explored for each baseline method.\n- It would also be useful to show the learning curves (e.g., number of iterations vs. training loss) to understand the convergence. ", "broader_impact_concerns": "I don't have any concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Meta-review: The reviewers highlighted a number of concerns around clarity, justification, and some of the evaluations. The authors did a sufficiently good job of attending to these concerns to lead all three reviewers to recommend acceptance. However, the authors should perform a final check to make sure that they have incorporated all of the outstanding changes promised (e.g. switching to a regular GitHub codebase) before final acceptance.
Decision: Accept (poster)