hi there. Today, we're looking at back propagation in the brain by Timothy Lilly, Corrupt Adam Santoro, Luke Morris, Colin Ackerman, and Geoffrey Hinton. So, this is a bit of an unusual paper for the machine learning community, but nevertheless, it's interesting. And let's be honest, at least half of our interest comes from the fact that Geoffrey Hinton is one of the authors of this paper. So, this is a paper that basically proposes a hypothesis on how the algorithm of back propagation works in the brain because previously there has been a lot of evidence against there being something like back propagation in the brain. So, the question is how do neural networks in the brain learn? And they say there can be many different ways that neural networks learn, and they list them up in this kind of diagram where you have a network and it maps from input to output by having these weighted connections between neurons. So, the input is two-dimensional, and then it maps using these weights to a three-dimensional hidden layer, and usually, there is a nonlinear function.

somewhere at the output here of these, so they do a weighted sum of the inputs, and then they do a nonlinear function, and then they propagate that signal to the next layer, and till then to finally to the output. All right, so how do these networks learn? The one way of learning is called Hebbian learning. The interesting thing here is that it requires no feedback from the outside world. Basically, what you want to do in Hebbian learning is you want to update the connections such that they kind of match their own previous outputs or even increase their own previous outputs. So, you propagate a signal, and then maybe this neuron spikes really hard, and this spikes really low. Then, if you propagate the signal again, right, then you want to match those activations, or if you properly similar signals, no feedback required. So, basically, it's a self-amplifying or self-dampening process. Ultimately, though, you want to learn something about the world, and that means you have to have some feedback from outside, right? So, with

feedback. What we mean is usually that the output here. Let's look this way. The output here goes into the world. Let's say this is a motor neuron, right? You do something with your arm, like you hammer on a nail, and then you either hit the nail or you don't. Let's say you don't hit the nail, so after it looks like crooked there, you have feedback, right? So feedback usually in the form of some sort of error signal, right? So feedback, it can be like this was good or this was bad, or it can be this was a bit too much to the left, or so on. The important part is you get kind of one number of feedback, right? How bad you were, and now your goal is to adjust all of the individual neurons or weights between neurons such that the error will be lower. So in Hebbian learning, there is no feedback. It's just simply a self-reinforcing pattern activation machine. In the first instances of perturbation learning, what you'll have is you'll have one single

feedback, and that you can see this is a diffuse cloud here. What you're basically saying is that every single neuron is kind of punished, let's say the feedback here was negative one. That means every single neuron is punished for that. So how you can imagine something if you have your input X and you map it through your function f, then the function f has a way to w1 and so on, right? So you map X through it, right? And then you get feedback of negative 1, and then you map X with a little bit of noise plus M, right? Da-da-da-dah, and you get a feedback of negative 2, right? Then you, you, that means that the direction of this noise was probably a bad direction. So ultimately, you want to update X into the direction of negative that noise by modulated, of course, by some factor here. That's, that, it kind of tells you how bad it was. So this could be the negative 2 minus negative 1. Now that makes big sense. No, yes, that would be no, it would be.

negative 1 minus negative nevermind so basically with a scalar feedback, you simply tell each neuron what it did right or sorry if the entire network right. The entire network did right or wrong, so the entire network will lead to this feedback. You don't have accountability of the individual neurons. All you can say is that whatever I'm doing here is wrong and whatever I'm doing here is right, so I'm gonna do more of the right things now. In back propagation, it is very different, right? In back propagation, what you'll do is you'll have your feedback here, let's say that's negative 1, and then you do a reverse computation. So the forward computation in this case was this weighted sum of this layer. Now usually layer-wise reverse computation, which means that you know how this function here, this output, came to be out of the inputs, and that means you can inverse and you can do an inverse propagation of the error signal, which is of course the gradient. So this would be your... you would derive

your error by the inputs to the layer, right? So, this basically tells in the backpropagation algorithm, you can exactly determine if you are this node. How do I have to adjust my input weights? How do I have to adjust them in order to make this number here go down, right? And then, because you always propagate the error according to that, what you'll have in each layer is basically a vector target. So, it's no longer just one number, but each layer now has a target of vectors, and it says, Okay, these are the outputs that would be beneficial. Please, this layer, please change your outputs in the direction of negative two, negative three, plus four. So, you see, this is so the negative two would be this unit, the negative three would be this unit, and the plus four would be this unit. So, each unit is instructed individually to say, Please, this is the direction that each unit should change in order to make this number go lower. You see how this is much more information than the perturbation learning in the perturbation learning.

