1 Introduction
The suitability of the backpropagation of error (BP) algorithm [32] for explaining learning in the brain was questioned soon after it was popularized [11, 8]. Weaker objections included undesirable characteristics of artificial networks in general, such as their violation of Dale’s Law, their lack of celltype variability, and the need for the gradient signals to be both positive and negative. More serious objections were: (1) The need for the feedback connections carrying the gradient to have the same weights as the corresponding feedforward connections and (2) The need for a distinct form of information propagation (error feedback) that does not influence neural activity, and hence does not conform to known biological feedback mechanisms underlying neural communication. Researchers have long sought biologically plausible and empirically powerful learning algorithms that avoid these flaws [2, 30, 31, 1, 26, 39, 14, 16, 12, 5, 23]. Recent work has demonstrated that the first objection may not be as problematic as often supposed [22]
: the feedback alignment (FA) algorithm uses random weights in backward pathways to successfully deliver error information to earlier layers. At the same time, FA still suffers from the second objection: it requires the delivery of signed error vectors via a distinct pathway.
Another family of promising approaches to biologically motivated deep learning – such as Contrastive Hebbian Learning [24], and Generalized Recirculation [26] – use topdown feedback connections to influence neural activity, and differences in feedfowarddriven and feedbackdriven activities (or products of activities) to locally approximate gradients [1, 31, 26, 39, 4, 36, 38]. Since these activity propagation methods don’t require explicit propagation of gradients through the network, they go a long way towards answering the second serious objection noted above. However, many of these methods require long “positive” and “negative” settling phases for computing the activities whose differences provide the learning signal. Proposals for shortening the phases [13, 6] are not entirely satisfactory as they still fundamentally depend on a settling process, and, in general, any settling process will likely be too slow for a brain that needs to quickly compute hidden activities in order to act in real time.
Perhaps the most practical among this family of “activity propagation” algorithms is target propagation (TP) and its variants [19, 20, 13, 3, 21]. TP avoids the weight transport problem by training a distinct set of feedback connections that define the backward activity propagation. These connnections are trained to approximately invert the computation of the feedforward connections in order to be able to compute target activities for each layer by successively inverting the desired output target. Another appealing property of TP is that the errors guiding weight updates are computed locally along with backward activities.
While TP and its variants are promising as biologicallymotivated algorithms, there are lingering questions about their applicability to the brain. First, the only variant explored empirically (i.e. DTP) still depends on explicit gradient computation via backpropagation for learning the penultimate layer’s outgoing synaptic weights (see Algorithm Box 1 in Lee et al. [21]
). Second, they have not been rigorously tested on datasets more difficult than MNIST. And third, they have not been incorporated into architectures more complicated than simple multilayer perceptrons (MLPs).
On this second point, it might be argued that an algorithm’s inability to scale to difficult machine learning datasets is a red herring when assessing whether it could help us understand learning in the brain. Performance on isolated machine learning tasks using a model that lacks other adaptive neural phenomena – e.g., varieties of plasticity, evolutionary priors, etc. – makes a statement about the lack of these phenomena as much as it does about the suitability of an algorithm. Nonetheless, we argue that there is a need for behavioural realism, in addition to physiological realism, when gathering evidence to assess the overall biological
realism of a learning algorithm. Given that human beings are able to learn complex tasks that bear little relationship to their evolution, it would appear that the brain possesses a powerful, generalpurpose learning algorithm for shaping behavior. As such, researchers can, and should, seek learning algorithms that are both more plausible physiologically, and scale up to the sorts of complex tasks that humans are capable of learning. Augmenting a model with adaptive capabilities is unlikely to unveil any truths about the brain if the model’s performance is crippled by an insufficiently powerful learning algorithm. On the other hand, demonstrating good performance with even a vanilla artificial neural network provides evidence that, at the very least, the learning algorithm
is not limiting. Ultimately, we need a confluence of evidence for: (1) the sufficiency of a learning algorithm, (2) the impact of biological constraints in a network, and (3) the necessity of other adaptive neural capabilities. This paper focuses on addressing the first two.In this work our contribution is threefold: (1) We examine the learning and performance of biologicallymotivated algorithms on MNIST, CIFAR, and ImageNet. (2) We introduce variants of DTP which eliminate significant lingering biologically implausible features from the algorithm. (3) We investigate the role of weightsharing convolutions, which are key to performance on difficult datasets in artificial neural networks, by testing the effectiveness of locally connected architectures trained with BP and variants of FA and TP.
Overall, our results are largely negative. That is, we find that none of the tested algorithms are capable of effectively scaling up to training large networks on ImageNet. There are three possible interpretations from these results: (1) Existing algorithms need to be modified, added to, and/or optimized to account for learning in the real brain, (2) research should continue into new physiologically realistic learning algorithms that can scaleup, or (3) we need to appeal to other adaptive capacities to account for the fact that humans are able to perform well on this task. Ultimately, our negative results are important because they demonstrate the need for continued work to understand the power of learning in the human brain. More broadly, we suggest that behavioural realism, as judged by performance on difficult tasks, should increasingly become one of the metrics used in evaluating the biological realism of computational models and algorithms.
2 Learning in Multilayer Networks
Consider the case of a feedforward neural network with
layers , whose activations are computed by elementwiseapplying a nonlinear function to an affine transformation of previous layer activations :(1) 
with input to the network denoted as and the last layer used as output.
In classification problems the output layer parametrizes a predicted distribution over possible labels , usually using the softmax function. The learning signal is then provided as a loss incurred by making a prediction for an input , which in the classification case can be crossentropy between the groundtruth label distribution and the predicted one: The goal of training is then to adjust the parameters in order to minimize a given loss over the training set of inputs.
2.1 Backpropagation
Backpropagation [32]
was popularized as a method for training neural networks by computing gradients with respect to layer parameters using the chain rule:
Thus, gradients are obtained by first propagating activations forward to the output layer via eq. 1, and then recursively applying these backward equations. These equations imply that gradients are propagated backwards through the network using weights symmetric to their feedforward counterparts. This is biologically problematic because it implies a mode of information propagation (error propagation) that does not influence neural activity, and that depends on an implausible network architecture (symmetric weight connectivity for feedforward and feedback directions, which is called the weight transport problem).
2.1.1 Feedback alignment
While we focus on TP variants in this manuscript, with the purpose of a more complete experimental study of biologically motivated algorithms, we explore FA as another baseline. FA replaces the transpose weight matrices in the backward pass for BP with fixed random connections. Thus, FA shares features with both target propagation and conventional backpropagation. On the one hand, it alleviates the weight transport problem by maintaining a separate set of connections that, under certain conditions, lead to synchronized learning of the network. On the other hand, similar to backpropagation, FA transports signed error information in the backward pass, which may be problematic to implement as a plausible neural computation. We consider both the classical variant of FA [23] with random feedback weights at each hidden layer, and the recently proposed Direct Feedback Alignment [25] (DFA) or Broadcast Feedback Alignment [35], which connect feedback from the output layer directly to all previous layers directly.
2.1.2 Target propagation and its variants
Unlike backpropagation, where backwards communication passes on gradients without inducing or altering neural activity, the backward pass in target propagation [19, 20, 3, 21]
takes place in the same space as the forwardpass neural activity. The backward induced activities are those that layers should strive to match so as to produce the target output. After feedforward propagation given some input, the final output layer
is trained directly to minimize the loss , while all other layers are trained so as to match their associated targets.In general, good targets are those that minimize the loss computed in the output layer if they had been realized in feedforward propagation. In networks with invertible layers one could generate such targets by first finding a lossoptimal output activation (e.g. the correct label distribution) and then propagating it back using inverse transformations . Since it is hard to maintain invertibility in a network, approximate inverse transformations (or decoders) can be learned . Note that this learning obviates the need for symmetric weight connectivity.
The generic form of target propagation algorithms we consider in this paper can be summarized as a scheduled minimization of two kinds of losses for each layer.

