The Complete History of AI: From Turing to AGI

Publicado em

Vídeo em Inglês, publicado pelo canal mildly curious..

About this content: The summary, key points and topics below are generated automatically from the video transcript. They reflect the content, opinions, claims and predictions presented in the video and do not represent a position, validation or fact-check by IA Dots.

Video summary

The video explores the history and development of artificial intelligence, tracing its origins from early mathematical and neural concepts to modern neural networks, deep learning, Transformers, and current challenges like adaptability and artificial general intelligence.

Key points

  • Artificial intelligence evolved from two foundational ideas: rule-based computing and networks of simple neuron-like units.
  • Early artificial intelligence focused on symbolic logic and expert systems, while machine learning allowed systems to learn from data or experience.
  • The development of backpropagation, convolutional neural networks, and GPUs enabled the success of deep learning and large-scale image recognition.
  • The invention of the Transformer architecture and attention mechanisms revolutionized language processing, leading to large language models like GPT.
  • Modern AI systems can generate text and images, use tools, and learn from human feedback, but they still face challenges in general adaptability and true reasoning.

Topics

Artificial IntelligenceMachine LearningNeural NetworksDeep LearningTransformerArtificial General Intelligence
Video transcript

Transcript from available captions; it may contain errors.

Imagine asking an AI assistant something you've always wondered about. Why doesn't the Moon simply fall to Earth? Within seconds, it explains the answer. You ask it to explain the same idea more simply. And somehow, it knows how to adjust. Now imagine placing that same AI assistant inside a game it has never played before. There are no instructions. No one explains what the controls do. You don't even tell it what winning means. Could it work out the rules just by exploring? That's a very different challenge. And the gap between answering a question and figuring out something genuinely unfamiliar tells us a great deal about artificial intelligence. Because the AI systems we use today didn't come from one extraordinary invention. They grew out of decades of experiments, disappointments, and discoveries that gradually came together. To understand how we got here, we need to go back to a time before computers, as we know them, existed. In 1936, the word computer didn't mean a machine. It meant a person, someone whose job was to calculate by hand. That year, a young British mathematician named Alan Turing was working on a deceptively deep question. What does it actually mean for something to be computable? Think about working through a sum on paper. You look at a symbol. You follow a rule. You write something down. And you move on. Could steps like those be described so precisely that a machine could carry them out? Turing imagined a remarkably simple machine. It has a long tape, divided into cells. Each cell can hold a symbol. A head looks at one cell at a time. And the machine is always in some state, like a bookmark that says which rule to use next. Here's one rule. If you're in state A and you see a zero: write a one, move right, and switch to state B. Now the machine is in state B, looking at a new cell. So it finds the rule for that, and follows it. That's all it ever does. Read, write, move, and change state. There's nothing clever happening anywhere. Just steps. That might sound too simple to matter. But different rule tables make different machines. One adds numbers. Another rewrites words. Another checks logic. And then Turing showed something remarkable. You could build one universal machine that reads another machine's rules from its own tape, and then behaves exactly like that machine. It's a bit like the phone in your pocket. One device, running whichever app you give it. That idea became a cornerstone of general-purpose computing. But notice something. Every rule still had to be written in advance. Following instructions, however many, isn't the same as learning from experience. For that, researchers would look somewhere very different. In 1943, a neuroscientist, Warren McCulloch, and a young logician, Walter Pitts, took that different path. They started with the nervous system. A real neuron is astonishingly complex. But one of its basic behaviors is simple. It collects signals from other neurons, and if enough of them arrive at once, it fires a signal of its own. McCulloch and Pitts kept only that. Their artificial neuron is either off or on. And it turns on when its inputs reach a threshold. Let's try it. Two inputs. Each one is either on or off. Each counts as one. And the threshold is two. First input on, second input off. That's only one. Nothing happens. Both inputs on. That's two. The unit fires. The unit only fires when both inputs are on. Logicians call that AND. Now here's a question for you. What happens if we lower the threshold to one? Now either input is enough. The same little unit now behaves like OR. Change one number, and you change what the unit computes. Now connect several of these units, so the output of one becomes the input of another. With the right connections, networks of them can compute more complicated logic. McCulloch and Pitts even argued that networks like these, given something like Turing's tape, could compute the same kinds of things his machines could. So the two ideas were linked from the very beginning. No single unit is intelligent. What the network does depends on how its parts are connected. But there was something missing. Every connection, and every threshold, was chosen by hand. Nothing in these networks learned. Could a machine built from parts like these ever learn on its own? Alan Turing had been wondering exactly that. In 1948, he wrote a report called Intelligent Machinery. In it, he described networks of simple, randomly connected units, close cousins of the networks we just saw. But instead of choosing every connection by hand, he imagined a teacher who could adjust them. It wasn't published until 1968, after his death. But the idea was startling. Maybe useful behavior didn't have to be programmed. Maybe it could be trained. Think about teaching someone a simple task. At first, they make mistakes. You tell them when they're right, and when they're wrong. They try again. And slowly, their behavior changes. Turing imagined giving a machine the same two kinds of signal. He called them, quite literally, pleasure and pain. Here's the idea. The machine sees a light and must choose: left or right. It picks left. Wrong. A correction weakens the connection that led there. Next time, it picks right. A reward strengthens that connection. After a few rounds, the right choice becomes the habit. Nobody wrote a rule saying choose right. The behavior came from training. In his famous 1950 paper, he went further. Instead of programming an adult mind, why not build something more like a child's mind, and educate it? This wasn't modern machine learning. But it raised a question that would run through the rest of this story. What if intelligence could be grown through learning, instead of written down as rules? And if a machine ever did learn to behave intelligently, how would we even recognise it? In 1950, Turing published a paper called Computing Machinery and Intelligence. It opens with a short question. Can machines think? But how would we ever know? We can't open a computer and point to a part labelled intelligence. And honestly, we can't do that with each other either. We judge whether other people are thinking by what they say and do. So Turing suggested judging a machine the same way. Imagine you're chatting, by text, with two unseen participants. One is a person. The other is a machine. You can ask anything you like. Your job is to work out which one is the machine. If, after a good conversation, you really can't tell them apart, that tells us something about how the machine behaves. Turing called this the imitation game. A simplified version of it became famous as the Turing Test. But there's a catch. Two machines could give exactly the same reply in completely different ways. One might follow an enormous book of hand-written rules. Another might have learned its replies, like the machines Turing imagined. From the outside, you can't tell which. And a convincing conversation doesn't settle deeper questions, like whether anything is truly understood. So the imitation game gave us a way to judge behavior. It didn't tell anyone how to build it. A few years later, a small group of researchers decided to try. In 1955, four researchers, John McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon, proposed a summer research project. Their proposal made a bold claim. That every aspect of learning, or any other feature of intelligence, could in principle be described so precisely that a machine could be made to simulate it. The project needed a name. McCarthy chose one. Artificial intelligence. The following summer, a small group of researchers gathered at Dartmouth College to begin. But naming a field isn't the same as solving its problems. They hoped to tackle language, reasoning, problem-solving, and learning. They had a shared goal. They didn't have one method for reaching it. And two broad directions were already taking shape. One was to give machines explicit knowledge and rules for reasoning, a lot like Turing's rule tables. The other was to let machines improve through experience, a lot like the trainable machines he imagined. These weren't rival camps with fixed borders. Ideas flowed between them. But they give us two branches to follow. And we'll start with reasoning. Let's try a small reasoning problem. Every square is a rectangle. This shape is a square. So what can we conclude? That it's a rectangle too. We didn't need to check every square in the world. We applied a general rule to a specific fact. And we can write that same reasoning with symbols. If square, then rectangle. Square. Therefore rectangle. Now, could a computer, given symbols and rules like these, derive conclusions nobody had written down? In 1956, Allen Newell, Herbert Simon, and Cliff Shaw showed a program that did exactly that, for mathematics. It was called Logic Theorist. Given a statement to prove, it worked with symbols and logical rules, looking for a chain of steps from what it knew to what it wanted. But at every step there are many rules it could apply. Trying them all quickly becomes hopeless. So it used rules of thumb, which researchers call heuristics, to try the most promising steps first. Think of it as a tree of possibilities. Promising branches get explored. Dead ends are abandoned. And it worked. Logic Theorist proved thirty-eight of the first fifty-two theorems in a chapter of Principia Mathematica, a famous work of mathematical logic. For one theorem, it found a proof more elegant than the one in the book. But notice what this needs. Someone has to describe the problem in symbols. And someone has to write the rules. For logic, that's possible. But what about a game, where the best move depends on judgement and experience? At IBM, Arthur Samuel was writing a program to play checkers. The rules were easy to give it. Which moves are legal. How pieces capture. And like Logic Theorist, it could search, looking a few moves ahead. But a search tree has to stop somewhere. And then the program has to judge: is this position good for me, or bad? Samuel gave it a scoring formula. Count a few useful features, like how many pieces each side has, or how many moves you have available. Multiply each by a weight, how much that feature matters. And add them up. Here's the clever part. What if the program could adjust those weights itself? Samuel's program played game after game, including many against itself. When its judgement of a position turned out to be wrong, it nudged the weights, so that next time its score would better predict how things actually turned out. Watch this position. Before learning, the program thinks it's roughly even. After many games, the same position scores clearly worse, because experience showed that losing control of the center tends to lose the game. People still wrote the rules of checkers, and the overall design. But part of the program's judgement came from experience, not from its programmer. Samuel reported that his program came to play better than he did. And in 1959, he described this work with a phrase that stuck: machine learning. So now we have our two branches in their simplest form. In rule-based AI, people write the rules down. In machine learning, the program uses data or experience to adjust how it does the task. And those adjustable weights, these little knobs, are about to become very important. Suppose we have a collection of flowers from two related species. For each flower, we measure two things: how long its petals are, and how wide. Let's put those on a graph. Length along the bottom. Width up the side. Each flower becomes a single point. Add more, and the two species start to form two groups. Here's the challenge. Could a machine learn to tell the groups apart, just from examples like these? In 1958, Frank Rosenblatt described a learning machine called the perceptron. You've already met its two key parts. Like the 1943 unit, it adds up its inputs and fires if the total crosses a threshold. But now each input has a weight, a knob, like Samuel's scoring formula. Petal length goes in, multiplied by one knob. Petal width goes in, multiplied by the other. Add them, plus one more adjustable number called the bias, and the perceptron answers: group A, or group B. On our graph, that decision becomes a straight line. Everything on one side is A, everything on the other side is B. Turn one knob, and the line tilts. Change the bias, and the line slides. Rosenblatt's hardware, the Mark I Perceptron, really did have physical dials, turned by little electric motors as it learned. At first, the knobs are set badly. The line is in the wrong place. So we show the perceptron one flower. It predicts: group A. We check the label. It's actually B. A mistake. The learning rule nudges each knob a little, in the direction that would have made this answer less wrong. The line shifts. Then another flower. Another check. Another small nudge. After enough examples, the line settles where it separates the two groups. Nobody told the perceptron where the line should go. It learned a decision rule from examples. Rosenblatt's demonstrations caused a sensation. One 1958 newspaper report said the Navy expected the machine would eventually walk, talk, see, write, and even be conscious of its own existence. Expectations were rising fast. Remember the imitation game, and that rule-book machine? In 1966, at MIT, Joseph Weizenbaum built a program that could hold a typed conversation. It was called ELIZA. Its most famous script played the part of a psychotherapist who mostly reflects your words back to you. Here's part of a conversation from Weizenbaum's own paper. So what's happening inside? ELIZA looks for keywords and patterns. Take that last line. The pattern is simple: my something made me something. ELIZA swaps the pronouns, my becomes your, me becomes you, and hands the sentence back. There's no understanding of boyfriends, or of feelings. Just matching and rearranging text. And yet, people found it surprisingly personal. Weizenbaum described how his own secretary, who knew exactly how it worked, asked him to leave the room so she could talk to it in private. That reaction troubled him for the rest of his career. Because it revealed something about us. We readily read understanding into anything that responds like a person. That's worth remembering today, every time an AI system sounds sure of itself. Remember the perceptron's decision? It's always one straight line. So let's give it a challenge. Four points, on the corners of a square. Blue in the top-left, and the bottom-right. Orange in the other two corners. Your job: draw one straight line with both blues on one side and both oranges on the other. Try it. However you move or tilt it, one line can't do it. This pattern has a name: XOR, or exclusive or. The output is on when one input is on, but not both. In 1969, Marvin Minsky and Seymour Papert published Perceptrons, a careful mathematical analysis of what these single-layer machines could and couldn't do. XOR was one of the simplest examples of their limits. Now, here's an important detail. Networks with more than one layer can handle XOR. In fact, back in 1943, you could have wired a few threshold units together by hand to compute it. The real problem was different. Nobody had a good way to train a multilayer network. When its answer was wrong, which of its many knobs should change? Partly because of these limits, much of the field's attention, and funding, moved away from neural networks for years. Remember those predictions, machines that would soon walk, talk, and see? By the late 1960s, AI had real achievements. Programs proved theorems, played games, and held simple conversations. But almost all of them worked in small, tidy worlds. A robot could stack blocks in a carefully arranged room. Move one box, change the lighting, and it could fail. A program could solve a puzzle written in symbols. But ordinary language, full of ambiguity and common sense, was far harder. There was a deeper problem, too. Remember the search tree? Suppose every step offers ten possible moves. Look one step ahead: ten possibilities. Two steps: a hundred. Three: a thousand. Ten steps ahead, ten billion. Small puzzles stay manageable. Real problems quickly don't. In 1973, a report for the British government by the mathematician James Lighthill singled out exactly this, which he called the combinatorial explosion, as a reason AI's grand promises hadn't been met. In the United States, a 1966 report had already been sharply critical of machine translation. Funding was cut back on both sides of the Atlantic. This period became known as the first AI winter. But a winter in funding isn't a winter in ideas. Work continued on logic, statistics, vision, robotics, and even neural networks. Public excitement tends to rise and fall quickly. Scientific progress usually moves more slowly, and more steadily. And some researchers found a way to make AI useful by aiming smaller. Instead of general intelligence, what about expert knowledge, in one narrow field? Think about how a specialist solves a problem. A chemist looks at measurements of an unknown molecule and, from years of experience, rules out most of the possibilities. Researchers at Stanford asked: what if we wrote that experience down as rules a computer could apply? Their program, DENDRAL, begun in the mid-1960s, helped identify the structure of molecules from their measurements. In the 1970s, another Stanford program, MYCIN, used several hundred if-then rules to suggest treatments for certain blood infections. In tests, its recommendations compared well with those of specialists, though it was never used in routine clinical care. These were called expert systems. By the 1980s, expert systems had become a business. Here's a real kind of problem. A company called Digital Equipment Corporation sold computers built to order. Each order might combine dozens of components: processors memory cabinets cables. Not every combination works. So DEC used an expert system called XCON to check and complete each configuration. For example: if this memory board is ordered, then this cabinet needs a compatible slot, so add this connector. XCON eventually handled tens of thousands of orders, with thousands of rules, and was reported to save the company tens of millions of dollars a year. Across the industry, companies rushed to build expert systems of their own. But there was a cost hiding in all those rules. Someone had to interview the experts and write every rule down. And experts often know more than they can say. Then the world changes. New products arrive. Exceptions appear. Every new rule has to fit with the thousands already there. As systems grew, keeping them correct became slow and expensive. By the end of the 1980s, the expert-systems boom had faded, and the market for specialised AI hardware collapsed. A second AI winter set in. And yet, the lesson was clear. When knowledge is hard to write down, maybe a machine needs to learn it. Meanwhile, in a handful of labs, someone was finally answering the question from 1969. Here are our four points again. One line can't separate them. But what about two lines? Imagine one hidden unit that draws this line, and another that draws this one. Each one, on its own, gets the pattern wrong. But now add a final unit that fires only when a point falls between the two lines. The blues are inside. The oranges are outside. Solved. So a network with a hidden layer can represent XOR. The real question is the one from 1969. If the network starts with random knobs and gets the answer wrong, which knobs should change, and by how much? There's an obstacle first. Our units are on-off switches. Turn a knob slightly, and usually nothing changes at all. Then, suddenly, the output flips. That gives no hint about which way to turn. So researchers replaced the hard switch with something smoother. More like a dimmer. Now, a small turn of any knob makes the output change a little, so we can measure whether it's getting better or worse. Now we need one number that says how wrong the network is. It's called the loss. Big when the answers are wrong, small when they're right. Picture it as a landscape. Every position on the ground is one setting of the knobs, and the height is the loss. We want to get as low as we can. But we're standing in fog. We can't see the whole landscape. What we can feel is the slope right under our feet. So we take a small step downhill. Feel the slope again. Step again. That slope, for every knob at once, is called the gradient. And stepping downhill is called gradient descent. But in a network with layers, how do we find the slope for a knob deep inside? That knob affects a hidden unit. That hidden unit affects the output. And the output affects the loss. So we work backward. Start at the end: how much does the loss change if the output changes? Then step back one layer: how much does the output change if this hidden unit changes? Then back again, to the knob itself. Multiply those effects together, and we know how much each knob is to blame. This is backpropagation. It uses the chain rule from calculus to pass the error backward through the network, one layer at a time. It doesn't change the knobs itself. It tells us the slope, so gradient descent knows which way to step. Forward, to make a prediction. Backward, to assign the blame. Then nudge every knob a little. And repeat. Let's run it on our four points. Forward. Backward. Nudge. Over and over. The two hidden lines swing into place. And the network separates the pattern a single perceptron never could. Versions of this idea had been worked out earlier, including by Seppo Linnainmaa in 1970 and Paul Werbos in 1974. But in 1986, David Rumelhart, Geoffrey Hinton, and Ronald Williams showed clearly how well it could train networks with hidden layers, and the idea spread. The teal branch was alive again. So, what could trained networks actually do? Think about the number eight. People write it in dozens of ways. Narrow loops. Wide loops. Tilted. Thick, faint, or broken. Try writing rules for every possible eight, and you'll never finish. But all those eights share smaller pieces. Curves. Crossings. Loops. What if a network could learn to spot those pieces, wherever they appear? Here's the idea. Instead of looking at the whole image at once, look through a small window, just three by three pixels. The window holds nine knobs, nine weights. Multiply each pixel by its weight, add them up, and you get one number: how strongly this patch matches the pattern. Now slide the same window one step. Same nine weights. New patch. New number. Slide it everywhere, and you get a new image, a feature map, that lights up wherever the pattern appears. This is a convolutional neural network, or CNN. And here's the key. Nobody sets those nine weights by hand. They're learned with backpropagation, the same way as before. Some filters learn to respond to edges at one angle. Others, to curves or corners. Stack layers of these. The first finds small edges. The next combines edges into curves and loops. Later layers combine those into whole shapes. At the end, the network makes its call. Eight. In 1989, Yann LeCun and colleagues at Bell Labs trained networks like this to read handwritten zip codes. By the late 1990s, a descendant of that work was reading a large share of the checks written in the United States. Instead of writing visual rules, we could train a model to learn its own visual features. But neural networks weren't the only things learning from data. Think back to the perceptron's flowers. Every example came with an answer: this one is species A, that one is species B. The machine predicted, compared with the answer, and adjusted. That kind of learning, from examples paired with the correct answers, is called supervised learning. The answers act like an answer key. And there's more than one way to learn from one. Let's try a new problem. A factory records two things about each machine: its temperature, and how much it vibrates. Its records also show which machines went on to fail. That's our answer key. One method, a decision tree, learns a short series of questions. Is the temperature above seventy degrees? If yes, is the vibration high? If yes: likely to fail. Another method, the support vector machine, learns a boundary instead, placed to leave the widest possible margin between the two groups. Same data. Same answer key. Two very different ways of drawing a decision. Others combine many simple models, letting hundreds of small trees vote. Each approach has strengths. Some work well with modest amounts of data. Some are easy to inspect: you can read a decision tree's questions. Others shine when the patterns are complicated and the data is plentiful. Newer isn't automatically better. Decision trees are still widely used today. But every method here shares one requirement. An answer key. What if you have mountains of data, and almost no answers? Here's the same kind of factory data, but now nobody has marked which machines failed. No answers at all. Just measurements. We can still ask: do the points naturally fall into groups? A clustering algorithm starts with a few guesses for group centers. Each point joins its nearest center. Each center moves to the middle of its points. Repeat. Three groups emerge. The algorithm doesn't know what they mean. But an engineer, looking closer, might recognise one as machines under light load, one as heavy load, and a small third group as something unusual worth checking. That's unsupervised learning: finding structure, without an answer key. But a pattern isn't automatically useful. A cluster might reveal a real problem, or just that half the readings came from a hotter room. Someone still has to look carefully. So now we've seen learning with answers, and learning without them. But what if the learner isn't handed a dataset at all? What if it has to act, and learn from what happens? Remember the game from the very beginning of this film? Here's a much simpler cousin. A small grid, one character, and a goal tile. This time, we'll give the learner one piece of information: when it reaches the goal, it gets a reward. A point. Nothing else. No map, no instructions. The learner, called an agent, tries an action, sees what happens, and keeps track of what led to reward. Turing's idea of pleasure and pain, made precise. Here's the hard part. The reward only comes at the very end. So which of the earlier moves deserve the credit? One clever answer: work backward from the reward. The square right before the goal is clearly valuable. So a square that leads there is valuable too, a little less so. Over many tries, value spreads backward from the goal, and the agent learns to follow it. That's how a policy, a strategy for choosing actions, can emerge from nothing but rewards. It also means a move that looks good now can be bad later, and the reverse. Good agents learn to care about the future. These ideas were developed through the 1980s, notably by Richard Sutton and Andrew Barto. In 1992, Gerald Tesauro at IBM combined them with a neural network to play backgammon. TD-Gammon learned mostly by playing against itself, hundreds of thousands of games, and reached a level close to the world's best players. But notice one thing about our grid game. We told the agent when it scored. In the game from the opening of this film, nobody says what winning means at all. That's an even harder problem. And we'll come back to it. In May 1997, in New York, IBM's Deep Blue beat the world chess champion, Garry Kasparov, in a six-game match. Kasparov had won their first match the year before. This time the machine won, three and a half games to two and a half. Chess had long been seen as a pinnacle of human intellect. So, was Deep Blue intelligent? To answer that, look at how it played. Deep Blue worked a lot like Samuel's checkers program, scaled up enormously. It searched ahead through possible moves and replies. At the end of each line, it scored the position with an evaluation function, crafted with help from chess grandmasters, and tuned on recorded games. And with custom chess chips, it could examine around two hundred million positions every second. It was a triumph of search, expert knowledge, and engineering. But it couldn't play checkers. It couldn't hold a conversation. It couldn't learn a new game on its own. Brilliant within its domain, and nowhere else. That difference, between narrow and general, will come back again and again. A photograph arrives all at once. But language unfolds over time. And the order matters. Read this sentence. The dog chased the ball, because it wanted to play. By the time you reach it, you're still carrying the dog in mind. A recurrent neural network works a bit like that. It reads one word at a time, and keeps a running memory, a small set of numbers it updates with every word. Each new word, plus the memory so far, produces a new memory. Like a summary that keeps being rewritten as you read. But what if the important word came much earlier? Imagine a long paragraph, where a name in the first sentence matters fifty words later. To learn that connection, training has to send the error signal backward through every one of those steps. And at each step, the signal tends to get multiplied by a small number. Shrink, shrink, shrink, and it fades away. Researchers including Sepp Hochreiter, in 1991, analysed exactly this, the vanishing gradient problem. In 1997, Hochreiter and Jürgen Schmidhuber introduced a fix: the Long Short-Term Memory network, or LSTM. It adds a protected memory track, with gates that learn when to keep information, when to write new information, and when to read it out. LSTMs became the workhorses of speech recognition, translation, and handwriting for years. But they still read one step at a time. And that would turn out to matter. By the 2000s, researchers already had many of the key ideas. Adjustable weights. Hidden layers. Backpropagation. Convolutional filters. Networks for sequences. So why weren't neural networks everywhere? Think of a great recipe. It doesn't help much if you have only a handful of ingredients and a tiny stove. Deep networks have a huge number of knobs. To set them well, they need lots of examples, and an enormous amount of calculation. In the 2000s, both were in short supply. Then, two things changed. First data. The internet filled with photos. And a team led by Fei-Fei Li built ImageNet: millions of images, each labelled by people with what it shows, across thousands of categories. A yearly competition asked programs to recognise objects across a thousand of those categories. Second computation. Graphics chips, GPUs, were designed for video games, to calculate millions of pixels at the same time. Training a neural network is mostly the same kind of work: huge numbers of simple multiplications that can run side by side. So researchers started training networks on graphics cards. In 2012, Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton entered a deep convolutional network, later called AlexNet, into the ImageNet competition. It was trained on two gaming graphics cards. Here's how the contest was scored. A program could make five guesses for each photo. If none of the five was right, it counted as an error. The best systems before had error rates around twenty-five percent. AlexNet's error rate was fifteen point three percent. The next-best entry: twenty-six point two. That wasn't a small step. It was a leap. And it convinced much of the field that deep neural networks, trained at scale, were the way forward for recognising images. AlexNet didn't invent convolutional networks. Those went back to the 1980s. Its success came from a combination. A good architecture, plus training tricks, plus lots of labelled data, plus GPU computing, all working together. That's a pattern we'll see again and again. An idea can wait for years, until the world around it catches up. But it raises a fascinating question. What exactly had the network learned, inside all those layers? Here are two photographs. An orange cat, in bright sunlight. A black cat, in shadow. To a computer, each photo is just a grid of numbers. And these two grids are almost completely different. Yet you see cat, instantly, in both. A trained network gets there step by step. Its early layers respond to small things: edges, and patches of color. Middle layers combine those into textures and shapes. Fur. Ears. An eye. Later layers respond to whole parts and objects. At each layer, the image becomes a new list of numbers, a new representation. And here's the payoff. In the network's later layers, the two cats, so different in pixels, end up with similar representations. Picture each image as a point in a space. In pixel space, the cats are far apart. In the network's learned space, they've moved close together, next to other cats, and away from dogs and cars. That's representation learning. We don't hand-design the features. The network learns descriptions that make the task easier. So, here's a thought. If networks can learn useful numbers for pictures, could they learn useful numbers for words? Computers work with numbers. So the simplest idea is to give every word a number. Cat is forty-two. Dog is seventy-three. Car is nineteen. But those numbers tell us nothing. Forty-two isn't closer to seventy-three because cats and dogs are both pets. What if, instead, each word got a whole list of numbers, a vector, learned so that words used in similar ways get similar lists? Here's the key insight. A linguist named J. R. Firth put it neatly in 1957: you shall know a word by the company it keeps. Look at these sentences. The dog slept on the sofa. The puppy slept on the sofa. Dog and puppy show up in the same kinds of places. In 2013, a team at Google led by Tomas Mikolov released Word2Vec, a fast way to learn word vectors by predicting which words appear near each other, across billions of words of text. Words that keep similar company end up with similar vectors. Nobody gave it a dictionary. It learned this from patterns of use alone. These spaces even showed some surprising patterns. In some trained models, take the vector for king, subtract man, add woman, and the nearest word is queen. Not a law of language. A tendency, in particular models, trained on particular text. But a striking one. There's a catch, though. Each word gets just one vector. Consider the word bank. We sat on the bank of the river. I paid the money into the bank. Same word. Completely different meanings. And one fixed vector can't be both. To understand a word, a model needs to look at the words around it, right there in that sentence. Let's translate a sentence from English into French. In 2014, researchers built translation systems from two recurrent networks. One, the encoder, reads the English sentence, word by word, updating its memory. When it reaches the end, its final memory is a summary of the whole sentence. The other, the decoder, starts from that summary and writes the French, one word at a time. For short sentences, that works surprisingly well. But imagine a long sentence. Several people, places, and events. All of it has to fit into that one fixed-size summary. It's like summarising a whole chapter on a single sticky note, and then translating the chapter from the note. Some details survive. Others get lost. And in fact, these systems got noticeably worse as sentences got longer. So researchers asked: what if the decoder didn't have to rely on one note? What if it could look back at the original sentence whenever it needed to? That's what attention does. Instead of throwing away the encoder's step-by-step memories, the model keeps all of them, one for each English word. Then, every time the decoder writes a word, it gives each English word a weight: how relevant is this one, right now? And it blends the memories using those weights. Watch. The English is the black cat is sleeping. In French, that's le chat noir dort. Notice that the order flips. Black cat becomes chat noir, cat first. To write chat, the model looks mostly at cat. To write noir, it looks back to black. To write dort, it looks at is sleeping. The weights change for every word it writes. And nobody programmed them. They're learned during training, with backpropagation, like everything else. Attention made translation noticeably better, especially for long sentences. By 2016, Google Translate had switched to a neural system built on recurrent networks with attention. But those recurrent networks still read the sentence one word at a time, each step waiting for the one before. Keep that in mind. It's about to matter a great deal. Remember how Deep Blue played chess? Search deep, then score positions with a hand-crafted formula. The ancient game of Go breaks that approach. The rules are simple. Players take turns placing black and white stones, trying to surround territory. But a 19-by-19 board allows more possible positions than there are atoms in the observable universe. Searching deeply is hopeless. And it's very hard to write a good formula for who's winning. Strong players often say they rely on intuition. So how could a machine compete? AlphaGo, from a company called DeepMind, combined three ideas we've already seen. First, a deep neural network trained on millions of positions from expert human games, to suggest promising moves. A learned intuition. Second, another network trained to judge a position: who's likely to win from here? Third, search, now guided by those networks. It explores only the moves that look promising, and checks the positions it reaches with the judging network. And then it improved by playing against itself, millions of times, with reinforcement learning. Learning guided the search. Search sharpened the decisions. And self-play supplied the experience. Deep Blue's evaluation was written by people. AlphaGo's was learned. In March 2016, in Seoul, AlphaGo played Lee Sedol, one of the world's strongest players. In game two, it played a move on the 37th turn that surprised the commentators. Many first thought it was a mistake. It turned out to be brilliant. AlphaGo won the match, four games to one. But it was still built for one game. It couldn't translate a sentence, or explain why the Moon doesn't fall. The next leap would come not from games, but from that translation problem, and that step-by-step reading. Remember that step-by-step reading? Each word waits for the one before. Fine for a short sentence, but slow to train on huge amounts of text, because you can't do the steps at the same time. In 2017, eight researchers, most of them at Google, published a paper with a bold title. Attention Is All You Need. Their question: what if we dropped the recurrence completely, and built the whole model out of attention? They called the result the Transformer. Here's the core idea. It's called self-attention. Every word in a sentence looks at every other word, and decides which ones matter for understanding it. Remember our two sentences with bank? We sat on the bank of the river. Here, bank pays strong attention to river. And its meaning shifts toward riverside. I paid the money into the bank. Now bank pays attention to money. And its meaning shifts toward finance. Same word, different context, different meaning. The problem from word vectors, solved. And this happens for every word at once, layer after layer, each layer refining the meanings further. Two more details. If every word looks at every word at once, how does the model know the order? Dog bites man isn't man bites dog. So each word also gets a signal describing its position. And because the words no longer wait in line, a Transformer can process a whole sentence in parallel during training. That fits perfectly with GPUs, the chips that do many calculations side by side. The original Transformer was built for translation. But its design turned out to be useful almost everywhere. So how does a word decide what to pay attention to? Think about searching a library. You have a question in mind. That's your query. Each book has a title on its spine. That's its key. And inside each book is the actual content. That's its value. You compare your question with every title, then read most from the books whose titles match best. Self-attention works the same way. Every word produces three lists of numbers: a query, what it's looking for; a key, what it offers; and a value, the information it can pass along. The model learns how to make these during training. Let's follow bank. Its query is compared with the key of every word. Each comparison gives a score. A high score means a good match. Say river scores two. Sat scores a half. The scores point one. Next, these scores are turned into weights that add up to one. That gives about seventy-three percent for river, sixteen for sat, and eleven for the. Finally, bank takes a blend of everyone's values, mixed in those proportions: mostly river's information, a little of the others. That blend updates bank's meaning. Now it carries a sense of water. Score. Weight. Blend. And nothing here is a hand-written rule that says river means riverbank. The numbers that make the queries, keys, and values are learned from data. One attention pattern can only capture one kind of relationship at a time. So Transformers run several in parallel, called heads. One might track which words describe which. Another might connect a pronoun to the noun it refers to. Their results are combined, then passed through a small feed-forward network. Together, that's one Transformer block. Stack dozens of them, and the meanings get richer at every layer. We don't need every engineering detail. The heart of it is this: attention lets words share information with exactly the words that matter to them. And it turns out the same architecture could be trained to do very different things. Remember the answer key? Supervised learning needs examples paired with correct answers. To learn language really well, a model would need an enormous number of examples. But nobody could pay people to label the whole internet. Here's the clever trick. Text already contains its own answers. Take a sentence. Hide a piece of it. Ask the model to predict the missing piece. Then reveal it, and check. Every sentence ever written becomes a practice question, with the answer built in. That's called self-supervised learning. There are two popular ways to hide the answer. One is fill in the blank. The ___ chased the ball. The model can look at words on both sides of the gap to guess dog. In 2018, researchers at Google trained a Transformer this way, called BERT. It became very good at understanding text: classifying it, finding answers inside it. The other way is even simpler. Predict what comes next. Give the model the beginning, The dog chased the, and ask for the next piece. It can only look backward, never at what comes later. These pieces are called tokens. Often a whole word, sometimes part of one. The model guesses ball. It checks against the real text. Then it moves one step along and predicts again. Each wrong guess produces a loss. Backpropagation works out how every knob should change. And the knobs get nudged. The same loop as the perceptron and the XOR network, just with billions of knobs, and billions of sentences. In 2018, OpenAI trained a Transformer this way, called GPT. That name will come back. One important thing, though. The model is learning to predict text. Whatever the text says, right or wrong. It picks up an astonishing amount about grammar, facts, and reasoning patterns along the way. But it's learning what text tends to say, not checking whether it's true. Keep that in mind. It'll matter later. For now, the question researchers asked was simple. What happens if we make these models much, much bigger? There are three main things you can scale. The number of knobs, which researchers call parameters. The amount of text the model learns from. And the amount of computation used to train it. GPT-2, in 2019, had about one and a half billion parameters. GPT-3, in 2020, had a hundred and seventy-five billion. And something interesting happened as they grew. Give a small model and a large model the same prompt. Translate into French: cheese. The small model wanders off. It continues the text, but not usefully. The large model writes fromage. Even more striking, you could show the large model a few examples in the prompt itself, and it would pick up the pattern and continue it, without any extra training. Researchers measured how prediction improved with scale and found something remarkable: the improvement followed smooth, predictable curves. Later work showed it matters how you balance the dials. In 2022, a model called Chinchilla showed that many large models had been trained on too little text for their size. But better at predicting text isn't the same as always being right. These models could still state false things confidently, and stumble on simple reasoning. And there was a more basic problem. Ask GPT-3 a question, and it might answer. Or it might just continue the document, as if your question were the first line of a quiz. Remember: the model was trained to continue text, not to be helpful. So researchers trained it a little more, on a different kind of text: thousands of examples of instructions, each paired with a good response, written by people. Explain photosynthesis simply. And a clear, simple explanation. Summarise this email. And a good summary. After this extra training, called instruction tuning, the model gets much better at treating your words as a request, and answering. But some good answers are better than others. So people were shown several answers to the same request, and asked which they preferred. Those choices trained a separate model, a reward model, to predict what people would prefer. Then reinforcement learning, the trial-and-reward idea from earlier, nudged the language model toward answers that the reward model scored highly. This is reinforcement learning from human feedback, or RLHF. It was developed from 2017 onward, and used in 2022 to make OpenAI's InstructGPT models more helpful. In a way, it's a distant echo of Turing's idea in 1948. Teach a machine with rewards. But there's a catch. Answers people prefer aren't always answers that are true. A confident, pleasant answer can still be wrong. On November 30, 2022, OpenAI released ChatGPT to the public. You could type a question, and get a conversational answer. Ask a follow-up. Ask it to try again, more simply. Within weeks, millions of people were using it. Remember the question from the very beginning? Why doesn't the Moon simply fall to Earth? This is that conversation. For many people, it felt like a sudden leap. But now you can see what's inside. Artificial neurons, from 1943. Adjustable weights, from the perceptron. Backpropagation, to train many layers. Learned representations, from deep learning. Word vectors. Attention. The Transformer. Self-supervised training on enormous amounts of text. And instruction tuning and human feedback, to make it an assistant. None of this came from one lab, one person, or one moment. It came from thousands of researchers, across eight decades, building on one another's work. But text is only one thing these systems can make. ChatGPT generates text. But generative AI isn't one particular algorithm. It's a capability, making new content, and different methods can provide it. For images, researchers tried several approaches, including networks that competed against each other, introduced in 2014. But one approach became especially influential. It starts with noise. Take a photo. Add a little random noise. Then a little more. And more. Eventually, it's pure static. Now train a network on the reverse job: given a noisy image, predict the noise, so it can be removed, one small step at a time. Show it millions of images, at every level of noise, and it gets very good at that one job. Then comes the clever part. Start from pure static, and run the denoising again and again. Structure appears. Then shapes. Then detail. A new image, that didn't exist before. To make the picture you asked for, the denoising is guided by your words. Ask for a small red boat on a quiet lake at dawn. At each step, the model removes noise in a direction that makes the image match that description a little better. First the horizon. Then the lake. Then a small red shape that becomes a boat. Systems like DALL·E 2 and Stable Diffusion, both released in 2022, brought this to millions of people. And increasingly, AI systems weren't just producing one kind of content. They were taking in several kinds at once. Imagine taking a photo of your bicycle, and asking: what's wrong with this tire? To answer, a system has to connect two very different kinds of information. Pixels, and words. Remember how a network can turn an image into a useful list of numbers? And how words become vectors? In 2021, OpenAI's CLIP showed how to train those two together, on hundreds of millions of images paired with captions, so that a picture and a matching description end up close together in the same space. Connect a vision part like that to a language model, and the model can talk about what it sees. The same idea extends to speech, and to video. You can talk to some assistants, and they talk back. But there's a big difference between describing a problem and fixing it. An assistant might tell you the tire is flat. It can't patch the tube. To go from answers to actions, an AI system needs tools, and a way to use them. That's what people mean by an agent. Suppose a small program has a bug. The total on a shopping cart is wrong. Ask an AI assistant about it, and it might suggest some likely causes. Useful advice. Now ask it to actually fix the bug. That's a different job. It has to open the project and read the relevant code. Find the line that's wrong. Change it. Run the tests. And see whether the fix actually worked. Let's say the first test run fails. One test still breaks. So the agent reads the error, looks again, and makes a second change. Tests run again. This time, they pass. That's the loop. Observe. Decide. Act. Check. And go around again. If it looks familiar, it should. It's the same shape as the reinforcement-learning loop we saw with the little grid game. But a capable loop isn't automatically a safe or reliable one. What the agent is allowed to touch, how well its tools work, and how carefully results are checked, all make a huge difference. And once AI systems act on real things, one question becomes impossible to ignore. How often do they get it right? Modern AI systems can sound remarkably sure of themselves. But remember what they were trained to do. Predict text that looks right. And give answers people tend to prefer. Neither is the same as being correct. Ask for a source, and a system might give you a perfectly formatted citation, for a paper that doesn't exist. Ask for code, and it might write something that looks fine but fails an important test. That's why checking matters. Checking claims against sources. Testing code. Limiting what an agent is allowed to do on its own. Long tasks make this harder. Imagine a task with twenty steps. And suppose each step succeeds ninety-five percent of the time. That sounds very reliable. What are the chances that all twenty succeed? Only about thirty-six percent. Real tasks aren't that simple. Mistakes aren't always independent, and good agents can sometimes notice and fix their errors. But the lesson holds. Long tasks need more than good individual steps. They need checking and recovery all the way through. So researchers have started measuring exactly this. In 2025, a research group called METR collected software tasks and measured how long each took skilled humans. A few minutes for some. Many hours for others. Then they asked: how long a task, measured in human time, can an AI agent complete about half the time? That's called its time horizon. It isn't how long the AI runs. It's how difficult a task it can handle, measured by how long that task takes a person. On their tasks, that time horizon had been doubling roughly every seven months, from 2019 to early 2025. It's one useful measure. But it covers particular kinds of tasks. And no single measure captures everything we mean by intelligence. To track progress, researchers use benchmarks: fixed sets of tasks, with clear ways to score them. Some test hard science questions. Some test real software fixes. Others test reasoning, perception, or interaction. They're genuinely useful. But a high score on one benchmark tells you about that kind of task, in that format. A system can do brilliantly on familiar kinds of problems, and struggle when the situation is new. So the better question isn't just how intelligent is it? It's what can it do, under what conditions, and how reliably? Now, remember the game from the very beginning? No instructions. No explanation of the controls. Not even a hint of what winning means. When we built our little grid game, we gave the learner a reward. A point for reaching the goal. This game gives you nothing. To succeed, you'd have to explore. Notice what changes. Guess at the rules. Test the guess. And adapt. People do this all the time. It's how you'd figure out a new board game, or an unfamiliar app. In March 2026, the ARC Prize Foundation launched a benchmark built around exactly this, called ARC-AGI-3. Hundreds of small game worlds. No instructions, no stated goals. At launch, the people tested could solve them. The best AI systems solved well under one percent. It's one way of probing adaptability, not a final definition of intelligence. But it shows how open this question still is. This brings us to the phrase you've probably heard: artificial general intelligence, or AGI. AGI isn't a type of neural network, or a branch of this tree. It's a goal: machines that are broadly capable, across many kinds of tasks. And there's no single agreed definition, or single test. Some definitions focus on how many tasks a system can do well. Others on how quickly it can learn something new, or how independently it can work. We've seen both sides of this all through the story. Deep Blue and AlphaGo were extraordinary at one thing. Today's assistants can do a remarkable range of things, and still fail at some that people find easy. Keeping those differences clear is the best way to judge any claim about where AI is heading. Let's step back, and look at the whole tree. At its roots, two ideas from the 1930s and '40s. Machines that follow precise steps. And networks of simple, neuron-like units. From them, one field with two great branches. One gave machines knowledge and rules. It brought us logic programs, and expert systems. The other let machines learn from experience. It grew into many methods, and one of them, neural networks, grew into deep learning. Around the tree, the different ways of learning: with answers, without them, from rewards, and from the data itself. And in the canopy, what these systems can now do: generate, see, and act. Three patterns run through the whole story. First, big advances often came from combining ideas. AlphaGo joined search, deep networks, and reinforcement learning. ChatGPT joined decades of work. Second, good ideas often had to wait. Neural networks needed data and computing power to catch up with them. And third, being brilliant at one thing isn't the same as being good at everything. From Deep Blue to today, the gap between narrow and general has never quite closed. We began with two challenges. An AI assistant explaining why the Moon doesn't fall to Earth. And a game with no instructions, and no idea what winning means. Today, machines are astonishingly good at the first kind. The second, working out something genuinely new, reliably, is still one of the great open questions. What will it take to build machines that can learn their way through situations nobody prepared them for? Nobody knows yet. But if this story is any guide, the answer may come from connecting ideas that already exist, in ways no one has imagined. Until next time, stay mildly curious.

Assistir ao vídeo original no YouTube

Assuntos: Agentes de IA, Assistente pessoal, AGI. Publicado no YouTube em 2026-11-01.

Seleção automática por assunto e idioma. O vídeo pertence ao canal de origem.

Comentários

Postagens mais visitadas deste blog

How to build a JARVIS AI Voice Agent for FREE | Full Livekit Tutorial (2026)

How Does AI Actually Work? 🤖 | AI, Machine Learning & Generative AI Explained