All the units simply know well the four was bad and now is better. So let's, you know, change a bit. And here you have detailed instructions for each unit because of the back propagation algorithm. So ultimately, people have kind of thought that since back propagation wasn't really possible with biological neurons, that the brain might be doing something like perturbation learning. But this paper argues that something like back propagation is not only possible but likely in the brain. And they proposed this kind of backdrop-like learning with the feedback network. So they basically concern all the, they differentiate hard between these two regimes here. In this hand, you have the scalar feedback, which means that the entire network gets one number as a feedback, and each neuron just gets that number. And here you have vector feedback, where each neuron gets an individual instruction of how to update. And they achieve this not by back propagation, because still the original formulation of back prop as we use it in neural networks is not biologically plausible, but they achieve this with this backdrop-like learning with the

feedback network, and we'll see how this does, but in essence, this feedback network is constructed such that it can give each neuron in the forward pass here detailed instructions on how to update itself, right? So yeah, they have a little bit of a diagram here of if you do Hebbian, if this is an error landscape, if you do Hebbian learning, you basically, you don't care about the error, you're just reinforcing yourself. If you do perturbation learning, then it's very slow because you don't have a detailed signal, you just rely on this one number. It's kind of if you were to update every single neuron in your neural network with reinforcement learning, considering the output of the neural networks or the error, considering that the reward, not using backprop, and then with backprop, you'd have a much smoother, much faster optimization trajectory. So they looked at this, and they come to some conclusions. First of all, so here's backprop basically saying backprop, as we said, you have the forward

pass, and there you simply compute these weighted averages, and you also pass them usually through some sort of nonlinear activation, right? And the cool thing about this is in artificial neural networks is that once the error comes in, you can exactly reverse that. So you can do a backward pass of errors where you can propagate these errors through because you know it's kind of invertible. The function doesn't have to be invertible, but that the gradients will flow backwards if you know how the forward pass was computed. So first of all, they go into a discussion of backprop in the brain. How can we even expect that? And one cool piece of evidence is where I find is that they cite several examples where they use artificial neural networks to learn the same tasks as humans, right? And or as animal brains. And then I have no clue how they measure any of this, but then they compare the hidden representations of the living neural networks and the artificial neural networks. And it turns out that these networks that were trained with backpropagation x

then networks that were not trained with backdrop. So basically, that means if you train a network with backprop, it matches the biological networks much closer in how they form their hidden representations. And they cite the number of experiments here that show this. So this gives you very good evidence that if the hidden representations look as if they had been computed by backdrop and not by any of these scalar update algorithms. So it is conceivable that we find backprop in the brain. That's why they go here next. They go into problems with backdrops. So basically, why would we, why so far have we believed that backprop isn't happening in the brain. So now let's, I want to highlight two factors here that I find a thinker suffice state. They have more, but first of all, backprop demands synaptic symmetry in the forward and backward paths, right? So basically, if you have a neuron and it has output to another neuron, what you need to be able to do is

to pass back information along that neuron, so it kind of has to be a symmetric connection idea of the forward and the backward pass, and these need to be exact right, and this is just not. If you know how neurons are structured, they have kind of input dendrites, and then there's this accent act action potential, and along the axon, the signal travels, and the back traveling of the signal just I think is very is very very slow if even possible, and so it's generally not invertible or inverse compute capable. So, this is one reason why that prop seems unlikely, and then the second reason here is error signals are signed and potentially extreme valued, and I want to add to that they also just talk about this somewhere that error signals are of a different type, right? That's a different type. So, first, let's see what signed error signals are signed. Yes, we need to be able to adjust neurons in specific directions, right? If you look at again what we've drawn before here, we said here this is how these neurons must must

update so the first neuron must decrease by two. This must decrease by three, and this must increase by four. Now in the background, we need this, but if we assume that there is something like a reverse computation or signaling here happening, then we still have the problem that usually these output signals are in the form of spiking rates, which means that over time, right? So if a neuron wants to, if a neuron has zero activation, there's just no signal. But if a neuron has a high activation, it spikes a lot. If it has a low activation, it kind of spikes sometimes. Well, what he can do is negative spike, right? Like zero is as low as it goes. So the thought that there are signed information in the backward pass is inconceivable, even if you have something like a second. So you can imagine here instead of this backward connection because of the symmetry problem, we have some kind of second neural network that goes in this direction. Still, you'd have the problem that here you can only have positive signal or a zero, and they might be

