The Rise of Machine Learning

The AI revolution is underway thanks to machine learning.

The first wave of Information Age automation involved programmers manually defining everything their computer systems should do. As discussed in the last chapter, this fits will into the model for all previous eras of automation, where a human designs a piece of technology to make a machine that does things faster, cheaper, etc.

The introduction of machine learning (ML) turned all of that on its head. While the old way of automation focused on throwing processing power at simple, well-defined tasks, machine learning takes a different approach.

The old way's big limitation in the age of cheap, abundant processing power is the ability to define and execute a set of steps (an algorithm). If the task is straightforward, like assembling a car bumper, then that's not particularly hard to get that algorithm up and running.

That approach runs into problems in domains where there's a large amount of variability and a substantial number of choices that have to be made on a regular basis.

This presented problems in the past because old methods relied on the limited brains of programmers, who can only account for a small number of possibilities for any given activity. Constructing logical constructs of how to do something becomes untenable quickly for all but the most basic activities.

Enter machine learning (ML). Rather than depending on programmers determining all possible paths ahead of time, ML uses data to generate programs that solve problems on their own. You can think of ML like a big, black box that takes in data (as much as you can give it) and spits out programs.

There are a bunch of different ways to generate these programs, but the type of ML creating the most economic value right now is a set of techniques known as supervised learning. Supervised learning revolves around using data to find patterns, and then building programs that utilize those patterns in some way.

Another popular set of techniques is reinforcement learning (RL), in agents maximize some kind of reward while operating within a specific environment. RL has been at the core of the most famous AI game playing systems, such as DeepMind's AlphaGo and AlphaGo Zero.

The specifics of those particular topics are very math-heavy and not particularly relevant for right now, so we're not going to zero in on the details. For now, just remember this: ML is all about using data to infer patterns, create models around those patterns and then generate some kind of automated output.

ML Out in the Wild

An example that you've probably already used today is the way that Google suggests things when you use the search bar. The suggestions you get were not manually entered by a programmer—that would be far too labor-intensive.

Instead, Google utilizes machine learning to constantly scan their incoming search data and spot patterns in the search terms.

If you go to Google right now and type in "What is..." you'll see some suggestions, which are likely not related to what you're looking for. That's because that phrase is extremely broad. Once you narrow it down a little bit, like "What is machine" you'll get closer to what you want.

Google can do this because their ML algorithms recognize that those combinations of words tend to lead to specific searches. As more and more people use their search engine, those algorithms automatically build those suggestions and give people increasingly relevant results.

The only reason Google can do this so effectively is because they deal with enormous amounts of data. On any given day, they're processing 40,000 searches per second.

If Google was just starting out and processing only a few searches a day, then they'd have to wait a long time before they had enough data to use ML. That's because ML systems utilize statistics to spot patterns, and it's very difficult to accurately spot patterns with small sample sizes.

Building Houses vs. Growing Plants

The reason ML technology is so powerful is that it allows programmers to teach software how to do things, rather than strictly define what software should do. Once data is available, ML algorithms can continuously improve themselves and generate increasingly complex programs.

There's an element of mystery to the whole ML process as a result of this, because the algorithms are generating programs on their own. Programmers are no longer specifying all the moving parts of their software, and are instead simply telling their ML systems what kind of end results they want (better searches, improved movie recommendations, etc.).

Because they aren't designing the output programs, they often have no idea exactly how they work. As crazy as that may sound to those outside of the tech world, this is the norm when you're dealing with massive amounts of data and throwing them into ML algorithms. It's a big, extremely profitable set of black boxes.

Take, for example, self-driving cars. Even though Google and several other companies have built vehicles that can drive themselves, nobody knows exactly how they do it. This is because self-driving cars use ML to teach themselves how to drive, and it's a process of adaptation rather than explicit instruction.

First, the engineers working on these projects design a set of target outputs. Their primary goal is to have the car drive itself safely (an important distinction, since a car could get to its destination in a variety of very unsafe ways), so the goal is to have a program that knows when to stop at stoplights, make U-turns, merge onto the freeway, and so on.

The engineers then slap a plethora of sensors onto their prototype vehicles, and then allow them to drive around. When the vehicle makes a mistake (like stopping when it shouldn't), it looks at the data surrounding that mistake, updates its internal algorithm, then tries again.

While the engineering team is not entirely hands-off — they have to regularly make tweaks to the ML systems to ensure the targets are understood and correct — the task of driving is not defined by them. They simply tell the ML systems what outputs they want, and the car figures out the rest.

The differences between traditional software systems and ML systems can be compared to the difference between building a house (old way of building software) and growing a plant (new way of building software). A house is built by laborers from blueprints that are created by an architect. The laborers are expected to follow the design laid out in those blueprints exactly, and they fully understand what the end product will be because of the nature of that construction process.

Growing a plant, on the other hand, involves placing a seed into soil and then tending to it until it turns into a bush, a tree, a tuber, and so on. How well it turns out depends on how much water you use, what nutrients you put into the soil, etc. You don't have to understand everything about that growth process to get what you want out of the plant, but you do need to provide it with the right environment to thrive.

That's ML in a nutshell: you give an ML system some data, and see what comes out. It's a completely different mindset than what most people are used to, but it's becoming increasingly popular as AI gets more advanced.