Reconstruction or inverse loss is used to train the approximate inverse that is parametrized similarly to the forward computation: where activations are assumed to be propagated from the input. One can imagine other learning rules for the inverse, for example, the original DTP algorithm trained inverses on noisecorrupted versions of activations with the purpose of improved generalization. The loss is applied for every layer except the first, since the first layer does not need to propagate target inverses backwards.

Forward loss penalizes the layer parameters for producing activations different from their targets. Parameters of the last layer are trained to minimize the task’s loss directly.
Under this framework both losses are local and involve only a single layer’s parameters, and implicit dependencies on other layer’s parameters are ignored. Variants differ in the way targets are computed.
Target propagation
“Vanilla” target propagation (TP) computes targets by propagating the higher layers’ targets backwards through layerwise inverses; i.e. . For traditional categorization tasks the same 1hot vector in the output will always map back to precisely the same hidden unit activities in a given layer. Thus, this kind of naive TP may have difficulties when different instances of the same class have different appearances, since it will attempt to make their representations identical even in the early layers. As well, there are no guarantees about how TP will behave when the inverses are imperfect.
Difference target propagation
Both TP and DTP update the output weights and biases using the standard delta rule, but this is biologically unproblematic because it does not require weight transport [26, 23]. For most other layers in the network, DTP [21] computes targets as
(2) 
The second term is the error in the reconstruction, which provides a stabilizing linear correction for imprecise inverse functions. However, in the original work by Lee et al. [21] the penultimate layer target, , was computed using gradients from the network’s loss, rather than by target propagation. That is, , rather than . Though not stated explicitly, this approach was presumably taken to ensure that the penultimate layer received reasonable and diverse targets despite the lowdimensional 1hot targets at the output layer. When there are a small number of 1hot targets (e.g. 10 classes), learning a good inverse mapping from these vectors back to the hidden activity of the penultimate hidden layer (e.g. 1000 units) might be problematic, since the inverse mapping cannot provide information that is both useful and unique to a particular input sample . Using BP in the penultimate layer sidesteps this concern, but deviates from the intent of using these algorithms to avoid gradient computation and delivery.
Simplified difference target propagation
We introduce SDTP as a simple modification to DTP. In SDTP we compute the target for the penultimate layer as , where , i.e. the correct label distribution. This completely removes biologically infeasible gradient communication (and hence weighttransport) from the algorithm. However, it is not clear whether targets for the penultimate layer will be diverse enough (given low entropy classification targets) or precise enough (given the inevitable poor performance of the learned inverse for this layer). The latter is particularly important if the dimensionality of the penultimate layer is much larger than the output layer, which is the case for classification problems with a small number of classes. Hence, this modification is a nontrivial change that requires empirical investigation. In Section 3
we evaluate SDTP in the presence of lowentropy targets (classification problems) and also consider the problem of learning an autoencoder (for which targets are naturally highdimensional and diverse) in the supplementary material.
Auxiliary output SDTP
As outlined above, in the context of 1hot classification, SDTP produces only weak targets for the penultimate layer, i.e. one for each possible class label. To circumvent this problem, we extend SDTP by introducing a composite structure for the output layer , where is the predicted class distribution on which the loss is computed and is an auxiliary output vector that is meant to provide additional information about activations of the penultimate layer . Thus, the inverse computation can be performed conditional on richer information from the input, not just on the relatively weak information available in the predicted and actual label.
The auxiliary output is used to generate targets for penultimate layer as follows:
(3) 
where is the predicted class distribution, is the correct class distribution and produced from is used in both inverse computations. Here can be interpreted as a modification of that preserves certain features of the original
that can also be classified as
. Here parameters can be still learned using the usual inverse loss. But parameters of the forward computation used to produce are difficult to learn in a way that maximizes their effectiveness for reconstruction without backpropagation. Thus, we studied a variant that does not require backpropagation: we simply do not optimize the forward weights for , so is just a set of random features of .Parallel and alternating training of inverses
In the original implementation of DTP^{1}^{1}1https://github.com/donghyunlee/dtp/blob/master/conti_dtp.py
, the authors trained forward and inverse model parameters by alternating between their optimizations; in practice they trained one loss for one full epoch of the training set before switching to training the other loss. We considered a variant that simply optimizes both losses in parallel, which seems nominally more plausible in the brain since both forward and feedback connections are thought to undergo plasticity changes simultaneously — though it is possible that a kind of alternating learning schedule for forward and backward connections could be tied to wake/sleep cycles.
2.2 Biologicallyplausible network architectures
Convolutionbased architectures have been critical for achieving state of the art in image recognition [18]
. These architectures are biologically implausible, however, because of their extensive weight sharing. To implement convolutions in biology, many neurons would need to share the values of their weights precisely — a requirement with no empirical support. In the absence of weight sharing, the “locally connected” receptive field structure of convolutional neural networks is in fact very biologically realistic and may still offer a useful prior. Under this prior, neurons in the brain could sample from small areas of visual space, then pool together to create spatial maps of feature detectors.
On a computer, sharing the weights of locally connected units greatly reduces the number of free parameters and this has several beneficial effects on simulations of large neural nets. It improves generalization and it drastically reduces both the amount of memory needed to store the parameters and the amount of communication required between replicas of the same model running on different subsets of the data on different processors. From a biological perspective we are interested in how TP and FA compare with BP without using weight sharing, so both our BP results and our TP and FA results are considerably worse than convolutional neural nets and take far longer to produce. We assess the degree to which BPguided learning is enhanced by convolutions, and not BP per se, by evaluating learning methods (including BP) on networks with locally connected layers.
3 Experiments