extreme valued which okay it can't be really encoded with the spiking because they are they're limited in the range they can assume but they are also of a different type and I'm what I mean by that is basically if you think of this as a programming problem then the forward passes here are our activations right and the backward passes here they are deltas so in the backward passes view either propagate deltas or you propagate kind of directions so the activations are sort of impulses whereas the backward signals are this isn't how you need to change their their gradients ultimately so it's fundamentally a different type of data that is propagated along would be propagated along these directions and that makes it very unlikely because we are not aware as this paper says that the that neural networks that neurons can kind of switch the data type that they're they're transmitting all right so then the paper goes into their end grad hypothesis and what this is the hypothesis basically states that the brain could implement something like neural networks by using by using an

approximate backdrop-like algorithm based on autoencoders. And I want to jump straight into the algorithm. No, actually, first, they do talk about autoencoders, which I find very interesting. So, if you think of autoencoders, what is an autoencoder? An autoencoder is a network that basically starts out with an input layer and then has a bunch of hidden layers. And at the end, it tries to reconstruct its own input, right? So, you feed data in here, you get data out here, and then your error, the error signal, it will be your difference to your original input. Now, usually, when we train autoencoders in deep learning, we also train this by backprop, right? We see then this error here, and this goes back. But if you just think of single-layer autoencoders, so, um, let's go over here, single-layer autoencoder with, let's say, the same number of units in this layer. What you'll have is, so, this is input, this is output, and this is the

hidden layer right. You'll have a weight matrix here, and you'll probably have some sort of nonlinear function, and then you have another weight matrix here, and they call them W and B. Another way to draw this is I have a weight matrix going up, then I have a nonlinear function transforming this into this signal, and then I have the B going back right. So I'm drawing it in two different ways up here or over here, and with the second way, you can see that it is kind of a forward-backward algorithm where now the error, if you look at what is the error here, the error is the difference between this and this, and the difference between this and this, and the difference between this and this, right? And you can train an autoencoder simply by saying, W, please make sure that the input here gets mapped closer to the output and to be the same thing. This will become clear in a second, so but basically, sorry, this, I mean the hidden representations. You'll see basically the idea is that

you can train an autoencoder only by using local update rules. You don't have to do back prop, and that's what this algorithm is proposing. Namely, if you think of a stack of autoencoders, this transforming one hidden representation into the next, right? This is the feed-forward function. What you can do is, first of all, you can assume that for each of these functions here, you have a perfect inverse, right? You can perfectly compute the inverse function. That's this G here. Of course, this doesn't exist, but assume you have it. What you then could do is, if you knew in one layer and on the top layer, of course, you know, if you knew that, Okay, I got this from my forward pass, but I would like to have this. This is my desired output, right? So, in the output layer, you get this. This is your error signal. If you knew, you could compute an error right here. This is what you do in the output, right? Now, in back prop, we would back propagate this error along the layers, but now we

don't do this. Instead of what we do, is we use this G function to invert the F function, right? And by that, what we'll say is what hidden representation in layer two, what should the hidden representation have been, that in order for us to obtain this thing, right? So the claim here is if in layer two we had had H two as a hidden representation, then we would have landed exactly where we want it, right? That's what this G function does. Because here we use F, so had we had F h2 and used F on it, we would be exactly where we want. Instead, we had h2 here and used F on it, and then we landed here where we don't want. So this is where we want, we would want to be in layer two, and this is where we were. So again, we can compute an error here. Again, instead of back propagating that error, what we'll do is we'll use the inverse of the forward function in order to back propagate our desired hidden representation. And you can see there is, of course, a relationship to the

true back prop here, but the important distinction is we are not trying to back propagate the error signal. We're trying to invert the desired hidden states of the network, and then in each layer we can compute from the forward pass. We can compute the difference to the desired hidden state and thereby compute an error signal. And now we have achieved what we wanted. We want an algorithm that doesn't do back prop, that only uses local information in order to compute the error signal that it needs to adjust. And by local, I mean information in the same layer and also the data type that is propagated by F is activations, right, of hidden representations. And by G is also activations of hidden representations. Both of them are always positive, can be encoded by spiking neurons, and so on. So this algorithm achieves what we want. They go a bit into detail how the actual error update here can be achieved. And apparently, neurons can achieve, you know, in the same layer, to adjust themselves to a given desired activation. So this algorithm achieves it. Of course, we don't have this.

