You might have missed an overlap in Saturday’s debate, Meyer v. Krauss v. Lamoureux, with headlines in technology news. A computer algorithm, AlphaGo, has crossed a threshold, beating a champion player of the Chinese board game Go. In the debate, “What’s Behind It All? God, Science, and the Universe,” Lawrence Krauss adduced such feats as support for algorithms as a fair model of Darwinian processes. To Meyer’s objection that a program requires a programmer, Krauss responded that the software in question “did not in fact require input from a programmer. It was a perfect example of natural selection.” What’s behind the exchange?
From The Guardian:
The computer programme that defeated the world Go champion taught itself how to improve its game by playing millions of matches against itself, according to the head of the Google subsidiary that developed the software.
Demis Hassabis, who co-founded DeepMind, the London-based unit that built the AlphaGo programme, said that he hoped to use the same technique to help Google improve its own products, such as its phone assistants and search engines.
“We call it deep reinforcement learning,” Hassabis said. “It’s the combination of deep learning, neural network stuff, with reinforcement learning: so learning by trial and error, and incrementally improving and learning from your mistakes and your errors, so that you improve your decisions.”
If a program can teach itself, does that indeed model the power of natural selection, acting without intelligent design? A friend of ours, an elite architect-level Microsoft programmer, isn’t convinced. He writes:
I wanted to offer a bit of insight, if you’ll allow, on AlphaGo. A close friend [in the world of Artificial Intelligent research] and I were out at local pub last Friday. We often discuss current trends, including AI. Among our topics on Friday was AlphaGo as my friend had just returned from a conference in Arizona where DeepMind (the Google-owned company) presented on AlphaGo.
As you well know, there is a lot of misinformation about how these programs work. AlphaGo is no different. First, AlphaGo did not teach itself at all. Second, AlphaGo is actually a combination, roughly of two styles: Classic AI plus (so called) Neural Nets. Let me put each part in perspective.
Go, as you know, is hard to beat because the board positions suffer combinatorial explosion. (I’ve heard the possible board positions exceed the number of estimated atoms in the universe.) Combinatorial explosion defeats Classic AI techniques because they are fairly wooden search schemes (that is, depth/breadth first with clever trimming along the way). Without the insight of a human, or some other function, knowing if a board position is good or bad entails playing the game to end against all possible competitive positions. Since such searches are too costly, Classic AI searches a limited space combined with functions that estimate the goodness or badness of a board position. Go’s combinatorial space has precluded both deep search and successful estimation of a positions quality.
AlphaGo mostly cracked that second nut: They developed a means to reliably evaluate the quality of a board position and for this they used layered (aka Deep) Neural Nets. Neural Nets excel at just one thing: pattern matching. That is, Neural Nets, deep or otherwise, are only capable of saying whether the thing they’re given matches (broadly) some pattern. The “thing” is first quantized (e.g., an image is broken into its pixels) and each quantity is fed to a node in the network. That input, plus a weighting value (more or less) at that node, determines if the node signals its neighbors and the “strength” of that signal. These signals cascade through the network producing a single value weighting whether the combined nodes “recognize” the inputs as corresponding to a predefined pattern. Patterns here can be very complex. They need not be, are not usefully, a single thing, but a type of thing, such as a cat photograph or, in this case, a high-quality Go board position or high-value move. Neural Nets get “trained” by feeding many “images” into the network and then scoring the result (kind of a backward cascade upward through the network) that tweaks the weights at each node and the signals sent/received. With sufficient training (undergirded by careful math), a Neural Net can be “taught” to recognize a set of patterns. AlphaGo succeeded in creating Deep Neural Networks which successfully evaluated the quality of Go board positions and high-value moves. (By the way, Deep means that the networks feed other networks, with each network, perhaps, trained in only a portion of the overall evaluation.) The only way that AlphaGo trained itself was to, relying on the rules of Go, repeatedly play itself (that is, move pieces about using its own evaluation function) and then use those results to further tune the network. It did not change its rules. It did not learn new rules. It did not learn strategy. It only got better and better and better at recognizing a high-quality board positions and high-value moves.
To play Go, AlphaGo continues to use Classic AI but augmented it with a useful evaluation function of Go board positions. That’s it. It is impressive programming. But it is a Universe away from any kind of knowledgeable system. Further, their approach works only for, what’s termed, “Perfect Knowledge” systems…such as games. The real world is not a perfect knowledge system…by far.
AlphaGo, apparently, during the match made similarly goofy moves, just like IBM’s Watson can do, because it lacks intelligence and insight. A slight bump in the wrong direction and the program can skid down a hill into silliness that no human would tolerate because it doesn’t know any better. In fact, it doesn’t know at all.
In any case, I hope this is helpful.
Yes, it is helpful. For more on AlphaGo’s use of Deep Neural Nets and Classic AI, see here and here. It was a minor part of the conversation in Toronto but, like much of the rest from Meyer’s opponents, misleading.
Image: Go, by Goban1 (Own work) [Public domain], via Wikimedia Commons.