In this section we experimentally evaluate variants of target propagation, backpropagation, and feedback alignment [23, 25]
. We focused our attention on TP variants. We found all of the variants we explored to be quite sensitive to the choice of hyperparameters and network architecture, especially in the case of locallyconnected networks. With the aim of understanding the limits of the considered algorithms, we manually searched for architectures well suited to DTP. Then we fixed these architectures for BP and FA variants and ran independent hyperparameter searches for each learning method. Finally, we report best errors achieved in 500 epochs. For additional details see Tables
3 and 4 in the Appendix.For optimization we use Adam [15], with different hyperparameters for forward and inverse models in the case of target propagation. All layers are initialized using the method suggested by Glorot & Bengio [10]. In all networks we used the hyperbolic tangent as a nonlinearity between layers as it was previously found to work better with DTP than ReLUs [21].
3.1 Mnist
To compare to previously reported results we began with the MNIST dataset, consisting of grayscale images of handdrawn digits. The final performance for all algorithms is reported in Table 1 and the learning dynamics are plotted in Figure 8 (see Appendix). Our implementation of DTP matches the performance of the original work [21]. However, all variants of TP performed slightly worse than BP, with a larger gap for SDTP, which does not rely on any gradient propagation. Interestingly, alternating optimization of forward and inverse losses consistently demonstrates more stable learning and better final performance.
3.2 Cifar10
CIFAR10 is a more challenging dataset introduced by Krizhevsky [17]. It consists of RGB images of 10 categories of objects in natural scenes. In contrast to MNIST, classes in CIFAR10 do not have a “canonical appearance” such as a “prototypical bird” or “prototypical truck” as opposed to “prototypical 7” or “prototypical 9”. This makes them harder to classify with simple template matching, making depth imperative for achieving good performance. The only prior study of biologically motivated learning methods applied to this data was carried out by Lee et al. [21]; this investigation was limited to DTP with alternating updates and fully connected architectures. Here we present a more comprehensive evaluation that includes locallyconnected architectures and experiments with an augmented training set consisting of vertical flips and random crops applied to the original images.
Final results can be found in Table 1. Overall, the results on CIFAR10 are similar to those obtained on MNIST, though the gap between TP and backpropagation as well as between different variants of TP is more prominent. Moreover, while fullyconnected DTPalternating roughly matched the performance of BP, locallyconnected networks presented an additional challenge for TP, yielding only a minor improvement.
The issue of compatibility with locallyconnected layers is yet to be understood. One possible explanation is that the inverse computation might benefit from a form that is not symmetric to the forward computation. We experimented with more expressive inverses, such as having larger receptive fields or a fullyconnected structure, but these did not lead to any significant improvements. We leave further investigation of this question to future work.
As with MNIST, a BP trained convolutional network with shared weights performed better than its locallyconnected variant. The gap, however, is not large, suggesting that weight sharing is not necessary for good performance as long as the learning algorithm is effective.
We hypothesize that the significant gap in performance between DTP and the gradientfree SDTP on CIFAR10 is due to the problems with inverting a lowentropy target in the output layer. To validate this hypothesis, we ran AOSDTP with 512 auxiliary output units and compare its performance with other variants of TP. Even though the observed results do not match the performance of DTP, they still present a large improvement over SDTP. This confirms the importance of target diversity for learning in TP (see Appendix 5.5 for related experiments) and provides reasonable hope that future work in this area could further improve the performance of SDTP.
Feedback alignment algorithm performed quite well on both MNIST and CIFAR, struggling only with the LC architecture on CIFAR. In contrast, DFA appeared to be quite sensitive to the choice of architecture and our architecture search was guided by the performance of TP methods. Thus, the numbers achieved by DFA in our experiments should be regarded only as a rough approximation of the attainable performance for the algorithm. In particular, DFA appears to struggle with the relatively narrow (256 unit) layers used in the fullyconnected MNIST case — see Lillicrap et al. [23] Supplementary Information for a possible explanation. Under these conditions, DFA fails to match BP in performance, and also tends to fall behind DTP and AOSDTP, especially on CIFAR.
3.3 ImageNet
We assessed performance of the methods on the ImageNet dataset [33], a largescale benchmark that has propelled recent progress in deep learning. To the best of our knowledge, this is the first empirical study of biologicallymotivated methods and architectures conducted on a dataset of such scale and difficulty. ImageNet has 1000 object classes appearing in a variety of natural scenes and captured in highresolution images (resized to ).
Final results are reported in Table 2. Unlike MNIST and CIFAR, on ImageNet all biologically motivated algorithms performed very poorly relative to BP. A number of factors could contribute to this result. One factor may be that deeper networks might require more careful hyperparameter tuning; for example, different learning rates or amounts of noise injected for each layer.
A second factor might be a general incompatibility between the mainstream design choices for convolutional networks with TP and FA algorithms. Years of research have led to a better understanding of efficient architectures, weight initialization, and optimizers for convolutional networks trained with backpropagation, and perhaps more effort is required to reach comparable results for biologically motivated algorithms and architectures. Addressing both of these factors could help improve performance, so it would be premature to conclude that TP cannot perform adequately on ImageNet. We can conclude though, that outofthebox application of this class of algorithms does not provide a straightforward solution to real data on even moderately large networks.
We note that FA demonstrated an improvement over TP, yet still performed much worse than BP. It was not practically feasible to run its sibling, DFA, on large networks such as one we used in our ImageNet experiments. This was due to practical necessity of maintaining a large fullyconnected feedback layer of weights from the output layer to each intermediate layer. Modern convolutional architectures tend to have very large activation dimensions, and the requirement for linear projections back to all of the neurons in the network is practically intractable: on a GPU with 16GB of onboard memory, we encountered outofmemory errors when trying to initialize and train these networks using a Tensorflow implementation. Thus, the DFA algorithm appears to require either modification or GPUs with more memory to run with large networks.
4 Discussion
Historically, there has been significant disagreement about whether BP can tell us anything interesting about learning in the brain [8, 11]. Indeed, from the mid 1990s to 2010, work on applying insights from BP to help understand learning in the brain declined precipitously. Recent progress in machine learning has prompted a revival of this debate; where other approaches have failed, deep networks trained via BP have been key to achieving impressive performance on difficult datasets such as ImageNet. It is once again natural to wonder whether some approximation of BP might underlie learning in the brain [22, 5]. However, none of the algorithms proposed as approximations of BP have been tested on the datasets that were instrumental in convincing the machine learning and neuroscience communities to revisit these questions.
Here we studied TP and FA, and introduced a straightforward variant of the DTP algorithm that completely removed gradient propagation and weight transport. We demonstrated that networks trained with SDTP without any weight sharing (i.e. weight transport in the backward pass or weight tying in convolutions) perform much worse than DTP, likely because of impoverished output targets. We also studied an approach to rescue performance with SDTP. Overall, while some variants of TP and FA came close to matching the performance of BP on MNIST and CIFAR, all of the biologically motivated algorithms performed much worse than BP in the context of ImageNet. Our experiments are far from exhaustive and we hope that researchers in the field may coordinate to study the performance of other recently introduced biologically motivated algorithms, including e.g. [28, 27].
We note that although TP and FA algorithms go a long way towards biological plausibility, there are still many biological constraints that we did not address here. For example, we’ve set aside the question of spiking neurons entirely to focus on asking whether variants of TP can scale up to solve difficult problems at all. The question of spiking networks is an important one [35, 12, 7, 34], but it should nevertheless be possible to gain algorithmic insight to the brain without tackling all of the elements of biological complexity simultaneously. Similarly, we also ignore Dale’s law in all of our experiments [29]. In general, we’ve aimed at the simplest models that allow us to address questions around (1) weight sharing, and (2) the form and function of feedback communication. However, it is worth noting that our work here ignores one other significant issue with respect to the plausibility of feedback communication: BP, FA, all of the TP variants, and indeed most known activation propagation algorithms (for an exception see Sacramento et al. [34]), still require distinct forward and backward (or “positive” and “negative”) phases. The way in which forward and backward pathways in the brain interact is not well characterized, but we’re not aware of existing evidence that straightforwardly supports distinct phases.
Nevertheless, algorithms that aim to illuminate learning in cortex should be able to perform well on difficult domains without relying on any form of weight sharing. Thus, our results offer a new benchmark for future work looking to evaluate the effectiveness of biologically plausible algorithms in more powerful architectures and on more difficult datasets.
Acknowledgments
We would like to thank Shakir Mohamed, Wojtek Czarnecki, Yoshua Bengio, Rafal Bogacz, Walter Senn, Joao Sacramento, James Whittington, and Benjamin Scellier for useful discussions.
References