G, we don't have it, and therefore we need to go a bit more complicated. What they introduce is the following algorithm. The goals are the same, but now we assume we do not have a perfect inverse, but we have something that is a bit like an inverse. So, we have an approximate inverse, and they basically suggest if we have an approximate inverse, we can do the following. So, G is now an approximate inverse to F. What we can do is this is our input signal, right? We use F to map it forward to this and so on, all the way up until we get our true or error right here. This is our error from the environment, right? This is the nail being wrong, and then we do two applications of G, right? So, this is an application of F. We do two applications of G1. We apply G2, this to what we got in the forward pass, right? And this now gives us a measure of how bad our inverse is, right? So, if G is now an approximate inverse, and this now we see

here oh okay we we had a ch2 in the forward pass and we basically forward passed and then went through our inverse and we didn't land quite exactly where we started but we know that okay this this is basically the difference between our our inverse our forward inverse H and our true H and then we also back project using G again the desired outcome so we invert the desired outcome here now before we have adjusted directly these two right because we said this is what we got this is what we want but now we include for the fact that G isn't a perfect inverse and our assumption is that G here probably makes about the same mistakes as G here so what we'll do is we'll take this vector right here and apply it here in order to achieve this thing and this thing is now the corrected thing our corrected to desired hidden representation correct for the fact that we don't have a perfect inverse and now again we have our error here that we can locally adjust again all the signals propagated here here and here are just neural

activations and all the information required to update a layer of neurons is now contained within that layer of neurons, right? And this goes back through the network. So this is how they achieve this. This is a bit of a close-up look, and here are the computations to do this. So basically, for the forward updates, you want to adjust W into the direction of the H minus the H tilde, and the H tilde in this case would be the hidden representation that you would like to have. So you will update your forward weights into the direction such that your hidden representations are closer—sorry, that your forward hidden representation is closer to your backward hidden representation. And the backward updates, now your goal is to get a more—better to make G. So, sir, W here is our W, or the weight of F and B, or the weights of G. So in the backward updates, your goal is to make G a better inverse, right? So what you'll do is again you'll take the difference between—now you see

the difference here, here, here, right, not the same error. So here you will, you in the W update, use what we labeled error here. In the G update, you use this error here. So this is the error of G. So when you update the function G, you want to make these two closer together such that G becomes a better inverse, right, because you're dealing with an approximate inverse. You still need to obtain that approximate inverse end, and this here is how you learn it. This algorithm now achieves what we wanted, right, local updates, data types, check, signed, check, and so on. I hope this was enough clear. In essence, it's pretty simple, but it's pretty cool how they work around this. They call this a different story with propagation and not these kind of papers. I don't think they invented this, maybe I'm not sure, maybe they did, maybe they didn't, and this paper just kind of frames it in this hypothesis. It is unclear to me. I am not familiar with this kind of papers, so sorry if I miss attribute something here. All right.

then they go into how could these things be implemented biologically, and they go for some evidence. They also state that we used to look at neurons basically in this way, where you had input and feedback here, a very simple, simplistic view of neurons. Whereas nowadays, even the computational community views neurons in a more differentiated way, where you have, for example, different regions here on the soma that can be separated from each other, and you have inter-neuron interference, and so on. I'm not qualified too much to comment on this stuff, but I invite you to read it for yourself if you want. Alright, so this was my take on this paper. I find the algorithm they propose pretty cool. I hope you liked it and check it out. Bye-bye.

Backpropagation and the brain

I make videos about machine learning research papers, programming, and issues of the AI community, and the broader impact of AI in society.

Twitter: https://twitter.com/ykilcher
Discord: https://ykilcher.com/discord
BitChute: https://www.bitchute.com/channel/yannic-kilcher
LinkedIn: https://www.linkedin.com/in/ykilcher
BiliBili: https://space.bilibili.com/2017636191

If you want to support me, the best thing to do is to share out the content :)

If you want to support me financially (completely optional and voluntary, but a lot of people have asked for this):
SubscribeStar: https://www.subscribestar.com/yannickilcher
Patreon: https://www.patreon.com/yannickilcher
Bitcoin (BTC): bc1q49lsw3q325tr58ygf8sudx2dqfguclvngvy2cq
Ethereum (ETH): 0x7ad3513E3B8f66799f507Aa7874b1B0eBC7F85e2
Litecoin (LTC): LQW2TRyKYetVC8WjFkhpPhtpbDM4Vw7r9m
Monero (XMR): 4ACL8AGrEo5hAir8A9CeVrW8pEauWvnp1WnSDZxW7tziCDLhZAGsgzhRQABDnFy8yuM9fWJDviJPHKRjV4FWt19CJZN9D4n


