생물학적 신경망의 역전파 가설

### 뇌의 역전파 탐구: 새로운 가설
* 🧠 티모시 릴리와 제프리 힌튼을 비롯한 동료들이 작성한 이 논문에서는 생물학적 신경망에는 이러한 메커니즘이 존재하지 않는다는 기존의 믿음에 도전하며, **뇌에서 역전파가 어떻게 작동하는지에 대한 가설**를 제안합니다.
* 🔄 저자는 다양한 학습 방법을 소개하며, **헤비안 학습은 외부 피드백이 없는 대신 뉴런 활성화의 자기 강화**에 의존한다는 점에서 주목할 만합니다.
* 📉 반면 섭동 학습과 같은 피드백 메커니즘은 전체 네트워크에 단일 오류 신호를 제공하므로 **각 뉴런에 대한 역전파의 세부 지침보다 효율성이 떨어집니다.**
* ⚙ 이 논문은 기존의 역전파가 생물학적으로 타당하지 않지만, **특정 피드백에 따라 개별 뉴런을 업데이트**할 수 있는 배경과 같은 학습 메커니즘이 존재할 수 있다고 주장합니다.
* 🔍 연구팀은 역전파로 훈련된 신경망이 생물학적 네트워크와 밀접하게 일치한다는 증거를 제시하며, **역전파와 유사한 과정이 뇌에 존재할 수 있음을 시사**합니다.
* ⚖ 저자는 **시냅스 대칭의 필요성, 역신호 과정을 복잡하게 만드는 오류 신호의 특성** 등 생물학에서 역전파에 대한 도전 과제에 대해 논의합니다.
* 📈 궁극적으로는 로컬 업데이트를 허용하고 필요한 데이터 유형을 유지하여 생물학적 구현에 더 적합한 **자동 인코더를 사용하는 대략적인 배경과 유사한 알고리즘**을 제안합니다.
* 🔬 이 논문은 신경세포 기능과 학습 과정에 대한 이해의 변화를 반영하여 **이러한 메커니즘이 생물학적으로 어떻게 나타날 수 있는지에 대한 추가 탐색**을 촉구하며 마무리합니다.

제프리 힌튼의 논문은 신경 학습에 대한 기존의 가정에 도전하는 역전파형 학습이 뇌에서 일어날 수 있다고 제안합니다.

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




Yannic Kilcher

이 논문은 신경망의 핵심 알고리즘인 역전파가 뇌에서 어떻게 작동하는지에 대한 가설을 제안합니다.

외부 피드백이 필요 없는 헤비안 학습을 비롯한 신경망의 다양한 학습 방법을 설명합니다.

저자는 환경으로부터의 피드백이 학습에 매우 중요하며, 오류 신호에 따라 신경 연결을 조정하여 향후 결과를 개선하는 과정을 설명합니다.

스칼라 피드백과 역전파의 차이점

스칼라 피드백은 전체 네트워크에 단일 오류 신호를 제공하여 가중치를 전반적으로 조정하는 반면, 역전파는 개별 뉴런에 오류 신호에 따라 가중치를 업데이트하는 방법에 대한 자세한 지침을 제공합니다.

역전파는 역방향 계산을 사용하여 기울기를 결정하고 오류를 전파하여 각 레이어에 대한 벡터 타겟을 생성합니다.

이 논문은 뉴런에 개별 지침을 제공하는 피드백 네트워크를 통한 배경 학습이 뇌의 학습 메커니즘일 가능성이 높다고 주장하며, 역전파가 생물학적으로 믿을 수 없다는 개념에 도전합니다.

신경망에서의 역전파와 그 역할

인공 신경망의 역전파는 가중 평균을 계산하고 비선형 활성화를 사용하여 오류의 역전파를 허용합니다.

역전파를 통해 훈련된 네트워크의 숨겨진 표현은 생물학적 네트워크의 표현과 매우 유사하여 뇌에서 역전파가 일어날 수 있다는 증거를 제공합니다.

그러나 역전파에 필요한 대칭성과 뉴런의 오류 신호의 특성으로 인해 생물학적 시스템에서의 가능성에 대한 의문이 제기되고 있습니다.

두뇌의 대략적인 역전파 알고리즘

이 논문은 신경망에서 전파되는 고유한 데이터 유형에 대해 설명하며, 활성화를 임펄스로, 역방향 신호를 그라데이션으로 설명합니다.

이 논문에서는 뇌가 자동 인코더에 기반한 대략적인 역전파 유사 알고리즘을 사용하여 신경망을 구현할 수 있다는 '엔드 그래디언트 가설'을 제시합니다.

이 알고리즘은 오류 신호를 계산하고 숨겨진 표현을 변환하기 위해 완벽한 역함수를 사용하여 로컬 업데이트 규칙으로 자동 인코더 스택을 훈련할 것을 제안합니다.

G 함수는 F 함수를 반전시켜 레이어 2에서 원하는 숨겨진 표현을 결정하는 데 사용됩니다.

알고리즘은 오류를 역전파하는 대신 순방향 함수의 역을 사용하여 원하는 숨겨진 상태를 계산합니다.

완벽한 역수를 사용할 수 없는 경우 알고리즘은 대략적인 역수를 사용하고 역전 과정의 불완전성을 고려하여 원하는 숨겨진 표현을 조정합니다.

뉴런 레이어 업데이트하기: 독특한 접근 방식

뉴런 레이어를 업데이트하는 데 필요한 정보는 해당 레이어에 포함되어 있으며, 순방향 및 역방향 업데이트가 가능합니다.

순방향 업데이트는 가중치를 조정하여 숨겨진 표현을 더 가깝게 만드는 반면, 역방향 업데이트는 역함수를 더 정확하게 만드는 것을 목표로 합니다.

제안된 알고리즘은 로컬 업데이트를 달성하고 뉴런 기능을 차별화하여 뉴런 상호 작용에 대한 기존의 관점에 도전합니다.