Ackley et al. [1985]
Ackley, David H, Hinton, Geoffrey E, and Sejnowski, Terrence J.
A learning algorithm for boltzmann machines.
Cognitive science, 9(1):147–169, 1985.  Almeida [1990] Almeida, Luis B. A learning rule for asynchronous perceptrons with feedback in a combinatorial environment. In Artificial neural networks, pp. 102–111. IEEE Press, 1990.
 Bengio [2014] Bengio, Yoshua. How autoencoders could provide credit assignment in deep networks via target propagation. arXiv preprint arXiv:1407.7906, 2014.
 Bengio & Fischer [2015] Bengio, Yoshua and Fischer, Asja. Early inference in energybased models approximates backpropagation. arXiv preprint arXiv:1510.02777, 2015.
 Bengio et al. [2015] Bengio, Yoshua, Lee, DongHyun, Bornschein, Jorg, Mesnard, Thomas, and Lin, Zhouhan. Towards biologically plausible deep learning. arXiv preprint arXiv:1502.04156, 2015.
 Bengio et al. [2016] Bengio, Yoshua, Scellier, Benjamin, Bilaniuk, Olexa, Sacramento, Joao, and Senn, Walter. Feedforward initialization for fast inference of deep generative networks is biologically plausible. arXiv preprint arXiv:1606.01651, 2016.

