EPISODE TRANSCRIPT
Backpropagation: Learning Representations by Back-Propagating Errors (Rumelhart, Hinton & Williams)
Automatically transcribed from the episode audio. Some words and names may be inaccurate.
Listen to the episodeDownload textDownload captions
You know, usually when we talk about getting a medical diagnosis, there's this underlying expectation of absolute precision. Right, like it's a math problem. Exactly. It's almost like engineering. You break your arm, you go to the hospital, they take the x -ray, and it shows that really obvious jagged white line on the bone. Yeah, and the doctor just points right at it. Right. They point at it and say, you know, there it is. That is your problem. It's a binary state. Broken or not broken? Very definitive. And honestly, I think that's comforting. We, as humans, we really, really like things to be visible like that. Oh, absolutely. We want to perfectly categorize our problems. Yeah. We want to point to the exact cause of a phenomenon and say with, I mean, absolute certainty, that specific thing right there is the reason this is happening.
But the reality is most things aren't an x -ray. No. They aren't. When you step into the world of complex systems, you look at neurodevelopment or systemic trauma or even like macroeconomics, suddenly that beautiful clean x -ray machine is just totally broken. It's useless. Right. We're looking at a diagnostic landscape that is, well, it's completely murky. You can't just point to a single pixel and find the answer. Because the cause is distributed. Exactly. It's distributed across maybe a hundred different factors. It's hidden in the connections between things. Which is the absolute definition of diagnostic muddy waters. And you know what's so fascinating here is that this exact tension. Yeah. This tension between wanting a clean observable cause and dealing with a really complex hidden reality, that is the precise problem that almost killed the field of artificial intelligence in its infancy.
Wow. Which brings us perfectly to the core of what we're doing today. So welcome to the deep dive. Glad to be here. Today, we are looking at how a small group of researchers back in 1986 figured out how to solve that exact problem of hidden murky causes. And in the process, they accidentally laid the mathematical bedrock for basically every single piece of modern AI that we use today. It's wild to think about. We're unpacking this really legendary paper published in the journal Nature. It was written by David Rumelhart, Jeffrey Hinton, and Ronald Williams.
A truly foundational text. Learning representations by backpropagating errors. Right. And for you listening, we are not just going to skim the surface on this one. We are going to meticulously unpack how these three researchers managed to build an algorithm that allowed a machine to create its own internal representations of the world. Because if you interact with any modern artificial intelligence today, a voice assistant, an image generator, a large language model. Basically anything smart on your phone. Exactly. You are interacting directly with the mathematical descendants of the ideas laid out in this exact 1986 document.
But to really grasp the magnitude of what Hinton, Rumelhart, and Williams achieved, I feel like we have to look at the dark ages they were working in. The AI winter. Right, the AI winter. We have to look at what existed before 1986. The paper spends some time talking about earlier methods, specifically something called a perceptron. Yes, the perceptron convergence procedure. That was the prevailing model for a really long time. And it had some issues, right? It was deeply, deeply flawed. So I was trying to visualize perceptrons while going through the research for this, and I kept picturing them like those really rigid, strict flow charts. Oh, interesting. Like what kind? Like the ones you see in, you know, old 1950s corporate training manuals, where it's like, if X happens, do Y. If Y happens, do Z.
There is absolutely no room for interpretation. That's, yeah. Am I far off there? Were perceptrons basically just rigid flow charts that couldn't read between the lines? That is actually a brilliant way to visualize it. A perceptron was essentially a flat system. You had input data on one side and you wanted an output on the other. Okay. They did have intermediate steps with the researchers called feature analyzers sitting between the input and the output. So there was a middle man. There was, but here is the critical limitation. These intermediate steps were entirely designed by humans. Wait, entirely? Entirely. So a programmer had to sit down and mathematically dictate exactly what the machine should look for. Exactly. The human hard -coded the connections. The state of those intermediate units was completely dictated by the input based on human -made rules. So they didn't really learn anything themselves. No.
They weren't what Rumelhart and his team would call true hidden units. Because they couldn't actually hide anything. They were completely transparent. just blindly following orders. It's like going back to the medical thing, giving someone an x -ray and telling them to look for one highly specific 45 degree white line. And if they don't see exactly that line, they just fail the patient. Even if the bone is clearly shattered in a different way. Exactly. The machine couldn't learn that, hey, maybe a weird shadow over here combined with a tiny hairline fracture over there also means a broken bone. Precisely.
They couldn't learn representations. If the human didn't pre -program the exact feature, the perceptron was completely blind to it. Which seems like a huge bottleneck. It caused a massive stagnation in AI research. In fact, prominent figures like Marvin Minsky and Seymour Papert actually wrote a whole book mathematically proving that perceptrons were fundamentally incapable of solving certain basic logic puzzles. Just because they couldn't learn those hidden features. Exactly. It was a dead end. Which brings us to the breakthrough.
The mission of this 1986 paper was to introduce a new procedure called backpropagation. Yes. And the goal here was to let the network itself decide under what circumstances an intermediate unit should fire. Autonomy. Right. It's the difference between giving a traveler a map with a single red line drawn on it and giving them a compass, a machete, and telling them to just find the most efficient path through the jungle themselves. And that is exactly what the author set out to demonstrate. They wanted a general purpose. relatively simple procedure that was powerful enough to construct appropriate internal representations without a human holding its hand. But to understand how a network actually pulls this off, like how it basically invents abstract concepts out of thin air, we can't just talk in metaphors all day. No, we have to get into the mechanics. Right.
We need to build the machine with you, the listener, right now from the ground up, which means we need to start with how this thing is actually physically or I guess mathematically structured. Let's build the architecture. So the simplest form of this learning procedure applies to what they call layered networks. I want you to visualize a multi -story building. Okay, I'm picturing an office building. Perfect. On the ground floor you have your input layer. And this is where the raw data comes in, right? Right. Then above that you have any number of intermediate floors.
These are the hidden layers. They're the black box of the system. Okay. And finally on the penthouse floor you have the output layer. which gives you your final answer. And there are incredibly strict rules about how these floors communicate with each other, right? Like the researchers were very explicit that connections within a single layer are absolutely forbidden. That's correct. So two nodes sitting right next to each other on the same hidden floor cannot talk to each other at all. No gossiping on the same floor. Right. And furthermore, in this specific model, connections cannot go backward. A higher floor cannot send a signal down to a lower floor. The signal can only flow upward. It's a strictly one -way street, which is why it's called a feed -forward network. Feed -forward, okay. Though I did notice one fascinating little loophole in the rules when I was reading. It says connections can skip intermediate layers. Oh, yes. Good catch.
So the ground floor could theoretically have a direct express elevator to the penthouse, completely bypassing the hidden floors, while other signals have to take the stairs layer by layer. Yes, that's a crucial architectural flexibility. It allows the network to weigh raw data directly against processed data, if it needs to. But let's look at how the actual information moves through this structure. Let's do it. It always starts with an input vector. And let's clarify that term for a second, because vector sounds intimidating. If you're listening in this, an input vector is just a list of numbers. That's it. A simple list, yes. Like, if we are trying to teach the network to recognize an image, that vector is literally just the color value of every single pixel in the image. Right. Or if it's a medical diagnostic tool, the vector is a list of your vital signs. Heart rate, blood pressure, temperature.
You take that list of numbers and you lock them into the units on the bottom layer. And once that bottom layer is locked in, the network basically wakes up. The states of the units in the next layer up are determined. And the timing here is actually critical. How so? All the units within a single layer calculate their states in parallel, simultaneously. OK, right. But the layers themselves fire in sequence. Yes. It's like an assembly line in a factory. Layer one sorts all the raw materials at the exact same time. But layer two, you know, the welders, they can't start doing anything until a layer one completely finishes passing the materials up to them. Exactly. And then layer three, the painters have to wait for layer two. The signal just kind of washes over the network from bottom to top. The assembly line is the perfect analogy. So let's zoom in on a single worker on that assembly line. Let's look at one individual artificial neuron, or what they call a unit, sitting in a hidden layer.
OK, focusing on one guy. Right. How does it actually know what to do with the materials being handed up to it? Well, this is where we get into the math, but we are going to keep this grounded for you. The first thing this unit has to do is figure out its total input. It's just sitting there, and it has all these wires coming up to it from the floor below. And the signal traveling up each wire is multiplied by a specific weight. I always like to think of the weight as a volume knob on the wire. A volume knob? I like that. Yeah, so a signal comes up from the floor below. If the volume knob, the weight, is turned way up to a high positive number, that signal comes through loud and clear. Right. If the weight is near zero, the unit basically ignores the signal. But if the weight is a negative number, it actually inverts the signal. It acts as an inhibitor, telling the unit to quiet down. That's exactly how it functions. So the unit simply listens to all these incoming volume -adjusted signals from the layer below, and it adds them all together. Just a straight linear sum. Just addition. Right. That sum is its total input.
But there is a catch here. There's this brilliant little mathematical trick the researchers use involving something called a bias. Yes, the bias is fundamental. In earlier models, he had to worry about a neuron's threshold. Like a biological neuron. Exactly. Just like a biological brain, a neuron builds up electrical charge, and it won't actually fire and send a signal until that charge crosses a specific threshold. So historically, programmers had to write two completely different sets of rules. one mathematical rule for how the network should adjust the volume knobs on the wires, and a completely separate rule for how the network should adjust the internal threshold of the neuron itself. Which was incredibly clunky.
Yeah. Sounds like a nightmare to program. It was. But Rumelhart and Hinton bypassed this entirely. They introduced an extra phantom input to every single unit in the network. And this phantom input is bizarre because it never, ever changes. It is permanently glued to the number one. Exactly. It's a mathematical constant. And the weight on the wire connecting this constant, 1, to the unit is what they call the bias. Wait, I want to make sure I'm fully grasping why this is so clever. If you treat the threshold as just another weight on a wire that's always turned on, you don't need a second set of learning rules. Precisely.
You solve both problems with one equation. Because the network already knows how to adjust weights to get better answers. So if a neuron is firing too easily and ruining the output, the network doesn't have to go into a special threshold adjustment mode. Right. It just treats it like any other wire. It just turns down the volume knob on that one specific phantom wire. It makes the bias weight highly negative, which constantly pulls the neurons total sum down, effectively making it harder for the other normal wires to trigger it. It is mathematically identical to raising a threshold, but... From the algorithm's perspective, it's just tuning another volume knob. It completely streamlines the learning procedure. It's so elegant.
OK. So our unit has listened to all the incoming signals. It adjusted them by their weights, added them all up, and factored in its bias. Right. So it has a single number representing its total input. Let's say that number is 15. Does it just shout 15 up to the next floor? No. It cannot pass that linear sum directly up. It has to process it through a nonlinear function. This is often called a squashing function. And here is where I found myself scratching my head while reading this part of the paper. Why's that? Well, the paper says you can basically use any function as long as it has a smooth, bounded derivative, but they choose a very specific, somewhat complicated -looking S -curve called a logistic function.
Right. The sigmoid. Yeah, why not just use a hard cutoff? Like, if the total input is greater than zero, fire a one. If it's less than zero, fire a zero. Why do we need this curvy, smooth mathematical slope? That is the pivotal question of early AI. The hard cutoff you just described, a step function, is exactly what the old failing perceptrons used. Oh. Yes. Really? The problem with a hard cutoff is that it gives you absolutely no nuance. Imagine you're trying to tune a radio.
Okay. If your only feedback is no music or perfect music, you have no idea which way to turn the dial when you only hear static. You need to know if turning the dial slightly to the left makes the static slightly better. Ah, I see. You need a gradient. You need to know the rate of change. Exactly. A hard step function has no slope. It's just a flat line of zero. A sudden cliff straight up, and then a flat line of one. You can't calculate a useful derivative from a vertical cliff. That makes perfect sense. The logistic function they chose acts like a dimmer switch. It squashes any possible input number into a smooth range strictly between 0 and 1. So if the total input is a massive positive number like 1 ,000, the output gets incredibly close to 1 but never quite breaches it. Right. If the input is negative 1 ,000, it gets infinitesimally close to 0. And if the input is exactly 0, the output is perfectly 0 .5. Right. And because it's a smooth curve, if you were at an output of, say, 0 .8 and you change the input by a tiny fraction, the output changes by a predictable tiny fraction. Which you need for learning. This smooth continuous rate of change is the absolute bedrock requirement for the entire learning process we were about to discuss. Plus, as a bonus, the calculus for finding the derivative of this specific s -curve is incredibly simple to compute, which was vital for computers in 1986. But they didn't have the processing power we have now? Not even close.
OK, let me pause and synthesize this so you listening have the complete picture in your head. We've built the machine. We feed raw numbers into the ground floor. Those numbers travel up wires. Every wire has a volume knob, a weight. At every single unit on the hidden floors, those volume -adjusted numbers are added together, offset by a bias. and then squashed through a smooth S -curve to create a new signal between 0 and 1. Exactly. That new signal is passed up to the next floor, where the process repeats, all the way to the penthouse, where the final units light up with an answer. And that entire sequence, from raw data to final answer, is the complete forward pass. Which is great. It's a very impressive calculator. But here is the trillion -dollar problem that stalled AI for decades. What happens when the answer in the penthouse is completely spectacularly wrong? And it often is at first.
Right. You feed the ground floor a beautiful picture of a golden retriever, and the penthouse lights up and shouts, this is a toaster. The forward pass is completely useless if the machine cannot learn from its mistakes. Right. How do we tell the network it messed up? And infinitely more difficult, how do we look at a network with potentially millions of interconnected volume knobs and tell it exactly which knobs to turn and in which direction to make sure it doesn't call a dog a toaster next time? That is the heart of the breakthrough. That is backpropagation. And it requires us to move into the second major phase of the paper, the backward pass. Let's do it. Step one seems obvious, right? We have to mathematically define exactly how wrong the network is. Yes. The researchers call this the total error. The ultimate goal is to find a set of weights that ensures the network's output exactly matches the desired output for every possible case. So they measure the gap. If the network spat out a 0 .2 for the toaster node, but we wanted a zero because it's a dog, not a toaster, the gap is 0 .2. Exactly. But they don't just add up those raw gaps. They take the difference between the actual output and the desired output and they square it. Now, I was looking at this error calculation and I had a moment of, wait, why square it? Why not just take the absolute value of the mistake? It's a common question. But then I realized, if you guess too high by two on one image and too low by two on the next image, and you just add the raw errors together, plus two and minus two equals zero. Precisely. The network would look at a total error of zero and think, I am a genius, I solved it, when it actually failed twice. Squaring the number forces every single mistake, whether it's too high or too low, to become a positive number. It forces errors to accumulate. But squaring it serves a second, equally vital purpose. What's that? Imagine you have a tiny error of 0 .1.
If you square it, it becomes 0 .01. It shrinks. Right. But if you have a massive glaring error of 0 .8 and you square it, it becomes 0 .64. Squaring the gap severely penalizes large errors much more than small ones. Oh, wow. It acts as a mathematical triage, forcing the network to focus its energy on fixing its most catastrophic mistakes first, rather than obsessing over tiny micro adjustments. That is so smart. OK, so we sum up all those squared errors across every output node and every single training image.
We now have a massive number representing our total error. And this gives us our singular goal. We want to minimize that total error. We want to drive it as close to zero as possible. This process is called gradient descent. I always picture this as a topographical map. Imagine the total error is the altitude of a massive jagged mountain range. OK, I can see that. The different volume knobs, the weights in the network, are the latitude and longitude coordinates. Our goal is to find the exact coordinates that put us at the bottom of the deepest valley in that entire mountain range. We want to descend the gradient. But remember the network is blindfolded.
It can't just look at the map from above. To know which way is down, it needs to feel the slope of the ground directly beneath its feet. Mathematically, what does that mean? It means it needs to calculate the partial derivative of the total error with respect to every single weight in the network. Meaning, for every single wire, the network needs to ask, if I turn this specific volume knob up just a tiny little bit, does the total altitude go up or does it go down? Exactly. Now, calculating that slope for the weights directly connected to the penthouse, the output layer, is relatively straightforward.
Because they're right there at the end. Right. You just look at the final mistake and the final signal. But how do you calculate the exact blame for a single volume knob buried three layers deep in the hidden floors? Yeah, that's where it gets messy. Anamu's signal was mixed with a hundred other signals squashed through an S -curve and mixed again. That feels impossible. It did feel impossible to many people at the time, but Rumelhart, Hinton, and Williams solved it by meticulously applying the chain rule of calculus in reverse. Okay, I want everyone listening to stick with us here because we are going to translate this calculus into intuition. We are going to trace the error backward without reading Greek symbols. Good luck. Well, when I finally understood how this worked, it completely blew my mind. It is exactly like the hierarchy of blame in a massive corporate bureaucracy. I am intrigued. Walk us through the corporate blame analogy. All right. Imagine the neural network is a massive multinational corporation. At the very top, you have the output layer. The total error is a furious CEO screaming that quarterly profits are drastically down. OK, I'm with you.
Now, the CEO doesn't know why profits are down. They don't know how the factory floor operates. They just know there is a massive gap between the desired profits and actual profits. So who does the CEO yell at? The vice presidents. Exactly. The VPs are the output units. The CEO screams at the VPs. But a VP knows they don't actually build the products. They just process what the regional managers send them. Right. So the VP translates the CEO's rage into an understanding of how much their specific department's total input is to blame. They calculate their department's share of the massive error. Which, mathematically, is the equivalent of taking the derivative of the error with respect to the output and multiplying it by the derivative of that squashing function we talked about earlier. Right. The VP figures out their exact percentage of the blame. Then, the VP looks down at all the regional managers reporting to them. The managers are the signals coming up from the hidden layer. And the connections between them are the weights. Right, the performance bonuses. The VP looks at the incoming signals and says, OK, manager A sent me a huge shipment of terrible data, so they are getting 80 % of my blame. Manager B sent me almost nothing, so changing their bonus won't fix anything. They get 2 % of the blame. They are distributing the error backward, proportional to the strength of the forward signal. Exactly. But here is where the absolute genius of backpropagation kicks in. Because we aren't just adjusting the final layer, we have to go deeper. What happens at the regional manager level? Well, a regional manager, a hidden unit, doesn't have a desired target. The CEO didn't give them a quota directly.
Right. And in this corporation, a regional manager doesn't just report to one VP. Their work is distributed. They might report to three different VPs. So how does this middle manager figure out how badly they messed up. They have to sum up the blame. Yes. The regional manager listens to all the VPs they report to. VP number one is screaming at them. VP number two is giving them a mild reprimand. VP number three is actually praising them. So they aggregate it. The manager mathematically adds up all those complaints and praises weighted by how important their connection to that specific VP is. Once a manager calculates their total accumulated blame from above, they act just like a VP. The cycle continues. They figure out their department's total failure, they look down at the interns reporting to them on the ground floor, and they pass the blame down again using the exact same math. It cascades.
You repeat this entire process, passing the derivative of the error backward, layer by layer, multiplying and summing all the way down to the bottom. That's incredible. It is an incredibly precise mechanism for assigning microscopic slivers of responsibility for a macroscopic failure across a massively interconnected system. It's beautiful, really. Because no individual unit can see the whole picture, but through this reverse chain of command, every single volume knob in the entire network gets a specific number attached to it that basically says, if you want to lower the CEO's anger, turn me exactly this much to the left. And that brings us to how we actually update the weights. We have the instructions, but when do we make the change? The paper gives us two schemes. Scheme 1 seems like the most obvious approach. You show the network an image, it makes a guess, you calculate the CEO's anger, you pass the blame down, and you immediately tweak all the volume knobs. Then you move to the next image. Which is efficient in terms of computer memory. You calculate the gradient, use it, and discard it. But the authors actually chose Scheme 2 for their core experiments.
And Scheme 2 is wild. You don't change anything immediately. No. You show the network an image of a dog. calculate the massive blame matrix, and then you just write those numbers down on a clipboard. You don't touch the volume knobs. Then you show it a cat, calculate the new blame, and add it to the clipboard. You accumulate the gradient over every single image in your entire training set before you finally make a single combined adjustment to the weights. Why do you think they did that? Well, let's go back to your blindfolded person on the mountain. If you take a step after every single image, you might just be reacting to a weirdly shaped rock under your foot. Oh, like a local anomaly. Exactly. You might take a step north for the dog, and then a step south for the cat, and just vibrate in place. But by accumulating the gradient, you are essentially feeling the average slope of the entire mountain range at once. Ignoring the local pebbles. Right. And taking one confident step in the truest downward direction. That makes a lot of sense. It provides a much smoother, more stable descent toward the minimum error.
And when they finally take that step, the size of the step is determined by something called the learning rate. A small fraction that prevents the network from taking a wildly huge leap and accidentally overshooting the valley entirely. But the authors realized that a tiny cautious learning rate can be agonizingly slow. So they introduced a brilliant workaround to speed things up. Momentum. Momentum in weight space. It's a really fascinating concept. I love the physics analogy here. If you are a ball rolling down a physical hill, you don't just calculate your speed based on the exact slope directly under you at that specific millisecond. Right, because you have mass. You have momentum. You remember that you've been rolling downhill for the last 10 seconds, so you build up speed. And the authors translate this literally into the math. When calculating the new weight change, they don't just use the current gradient. They add a fraction of the previous weight change. So if the current slope says, go left, and the previous slope also said go left, the network says, great, we are definitely going left. Let's accelerate. And crucially, what happens when it hits a speed bump? This is the best part. If you are rolling fast down a long hill to the right and you hit a tiny rut where the local slope technically tilts left, without momentum, the algorithm would just stop and turn around. It would get stuck in the rut. But with momentum, With momentum, the massive historical force of rolling right completely overpowers the tiny local signal of tilt left. And the network just powers straight through the speed bump and continues down the mountain. It allows for incredibly fast learning rates without the network getting jittery or trapped in tiny surface variations. OK, we have built the engine. We understand the assembly line forward pass and the corporate blame backward pass. We have the theory. It makes logical sense on paper, but... As we know, the perceptron made sense on paper, too, right up until Minsky and Papert proved it was a dead end. Does backpropagation actually work on a problem that those rigid perceptrons fundamentally couldn't solve? To prove it does, the authors devised a series of experiments.
And the first one is a classic, elegant logic puzzle, the detection of symmetry. Let's set the stage for this. The task seems absurdly simple for a human. You have a one -dimensional array, just a straight line, of binary inputs. a line of 6 ones and zeros. Okay. The network has to look at this line and answer one simple question. Is the pattern symmetrical around the center point? Yes or no? So if the line is 101101, you draw a line down the middle, the left mirrors the right, the answer is yes. Right. And if it's 111000, it doesn't mirror at all, the answer is no. This takes a human a fraction of a second.
Why was this considered a famously impossible problem for earlier AI? Because of the limitations we discussed earlier. A perceptron tries to solve problems by looking at individual pieces of evidence and adding them up. But symmetry cannot be solved that way. Why not? The formal proof by Minsky and Papert demonstrated that looking at an individual input unit provides absolutely zero evidence about the symmetry of the entire vector. Right, because if I tell you, hey, the very first digit on the far left is a one, that tells you nothing.
It could be symmetrical if the far right digit is also a one, but it's asymmetrical if the far right is a zero. The individual data point is totally meaningless in isolation. Furthermore, you can't even look at the sum of the halves. If the left side has two ones and the right side has two ones, they can be in completely different non -mirroring positions. Oh, true. You absolutely must be able to compare specific paired relationships across the centerline. You must have a hidden layer capable of abstracting those exact relationships.
So Hinton and his team set up their back propagation network. They created an input layer of six units, giving them 64 possible combinations of ones and zeros. And they sandwiched a hidden layer between the input and the output. But before they started training, they did something crucial. They initialized all the weights with small random numbers. Why random? Why not start everything at a clean zero? Think about your corporate analogy. If you hire five identical regional managers, give them the exact same starting instructions, give them the exact same data, and yell at them the exact same way when they fail, they will all make the exact same adjustments. They will remain identical clones forever. And you don't need five clums doing the exact same job. You need them to specialize. Exactly. By starting the weights with random noise, some slightly positive, some slightly negative, you basically break the symmetry. When the CEO yells, the slightly different starting weights cause the managers to absorb the blame differently. Which causes them to adjust their weights differently. They begin to carve out unique areas of expertise.
So they initialize the random noise, feed in the 64 patterns, and let the network run. And in 1986, this was computationally heavy. It took 1 ,425 complete sweeps through all 64 patterns. That's 1 ,425 times the CEO screamed at the VPs before the error finally plummeted to zero. But when they cracked open the black box to see what the hidden layer had learned, the authors call it an elegant solution, and it truly is. It's a master class in autonomous mathematical balancing.
Let's look at how just one of those hidden units organized its volume knobs. I am going to walk through this slowly because visualizing this invisible math is, for me, the coolest part of the entire paper. The network arranged the weights connecting the inputs to the specific hidden unit in a perfect mirrored balance. How so? The weights on the left side of the array became equal in magnitude but completely opposite in sign to the corresponding weights on the right side. Let's anchor that with numbers to make it clear. If the first input unit on the far left learned a connection weight of plus 10, the input unit on the far right learned a weight of minus 10. Exactly. If the second from the left was minus 4, the second from the right was plus 4. So trace what happens when a perfectly symmetrical pattern is fed in. Let's say the two outer edges are both 1 and the middle is all zeros. The hidden unit receives a plus 10 signal from the left and a minus 10 signal from the right. And because we are just doing a linear sum, they perfectly cancel each other out. The net total input from the array is exactly zero.
This holds true for any symmetrical pattern. The positive and negative weights will always perfectly annihilate each other across the mirror line. Here is where the bias trick comes in. The network learned to give this hidden unit a massive negative bias. Let's say negative five. So the inputs cancel out to zero. but the bias is constantly dragging the unit down to negative 5. And because of that squashing S -curve, a massive negative input means the hidden unit is effectively turned off. Its output is crushed down to near zero. OK, so for a symmetrical pattern, the hidden unit stays silent. Now look at the final output unit in the penthouse. The network learned to give the output unit a positive bias.
So if the hidden unit is silent, The output unit just feels its own positive bias, and it happily turns on, shouting, yes, symmetrical. But what happens if the pattern is asymmetrical? What if the left edge is 1 with a weight of plus 10, and the right edge is 0 with a weight of 0? The sum is no longer 0. The left side overpowers the right. The hidden unit gets a massive jolt of plus 10, which easily overcomes its negative bias of negative 5. The hidden unit wakes up.
It turns on and fires a massive signal up to the penthouse. And the final piece of the trap. The connection from the hidden unit to the penthouse has an incredibly strong negative weight. Right. So when the hidden unit wakes up, it blasts the output unit with this huge negative signal, completely suppressing the output unit's positive bias, forcing it to turn off, signaling, no, not symmetrical. It is remarkably clever. But there is a meticulous detail in the text that shows just how mathematically precise this gradient descent can be. The weights on each side of the midpoint aren't just random opposing numbers. No, they aren't. The paper notes they fell into a ratio of 1 to 2 to 4.
Like binary code. Exactly. Why do you think the network settled on that specific exponential ratio? I had to think about this and it really blew my mind. If you use a 1 to 2 to 4 ratio, you guarantee that every single possible combination of 1s and 0s on the left side will generate a totally unique mathematical sum. Yes. Because if it was 1, 2, 3, then 1 plus 2 equals 3. You'd have overlapping sums. Right. So by using 1 to 2 to 4, there is absolutely no way a random pattern on the right side can accidentally equal the sum of a completely different pattern on the left side. It's impossible. The only way the sum from the right side can exactly balance the unique sum from the left side is if it is a perfect, exact mirror image. It is an airtight mathematical proof against false positives, constructed entirely by a blind algorithm following the chain rule of errors. The researchers didn't program the 1 .2 .4 ratio. They didn't program the equal and opposite signs. They didn't tell it to use negative biases to create a default off state.
The network invented a perfectly balanced mathematical scale out of random noise. It perfectly validates their thesis. Back propagation can construct appropriate internal representations. But detecting symmetry is still, you know, a mathematical parlor trick. It's numbers and logic. A truly revolutionary AI needs to be able to handle messy, abstract human concepts. Things like semantics, categories, sociology. Which brings us to the most profound experiment in the paper. Experiment two. Family tree. If the algorithm is truly general purpose, how do we force it to learn sociology? The researchers introduce a completely different kind of task.
They present two family trees, and they are what the text calls isomorphic family trees. Which simply means they have the exact same structural shape, but completely different labels. Right. One tree is an English family. Christopher and Penelope are married. They have a son named Colin. Colin has daughters, etc. The second tree is an Italian family. Roberto and Maria are married. They have a son named Alfonso. So the internal relationships, who is the patriarch, who is the aunt, who is the grandson, are structurally identical between the two families, even though the names share absolutely no similarities. The data is fed to the network as a set of logical triples, a formula. Person one plus relationship equals person two. For example, the input would be the name Colin and the relationship has aunt. The desired output from the network would be the correct answer. Victoria and Jennifer because Colin has two aunts. Now this feels radically different from looking at a string of ones and zeros. The network doesn't know what an aunt is. It doesn't know Colin is a man. How do they build an architecture to process this? They built a massive, highly constrained five layer architecture.
Let's visualize this because the shape of the network totally dictates how it learns. On the ground floor, you have two totally separate groups of inputs. On the left, you have 24 distinct units, each representing one specific person in the two family trees. When we want to input colon, we turn the colon switch to 1, and the other 23 switches to 0. And on the right? On the right side of the ground floor, you have 12 input units representing the 12 possible relationships, father, mother, husband, aunt, etc. Now move to the second floor. This is where the magic happens. The 24 person inputs do not connect to a massive, open, hidden layer. They are strictly routed into an isolated group of just six hidden units. This is a massive, deliberate bottleneck.
You are taking the data of 24 distinct, unique individuals and violently compressing it down into just six volume knobs. Why do this? Well, because if you gave it 24 hidden units, the network would just lazily dedicate one unit to each person. It would just memorize the data like a flash card. There's no learning there. By forcing it through a bottleneck of six units, the network literally cannot afford to memorize. It has to find a more efficient way to encode the data. It has to discover the underlying features, the invisible attributes that group people together.
The text calls this learning a distributed representation. It's forcing the network to distribute the abstract concept of a person across a pattern of activity in those six units. And side note for anyone listening who follows modern AI, this exact concept compressing sparse data into a dense bottleneck to find underlying meaning is the exact foundation of embeddings used in modern large language models to understand the relationship between words. Yes. It's the same math from 1986. It is the conceptual ancestor of the modern AI revolution.
So moving up the architecture, those two groups of six hidden units, one for the person, one for the relationship, finally mix their signals together in a central third floor of 12 units. This is where the person meets the relationship. That connects to a fourth floor of six units, which finally connects to the penthouse, an output layer of 24 units, identical to the input names representing the final answer. It basically looks like an hourglass, wide at the ends, heavily squeezed in the middle. The training regiment for this beast was grueling. There are 104 true relational facts in these family trees. And the researchers trained the network on 100 of them, purposefully holding four back to test it later.
And they ran it for 1500 sweeps. And they actively manipulated the learning environment as it trained. They started with a very small learning rate to ease it into the problem, then sped it up. But the most crucial intervention they made was introducing a concept called weight decay. I circled this in my notes because it feels entirely counterintuitive. The text says every single weight in the entire network is actively decreased, decayed, by a flat 0 .2 % after every single weight change. It's like building a muscle but intentionally starving it at the same time. Exactly.
Why purposefully shrink the exact connections you are trying so hard to build up? It is a brilliant technique to force ruthless efficiency. Without weight decay, if a network finds a sloppy solution that kind of works, it might just keep increasing those specific weights to infinity to drive the outputs closer and closer to perfect ones and zeros. You end up with massive, unwieldy, fragile numbers. And it probably overfits the data. It just memorizes the exact training set rather than learning the flexible underlying rules of the family tree. Right. By introducing a constant 0 .2 % decay, the network is fighting a constant headwind. The only way a weight can remain large and powerful is if the error gradient is constantly pushing it up harder than the decay is pulling it down. It's survival of the fittest for the synapses. Only the most universally vital connections survive the decay. The lazy memorization pathways wither away. Exactly. So after 1 ,500 sweeps of this grueling, constantly decaying training process, What did the network actually learn in that tight six -unit bottleneck? This is the defining aha moment of the entire paper. The researchers looked inside the receptive fields of those six hidden units that were processing the 24 people. They looked at the final volume knobs connecting the ground floor names to the second floor bottleneck, and they found something astonishing. Let's examine unit one in that bottleneck.
They found that the weights connecting the 12 English people to Unit 1 were all strongly positive, but the weights connecting the 12 Italian people to Unit 1 were all strongly negative. Unit 1 organically learned to distinguish English from Italian. It invented the concept of nationality as a mathematical sorting mechanism. Now look at Unit 2. It had strong positive weights for Christopher, Penelope, Roberto, and Maria. The grandparents. Right. It had middle ground weights for Colin, Victoria, Alfonso, the parents, and it had strong negative weights for the children at the bottom of the tree. Unit 2 invented the concept of generation. It learned to sort people by their vertical height in the family tree.
And Unit 6. Unit 6 had strong weights for the entire left side of the tree, the Christopher Arthur branch and the Roberto Emilio branch. It had opposing weights for the right side of the tree. It learned which specific branch of the family someone comes from. I want to make sure the profoundness of this is really landing for you listening. I have to extrapolate this because it blows my mind. The network was never told what an Italian is. It was never told what a generation is or what a branch of a family is. The input was literally just 24 independent switches representing arbitrary names. There was zero structure in the input data, just names.
But to minimize the CEO's anger, to mathematically figure out who Colin's aunt is, the network had to find structural patterns. It essentially reinvented human sociology from scratch. It really did. It discovered that categorizing these 24 arbitrary names by generation, branch, and nationality was the most mathematically efficient way to predict human relationships. It built an internal conceptual model of a family tree just by multiplying numbers and descending a gradient. And here is the ultimate payoff of forcing the network to learn this distributed representation. Because Unit 1 exclusively handles the English -Italian split, the rest of the units don't have to worry about it. As the text states, the representation of an English person is very similar to the representation of their Italian equivalent. So Colin's pattern of activity across units 2 through 6 is nearly mathematically identical to Alfonso's pattern of activity because their structural position as the father on the left branch is identical.
The network discovered the isomorphism on its own. Which brings us to the holy grail of machine learning. Generalization. Remember those four relational facts they held back during training? The ones the network had never seen? Right. it was never explicitly taught the answer. But when tested on them, because it had discovered the true underlying structure of how these families operated, it generalized sensibly. It got them right. It didn't memorize 100 isolated facts. It learned the universal rules of the system.
This experiment definitively proved that feedforward layered networks trained with backpropagation could extract profound, meaningful semantic features from entirely unstructured data. It is a staggering triumph. But as we move into the final major section of the paper, the authors acknowledge that these feed -forward networks, as impressive as they are, have a massive limitation. Yes, they do. They only process a static, frozen input. You put a single picture in, you get a single answer out. But human existence and many of the hardest problems in AI unfold over time. speech recognition, video analysis, logic puzzles that require multiple sequential steps. The paper addresses this too, introducing the concept of iterative networks. Right. The authors show that the mathematics of backpropagation aren't limited to spatial layered architectures. They discuss synchronous iterative networks, which we now more commonly refer to as recurrent neural networks.
This is where the network architecture gets a little trippy. In a recurrent network, the units don't just send signals upward. They have connections that loop back on themselves or loop back to units in the same layer. The signal cycles around and around. But how do you train a network that is constantly feeding back into itself? The error would just chase its own tail. The authors present a beautifully simple conceptual equivalence. An iterative network running over time can be mapped directly onto a static feed -forward network running over space. Okay, help me visualize that.
Unrolling time? Exactly. Imagine a recurrent network running for three distinct ticks of a clock. Time step one, time step two, and time step three. You can physically visualize that process as a three -story feed -forward network. So the state of the recurrent network at time step one is the ground floor? Yes. And the connections looping back on themselves in time are simply represented as standard wires pointing upward to the next floor. So time step two is the middle floor, time step three is the penthouse. So we just pretend time is space. And if we do that, the exact same backpropagation math we just spent an hour learning still perfectly applies. We just passed the CEO's blame down through the floors, which means we are technically passing the error backward through time. That is precisely what it is, backpropagation through time. But the text notes two major logistical complications when you try to actually program this into a computer. Right. Because in a standard spatial network, we said you need to remember the output of the hidden units from the forward pass to calculate the chain rule on the backward pass.
The first complication is memory constraint. In an iterative network running over time, the hidden units are just the network itself in the past. You can't just let the network override its state at each tick of the clock. You must build a massive memory bank to store the entire history of the output states of every single unit at every single time step during the forward run. So you have them preserved and waiting when you run the error backward through time. Which, in 1986, was a crippling amount of computer memory for complex tasks. What's the second complication?
The second complication involves the volume knobs. If our three -story spatial network is really just one recurrent network unrolled over three time steps, then the wires connecting floor one to floor two must be perfectly identical to the wires connecting floor 2 to floor 3. Because they aren't actually different wires. They are the exact same physical connections in the recurrent network just operating at a different moment in time. Right. But backpropagation calculates a unique, highly specific error derivative for every single physical connection based on its local position. The calculated blame for floor 1 will naturally be different from the calculated blame for floor 2. If we just update them independently like a normal network, they won't match anymore.
The illusion of unrolled time shatters. So how do you force them to stay identical while still learning? The authors introduce a simple mathematical proviso. You calculate the gradient for all the corresponding weights across the different time steps. Then you simply average those gradients together. Finally, you change all the corresponding weights simultaneously by an amount proportional to that single average gradient. They are forced to move together in lockstep. That is a brilliantly practical solution. So with those two tweaks, massive history storage and gradient averaging, backpropagation can train networks to learn sequential structures. It opened up entirely new worlds of capability for AI. But before they conclude the paper, the authors have to tackle the elephant in the room. They have to address the major theoretical criticism of gradient descent algorithms that had haunted the field for decades. The nightmare of local minima. Ah, yes. Let's return to our mountain landscape analogy one last time. The total error is the altitude. We want our blindfolded algorithm to step its way down to the lowest possible valley on the entire planet, the global minimum. And the obvious glaring drawback to this approach, which critics constantly point out, is that the error surface of a complex problem is not a simple smooth bowl with a single bottom.
It is rugged. It is highly non -linear. It contains local minima. Local minima are like small shallow valleys or craters perched high up on the side of the mountain. If our blindfolded algorithm wanders into one of these shallow craters, it reaches the bottom of the crater. It feels the ground with its foot, and every direction it touches goes up. The math tells it, you are at the bottom. Stop moving. The algorithm stops. It thinks it's solved the problem, but it's actually stuck in a poor local minimum with a massive error rate. And it will never ever find the true global minimum at the bottom of the mountain.
Theoretically, mathematically, this is a fatal flaw. It suggests that gradient descent shouldn't work on anything but the simplest problems. But the authors rebuttal to this theoretical fear is incredibly pragmatic. What did they actually find when they ran these complex experiments? They relay their empirical findings, which directly contradict the theoretical panic. They state, simply, experience with many tasks shows that the network very rarely gets stuck in poor local minima that are significantly worse than the global minimum. In practice, it just works. But why? Do they offer an explanation for how the blindfolded algorithm magically avoids these craters? They offer a fascinating geometrical explanation. They observe that this getting stuck behavior almost exclusively happens in networks that have just enough connections to perform the task. A network perfectly minimally sized for the complexity of the problem. But what happens if you make the network way bigger than it strictly needs to be? What if you give it way too many hidden units? That is the key. They state Adding a few more connections creates extra dimensions in weight space. I love this concept, the dimensional escape route. Let me try to visualize this for the listener. Imagine you are literally trapped in a three -dimensional valley. There are walls on the north, south, east, and west. You cannot move without going up. You are stuck in a local minimum. But then, you add a new connection to the network. Mathematically, you just added a fourth dimension of space to your landscape.
And in a four -dimensional space, what looked like an impenetrable solid wall in 3D might not be a wall at all. It might just be an open door. Yes. The text literally says, these dimensions provide paths around the barriers that create poor local minima in the lower dimensional subspaces. It's like finding a secret hyperdimensional tunnel out of the crater. By over -parameterizing the network, giving it way more connections than it needs, you give it the spatial freedom to flow like water around obstacles and find its way to the bottom of the mountain. It is a profound, counter -intuitive insight that remains a cornerstone of how we design massive neural networks today.
We make them astronomically huge, partially to ensure they have enough dimensional escape routes to never get trapped. We have covered so much incredible ground today. The assembly line forward pass, the corporate blame backward pass, the mathematical symmetry detector, the invention of sociology and the family tree, unrolling time, escaping 40 valleys. We are at the end of our deep dive. And I want to circle back to something that might seem very surprising after spending an hour marveling at how smart, how organic this system seems. The biological caveat. Yes. the authors themselves in the concluding paragraph of the paper explicitly state a major humbling caveat. The learning procedure in its current form is not a plausible model of learning in brains. They are being rigorously scientific.
Despite the inspiration taken from neurons, biological brains do not appear to perform the flawless, synchronous backward pass of precise error calculus that the chain rule requires. A brain doesn't have a secondary set of perfectly reversed pathways designed specifically to transmit fractional derivatives of blame back to individual synapses. So if our biological brains don't actually do this, what is the ultimate value of this massive paper? Why did organizations like the System Development Foundation and the Office of Naval Research fund this leap into artificial math?
The value is theoretical proof of existence. Before 1986, it was widely doubted, almost dogma. that any local decentralized mathematical rule could construct complex internal representations, like the abstract concept of a generation or a family branch. By proving that gradient descent in weight space can achieve this, the paper shattered that dogma. It proved the mathematical viability of the approach. And as the authors conclude, this suggests that it is worth looking for more biologically plausible ways of doing gradient descent in neural networks. It gave neuroscience and AI a true north. It proved that the murky diagnostic muddy waters of a complex system actually hold understandable structural truth if you can just figure out how to mathematically descend the gradient to find it. Which leaves me with a final provocative thought for you to mull over as we sign off. If our actual biological brains don't use exact backpropagation, if we don't have this flawless internal accounting department passing exact error derivatives perfectly backward down the chain of command, yet we somehow still learn incredibly complex abstract representations of the world, how are we doing it? That's the million dollar question. Is there an entirely different undiscovered mathematical principle governing human learning? Or, perhaps more intriguingly, is the wet, squishy brain somehow approximating this exact calculus in a messy, noisy, organic way? If backpropagation is the clean, perfectly engineered X -ray we talked about at the start, is the brain achieving the exact same result through the murky, distributed fog of biology?
What does it mean for the future of artificial intelligence if our most successful, world -changing algorithms are fundamentally alien to the biology that originally inspired them? It's a lot to think about. Keep digging into those questions. The answers are still out there, waiting to be discovered. Thanks for joining us on this deep dive.