Hi, I’m Carrie Anne, and welcome to Crash Course Computer Science!
As we’ve touched on many times in this series, computers are incredible at storing, organizing,
fetching and processing huge volumes of data.
That’s perfect for things like e-commerce websites with millions of items for sale,
and for storing billions of health records for quick access by doctors.
But what if we want to use computers not just to fetch and display data, but to actually
make decisions about data?
This is the essence of machine learning – algorithms that give computers the ability to learn from
data, and then make predictions and decisions.
Computer programs with this ability are extremely useful in answering questions like Is an email
spam?
Does a person’s heart have arrhythmia?
What video should youtube recommend after this one?
While useful, we probably wouldn’t describe these programs as “intelligent” in the
same way we think of human intelligence.
So, even though the terms are often interchanged, most computer scientists would say that machine
learning is a set of techniques that sits inside the even more ambitious goal of Artificial
Intelligence, or AI for short.
INTRO
Machine Learning and AI algorithms tend to be pretty sophisticated.
So rather than wading into the mechanics of how they work, we're going to focus on what
the algorithms do conceptually.
Let’s start with a simple example: deciding if a moth is a Luna Moth or an Emperor Moth.
This decision process is called classification, and an algorithm that does it is called a
classifier.
Although there are techniques that can use raw data for training – like photos and
sounds – many algorithms reduce the complexity of real world objects and phenomena into what
are called features.
Features are values that usefully characterize the things we wish to classify.
For our moth example, we’re going to use two features: “wingspan” and “mass”.
In order to train our machine learning classifier to make good predictions, we’re going to
need training data.
To get that, we’d send an entomologist out into a forest to collect data for both luna
and emperor moths.
These experts can recognize different moths, so they not only record the feature values,
but also label that data with the actual moth species.
This is called labeled data.
Because we only have two features, it’s easy to visualize this data in a scatterplot.
Here, I’ve plotted data for 100 Emperor Moths in red and 100 Luna Moths in blue.
We can see that the species make two groupings, but….
there’s some overlap in the middle… so it’s not entirely obvious how to best separate
the two.
That’s what machine learning algorithms do – find optimal separations!
I’m just going to eyeball it and say anything less than 45 millimeters in wingspan is likely
to be an Emperor Moth.
We can add another division that says additionally mass must be less than .75 in order for our
guess to be Emperor Moth.
These lines that chop up the decision space are called decision boundaries.
If we look closely at our data, we can see that 86 emperor moths would correctly end
up inside the emperor decision region, but 14 would end up incorrectly in luna moth territory.
On the other hand, 82 luna moths would be correct, with 18 falling onto the wrong side.
A table, like this, showing where a classifier gets things right and wrong is called a confusion
matrix... which probably should have also been the title of the last two movies in the
Matrix Trilogy!
Notice that there’s no way for us to draw lines that give us 100% accuracy.
If we lower our wingspan decision boundary, we misclassify more Emperor moths as Lunas.
If we raise it, we misclassify more Luna moths.
The job of machine learning algorithms, at a high level, is to maximize correct classifications
while minimizing errors
On our training data, we get 168 moths correct, and 32 moths wrong, for an average classification
accuracy of 84%.
Now, using these decision boundaries, if we go out into the forest and encounter an unknown
moth, we can measure its features and plot it onto our decision space.
This is unlabeled data.
Our decision boundaries offer a guess as to what species the moth is.
In this case, we’d predict it’s a Luna Moth.
This simple approach, of dividing the decision space up into boxes, can be represented by
what’s called a decision tree, which would look like this pictorially or could be written
in code using If-Statements, like this.
A machine learning algorithm that produces decision trees needs to choose what features
to divide on…and then for each of those features, what values to use for the division.
Decision Trees are just one basic example of a machine learning technique.
There are hundreds of algorithms in computer science literature today.
And more are being published all the time.
A few algorithms even use many decision trees working together to make a prediction.
Computer scientists smugly call those Forests… because they contain lots of trees.
There are also non-tree-based approaches, like Support Vector Machines, which essentially
slice up the decision space using arbitrary lines.
And these don’t have to be straight lines; they can be polynomials or some other fancy
mathematical function.
Like before, it’s the machine learning algorithm's job to figure out the best lines to provide
the most accurate decision boundaries.
So far, my examples have only had two features, which is easy enough for a human to figure
out.
If we add a third feature, let’s say, length of antennae, then our 2D lines become 3D planes,
creating decision boundaries in three dimensions.
These planes don’t have to be straight either.
Plus, a truly useful classifier would contend with many different moth species.
Now I think you’d agree this is getting too complicated to figure out by hand…
But even this is a very basic example – just three features
and five moth species.
We can still show it in this 3D scatter plot.
Unfortunately, there’s no good way to visualize four features at once, or twenty features,
let alone hundreds or even thousands of features.
But that’s what many real-world machine learning problems face.
Can YOU imagine trying to figure out the equation for a hyperplane rippling through a thousand-dimensional
decision space?
Probably not, but computers, with clever machine learning algorithms can… and they do, all
day long, on computers at places like Google, Facebook, Microsoft and Amazon.
Techniques like Decision Trees and Support Vector Machines are strongly rooted in the
field of statistics, which has dealt with making confident decisions, using data, long
before computers ever existed.
There’s a very large class of widely used statistical machine learning techniques, but
there are also some approaches with no origins in statistics.
Most notable are artificial neural networks, which were inspired by neurons in our brains!
For a primer of biological neurons, check out our three-part overview here, but basically
neurons are cells that process and transmit messages using electrical and chemical signals.
They take one or more inputs from other cells, process those signals, and then emit their
own signal.
These form into huge interconnected networks that are able to process complex information.
Just like your brain watching this youtube video.
Artificial Neurons are very similar.
Each takes a series of inputs, combines them, and emits a signal.
Rather than being electrical or chemical signals, artificial neurons take numbers in, and spit
numbers out.
They are organized into layers that are connected by links, forming a network of neurons, hence
the name.
Let’s return to our moth example to see how neural nets can be used for classification.
Our first layer – the input layer – provides data from a single moth needing classification.
Again, we’ll use mass and wingspan.
At the other end, we have an output layer, with two neurons: one for Emperor Moth and
another for Luna Moth.
The most excited neuron will be our classification decision.
In between, we have a hidden layer, that transforms our inputs into outputs, and does the hard
work of classification.
To see how this is done, let’s zoom into one neuron in the hidden layer.
The first thing a neuron does is multiply each of its inputs by a specific weight, let’s
say 2.8 for its first input, and .1 for it’s second input.
Then, it sums these weighted inputs together, which is in this case, is a grand total of
9.74.
The neuron then applies a bias to this result - in other words, it adds or subtracts a fixed
value, for example, minus six, for a new value of 3.74.
These bias and inputs weights are initially set to random values when a neural network
is created.
Then, an algorithm goes in, and starts tweaking all those values to train the neural network,
using labeled data for training and testing.
This happens over many interactions, gradually improving accuracy – a process very much
like human learning.
Finally, neurons have an activation function, also called a transfer function, that gets
applied to the output, performing a final mathematical modification to the result.
For example, limiting the value to a range from negative one and positive one, or setting
any negative values to 0.
We’ll use a linear transfer function that passes the value through unchanged, so 3.74
stays as 3.74.
So for our example neuron, given the inputs .55 and 82, the output would be 3.74.
This is just one neuron, but this process of weighting, summing, biasing and applying
an activation function is computed for all neurons in a layer, and the values propagate
forward in the network, one layer at a time.
In this example, the output neuron with the highest value is our decision: Luna Moth.
Importantly, the hidden layer doesn’t have to be just one layer… it can be many layers
deep.
This is where the term deep learning comes from.
Training these more complicated networks takes a lot more computation and data.
Despite the fact that neural networks were invented over fifty years ago, deep neural
nets have only been practical very recently, thanks to powerful processors, but even more
so, wicked fast GPUs.
So, thank you gamers for being so demanding about silky smooth framerates!
A couple of years ago, Google and Facebook demonstrated deep neural nets that could find
faces in photos as well as humans – and humans are really good at this!
It was a huge milestone.
Now deep neural nets are driving cars, translating human speech, diagnosing medical conditions
and much more.
These algorithms are very sophisticated, but it’s less clear if they should be described
as “intelligent”.
They can really only do one thing like classify moths, find faces, or translate languages.
This type of AI is called Weak AI or Narrow AI.
It’s only intelligent at specific tasks.
But that doesn’t mean it’s not useful; I mean medical devices that can make diagnoses,
and cars that can drive themselves are amazing!
But do we need those computers to compose music and look up delicious recipes in their
free time?
Probably not.
Although that would be kinda cool.
Truly general-purpose AI, one as smart and well-rounded as a human, is called Strong
AI.
No one has demonstrated anything close to human-level artificial intelligence yet.
Some argue it’s impossible, but many people point to the explosion of digitized knowledge
– like Wikipedia articles, web pages, and Youtube videos – as the perfect kindling
for Strong AI.
Although you can only watch a maximum of 24 hours of youtube a day, a computer can watch
millions of hours.
For example, IBM’s Watson consults and synthesizes information from 200 million pages of content,
including the full text of Wikipedia.
While not a Strong AI, Watson is pretty smart, and it crushed its human competition in Jeopardy
way back in 2011.
Not only can AIs gobble up huge volumes of information, but they can also learn over
time, often much faster than humans.
In 2016, Google debuted AlphaGo, a Narrow AI that plays the fiendishly complicated board
game Go.
One of the ways it got so good and able to beat the very best human players, was by playing
clones of itself millions and millions of times.
It learned what worked and what didn’t, and along the way, discovered successful strategies
all by itself.
This is called Reinforcement Learning, and it’s a super powerful approach.
In fact, it’s very similar to how humans learn.
People don’t just magically acquire the ability to walk... it takes thousands of hours
of trial and error to figure it out.
Computers are now on the cusp of learning by trial and error, and for many narrow problems,
reinforcement learning is already widely used.
What will be interesting to see, is if these types of learning techniques can be applied
more broadly, to create human-like, Strong AIs that learn much like how kids learn, but
at super accelerated rates.
If that happens, there are some pretty big changes in store for humanity – a topic
we’ll revisit later.
Thanks for watching.
See you next week.