Bengio et al. [2017]
Bengio, Yoshua, Mesnard, Thomas, Fischer, Asja, Zhang, Saizheng, and Wu,
Yuhuai.
Stdpcompatible approximation of backpropagation in an energybased model.
Neural computation, 2017.  Crick [1989] Crick, Francis. The recent excitement about neural networks. Nature, 337(6203):129–132, 1989.
 Dumoulin & Visin [2016] Dumoulin, Vincent and Visin, Francesco. A guide to convolution arithmetic for deep learning. arXiv preprint arXiv:1603.07285, 2016.

Glorot & Bengio [2010]
Glorot, Xavier and Bengio, Yoshua.
Understanding the difficulty of training deep feedforward neural
networks.
In
Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics
, pp. 249–256, 2010.  Grossberg [1987] Grossberg, Stephen. Competitive learning: From interactive activation to adaptive resonance. Cognitive science, 11(1):23–63, 1987.
 Guerguiev et al. [2017] Guerguiev, Jordan, Lillicrap, Timothy P, and Richards, Blake A. Towards deep learning with segregated dendrites. ELife, 6:e22901, 2017.
 Hinton [2007] Hinton, G.E. How to do backpropagation in a brain. NIPS 2007 Deep Learning Workshop, 2007.
 Hinton & McClelland [1988] Hinton, Geoffrey E and McClelland, James L. Learning representations by recirculation. In Neural information processing systems, pp. 358–366. New York: American Institute of Physics, 1988.
 Kingma & Ba [2014] Kingma, Diederik and Ba, Jimmy. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.

Körding & König [2001]
Körding, Konrad P and König, Peter.
Supervised and unsupervised learning with two sites of synaptic integration.
Journal of computational neuroscience, 11(3):207–215, 2001.  Krizhevsky [2009] Krizhevsky, Alex. Learning multiple layers of features from tiny images. 2009.
 Krizhevsky et al. [2012] Krizhevsky, Alex, Sutskever, Ilya, and Hinton, Geoffrey E. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
 LeCun [1986] LeCun, Yann. Learning process in an asymmetric threshold network. In Disordered systems and biological organization, pp. 233–240. Springer, 1986.
 LeCun [1987] LeCun, Yann. Modèles connexionnistes de l’apprentissage. PhD thesis, PhD thesis, These de Doctorat, Université Paris 6, 1987.
 Lee et al. [2015] Lee, DongHyun, Zhang, Saizheng, Fischer, Asja, and Bengio, Yoshua. Difference target propagation. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 498–515. Springer, 2015.
 Lillicrap et al. [2014] Lillicrap, Timothy P, Cownden, Daniel, Tweed, Douglas B, and Akerman, Colin J. Random feedback weights support learning in deep neural networks. arXiv preprint arXiv:1411.0247, 2014.
 Lillicrap et al. [2016] Lillicrap, Timothy P, Cownden, Daniel, Tweed, Douglas B, and Akerman, Colin J. Random synaptic feedback weights support error backpropagation for deep learning. Nature Communications, 7, 2016.
 Movellan [1991] Movellan, Javier R. Contrastive hebbian learning in the continuous hopfield model. In Connectionist models: Proceedings of the 1990 summer school, pp. 10–17, 1991.
 Nøkland [2016] Nøkland, Arild. Direct feedback alignment provides learning in deep neural networks. In Advances In Neural Information Processing Systems, pp. 1037–1045, 2016.
 O’Reilly [1996] O’Reilly, Randall C. Biologically plausible errordriven learning using local activation differences: The generalized recirculation algorithm. Neural computation, 8(5):895–938, 1996.
 Ororbia & Mali [2018] Ororbia, Alexander G and Mali, Ankur. Biologically motivated algorithms for propagating local target representations. arXiv preprint arXiv:1805.11703, 2018.
 Ororbia et al. [2018] Ororbia, Alexander G, Mali, Ankur, Kifer, Daniel, and Giles, C Lee. Conducting credit assignment by aligning local representations. arXiv preprint arXiv:1803.01834, 2018.
 Parisien et al. [2008] Parisien, Christopher, Anderson, Charles H, and Eliasmith, Chris. Solving the problem of negative synaptic weights in cortical models. Neural computation, 20(6):1473–1494, 2008.

Pineda [1987]
Pineda, Fernando J.
Generalization of backpropagation to recurrent neural networks.
Physical review letters, 59(19):2229, 1987.  Pineda [1988] Pineda, Fernando J. Dynamics and architecture for neural computation. Journal of Complexity, 4(3):216–245, 1988.
 Rumelhart et al. [1986] Rumelhart, DE, Hinton, GE, and Williams, RJ. Learning representations by backpropagation errors. Nature, 323:533–536, 1986.

Russakovsky et al. [2015]
Russakovsky, Olga, Deng, Jia, Su, Hao, Krause, Jonathan, Satheesh, Sanjeev, Ma,
Sean, Huang, Zhiheng, Karpathy, Andrej, Khosla, Aditya, Bernstein, Michael,
Berg, Alexander C., and FeiFei, Li.
ImageNet Large Scale Visual Recognition Challenge.
International Journal of Computer Vision (IJCV)
, 115(3):211–252, 2015. doi: 10.1007/s112630150816y.  Sacramento et al. [2017] Sacramento, Joao, Costa, Rui Ponte, Bengio, Yoshua, and Senn, Walter. Dendritic error backpropagation in deep cortical microcircuits. arXiv preprint arXiv:1801.00062, 2017.
 Samadi et al. [2017] Samadi, Arash, Lillicrap, Timothy P, and Tweed, Douglas B. Deep learning with dynamic spiking neurons and fixed feedback weights. Neural computation, 2017.
 Scellier & Bengio [2017] Scellier, Benjamin and Bengio, Yoshua. Equilibrium propagation: Bridging the gap between energybased models and backpropagation. Frontiers in computational neuroscience, 11, 2017.
 Springenberg et al. [2014] Springenberg, Jost Tobias, Dosovitskiy, Alexey, Brox, Thomas, and Riedmiller, Martin. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.
 Whittington & Bogacz [2017] Whittington, James CR and Bogacz, Rafal. An approximation of the error backpropagation algorithm in a predictive coding network with local hebbian synaptic plasticity. Neural computation, 2017.
 Xie & Seung [2003] Xie, Xiaohui and Seung, H Sebastian. Equivalence of backpropagation and contrastive hebbian learning in a layered network. Neural computation, 15(2):441–454, 2003.
5 Appendix
5.1 SDTP and AOSDTP algorithm details
In this section, we provide detailed algorithm description for both SDTP and its extension AOSDTP which can be found in Algorithm Box 1 and 2.
In the original DTP algorithm, autoencoder training is done via a noisepreserving loss. This is a well principled choice for the algorithm on a computer [21], and our experiments with DTP use this noisepreserving loss. However, in the brain, autoencoder training would necessarily be denoising, since uncontrolled noise is added downstream of a given layer (e.g. by subsequent spiking activity and stochastic vesicle release). Therefore, in our experiments with SDTP and AOSDTP we use denoising autoencoder training.
One might expect the performance of AOSDTP to depend on the size and the structure of the auxiliary output. We investigated the effect of the auxiliary output size. The results are consistent with the intuition that larger sizes generally lead to better performance, with improvements leveling off once the output is large enough to encode information about the penultimate layer well (see Figure 4).
5.2 Architecture details for all experiments
In this section we provide details on the architectures used across all experiments. The detailed specifications can be found in Table 3.
All locallyconnected architectures consist of a stack of locallyconnected layers (each specified by: receptive field size, number of output channels, stride), followed by one or more fullyconnected layers and an output softmax layer. All locallyconnected layers use zero padding to ensure unchanged shape of the output with
. One of our general empirical findings was that pooling operations are not very compatible with TP and are better to be replaced with strided locallyconnected layers.The locallyconnected architecture used for the ImageNet experiment was inspired by the ImageNet architecture used in [37]. Unfortunately, the naive replacement of convolutional layers with locallyconnected layers would result in a computationallyprohibitive architecture, so we decreased number of output channels in the layers and also removed layers with filters. We also slightly decreased filters in the first layer, from to . Finally, as in the CIFAR experiments, we replaced all pooling operations with strided locallyconnected layers and completely removed the spatial averaging in the last layer that we previously found problematic when learning with TP.
Dataset  Fullyconnected network  Locallyconnected network  
MNIST 



CIFAR 



ImageNet  – 

5.3 Details of hyperparameter optimization
Hyperparameter  Search domain 
Learning rate of model Adam optimizer  
parameter of model Adam optimizer  Fixed to 0.9 
parameter of model Adam optimizer  
parameter of model Adam optimizer  
Learning rate of inverse Adam optimizer  
parameter of inverse Adam optimizer  Fixed to 0.9 
parameter of inverse Adam optimizer  
parameter of inverse Adam optimizer  
Learning rate used to compute targets for in DTP  
Gaussian noise magnitude used to train inverses 
For DTP and SDTP we optimized over parameters of: (1) the forward model and inverse Adam optimizers, (2) the learning rate used to compute targets for in DTP, and (3) the Gaussian noise magnitude used to train inverses. For backprop we optimized only the forward model Adam optimizer parameters. For all experiments the best hyperparameters were found by random searches over 60 random configurations drawn from the ranges specified in table 4. We provide values for the best configurations in table 5.
MNIST, Fullyconnected  
DTP parallel  DTP alternating  SDTP parallel  SDTP alternating  BP  BP ConvNet  FA  DFA  
Model  LR  0.000757  0.000308  0.000402  0.000301  0.000152  0.000168  0.001649  
0.99  0.99  0.99  0.9  0.9  0.9  0.9  
0.95  0.99  0.999  0.95  0.999  0.999  0.95  
Inverse  LR  0.000768  0.004593  0.001101  0.009572  
0.99  0.99  0.99  0.9  
0.999  0.999  0.95  0.95  
0.15008  0.231758  
0.36133  0.220444  0.213995  0.118267  
MNIST, Locallyconnected  
Model  LR  0.000905  0.001481  0.000145  0.000651  0.000133  0.000297  0.000219  0.002462 
0.9  0.9  0.9  0.9  0.9  0.9  0.9  0.9  
0.99  0.99  0.99  0.99  0.99  0.99  0.999  0.99  
Inverse  LR  0.001239  0.000137  0.001652  0.003741  
0.9  0.9  0.9  0.9  
0.999  0.999  0.999  0.99  
0.116131  0.310892  
0.099236  0.366964  0.061555  0.134739  
CIFAR, Fullyconnected  
Model  LR  0.000012  0.000013  0.000129  0.000041  0.000019  0.000025  0.000050  
0.9  0.9  0.9  0.9  0.9  0.9  0.9  
0.999  0.999  0.99  0.99  0.999  0.99  0.99  
Inverse  LR  0.000039  0.000114  0.000011  0.000014  
0.9  0.9  0.9  0.9  
0.99  0.99  0.99  0.99  
0.125693  0.172085  
0.169783  0.134811  0.273341  0.125678  
CIFAR, Locallyconnected  
Model  LR  0.000032  0.000036  0.000020  0.000109  0.000044  0.000133  0.000022  0.000040 
0.9  0.9  0.9  0.9  0.9  0.9  0.9  0.9  
0.99  0.99  0.99  0.99  0.999  0.99  0.999  0.999  
Inverse  LR  0.000852  0.000389  0.000261  1.1e05  
0.9  0.9  0.9  0.9  
0.999  0.999  0.999  0.99  
0.189828  0.208141  
0.146728  0.094869  0.299769  0.023804 
ImageNet, Locallyconnected  
DTP parallel  DTP alternating  SDTP parallel  BP  BP ConvNet  FA  
Model  LR  0.000217  0.000101  0.000011  0.000024  0.000049  0.000043 
0.9  0.9  0.9  0.9  0.9  0.9  
0.99  0.99  0.999  0.999  0.99  0.99  
Inverse  LR  0.000234  0.000064  0.000170  
0.9  0.9  0.9  
0.999  0.999  0.999  
0.163359  0.03706  
0.192835  0.097217  0.168522 
As we pointed out in section 3, the explored learning methods have different sensitivity to hyperparameters. We provide histograms of the best test accuracies reached by different hyperparameter configurations on MNIST and CIFAR for each of the experiments (see Figure 5). We were not able to collect the results for each of the exploratory runs on the ImageNet due to prohibitive demand on computation. In this case, we also started 60 random configurations but after 10 epochs we allowed only the best performing job to continue thereafter.
These experiments demonstrate clearly that BP is the most stable algorithm. TP methods proved to be the most sensitive to the choice of hyperparameters, likely due to complicated interactions between updating forward and inverse weights. Finally, we note that within the TP based method, the alternating update schedule not only reach the better accuracy, but overall led to more stable convergence.
5.4 Implementation details for locallyconnected architectures
Although locallyconnected layers can be seen as a simple generalization of convolution layers, their implementation is not entirely straightforward. First, a locallyconnected layer has many more trainable parameters than a convolutional layer with an equivalent specification (i.e. receptive field size, stride and number of output channels). This means that a simple replacement of every convolutional layer with a locallyconnected layer can be computationally prohibitive for larger networks. Thus, for large networks, one has to decrease the number of parameters to run experiments using a reasonable amount of memory and compute. In our experiments we opted to decrease the number of output channels in each layer by a given factor. Obviously, this can have a negative effect on the resulting performance and more work needs to be done to scale locallyconnected architectures.
Inverse operations
When training locallyconnected layers with target propagation, one also needs to implement the inverse computation in order to train the feedback weights. As in fullyconnected layers, the forward computation implemented by both locallyconnected and convolutional layers can be seen as a linear transformation
, where the matrix has a special, sparse structure (i.e., has a block of nonzero elements, and zeroelements elsewhere), and the dimensionality of is not more than .The inverse operation requires computation of the form , where matrix has the same sparse structure as . However, given the sparsity of , computing the inverse of using would be highly inefficient [9]. We instead use an implementation trick often applied in deconvolutional architectures. First, we instantiate a forward locallyconnected computation , where and are dummy activities and sparse weights. We then express the transposed weight matrix as the gradient of this feedforward operation:
The gradient (and its multiplication with ) can be very quickly computed by the means of automatic differentiation in many popular deep learning frameworks. Hence one only needs to define the forward locallyconnected computation and the corresponding transposed operation is implemented trivially. Note that this is strictly an implementation detail and does not introduce any additional use of gradients or weight sharing in learning.
5.5 Autoencoding and target diversity
Since one of the main limitations of SDTP is target diversity for the penultimate layer, it may be instructive to compare different learning methods on a task that involves rich output targets. A natural choice for such a task is learning an autoencoder with the reconstruction error as a loss.
We set a simple fullyconnected architecture for the autoencoder of the following structure and trained it on MNIST using squared reconstruction error. The training curves can be found in Figure 6. SDTP still demonstrated a tendency to underfit, and did not match performance of DTP and backpropagation. But, visual inspection of reconstructions on the test set of MNIST did not show a significant difference in the quality of reconstructions (see Figure 7), which supports the hypothesized importance of target diversity for SDTP performance.
5.6 Backpropagation as a special case of target propagation
Even though difference target propagation is often contrasted with backpropagation, it is interesting to note that these procedures have a similar functional form. One can ask the following question: that should the targets be in order to make minimization of the learning loss equivalent to a backpropagation update?
Formally, we want to solve the following equation for :
Here we divided the learning loss by 2 to simplify the following calculations. Transforming both sides of the equation, we obtain
from which it follows that
We now expand the latter equation to express through :
Finally, if we define , then a step on the local learning loss in TP will be equivalent to a gradient descent step on the global loss.
The question remains whether this connection might be useful for helping us to think about new learning algorithms. For example, one could imagine an algorithm that uses hybrid targets, e.g. computed using a convex combination of the differential and the pseudoinverse functions:
Continuing the analogy between these two methods, is it possible that the inverse loss could be a useful regularizer when used with ? Practically that would mean that we want to regularize parameters of the forward computation indirectly through its derivatives. Interestingly, in the onedimensional case (where and are scalars) the inverse loss is minimized by .