JOSH GORDON: Hey, everyone.

Welcome back.

In this episode, I'll show you how

to train your own image classifier starting from just

a directory of images.

For example, say you want to build a classifier that

can tell the difference between a picture of a T.

rex and a triceratops.

Or maybe you want to classify a painting

as being a Monet or Picasso.

To do that, we'll work with a code lab

called TensorFlow for Poets.

And this is a great way to get started

learning about and working with image classification.

Now two things off the bat.

First, this code lab is high level.

To train our classifier, we'll basically just need

to run a couple of scripts.

But what's impressive is what the classifier will create

is better than what I could have written

myself just a few years ago.

As we go, I'll show you how the code lab looks in action,

and I'll add context and background

on why it works so well.

OK, let's get started.

To train an image classifier with TensorFlow for Poets,

we'll only need to provide one thing-- training data.

Here that's just directories full of images.

My plan is to create a classifier

to tell the difference between five types of flowers--

roses, sunflowers, and so on.

And here's what my training data looks like.

Notice that I have five directories, one

for each type of flower.

Inside each directory are lots of pictures.

And the reason I'm working with flowers

is we provided this data set in the code lab

so you can get started right away.

If you want to use your own images, say, for dinosaurs

or paintings, all you need to do is create a directory

and fill it with images from the web.

We'll need about 100 images in each directory to start.

Once we have our training data, the next thing we'll need to do

is train our classifier.

And for that, we'll use TensorFlow.

TensorFlow as an open source machine learning library.

And it's especially useful for working

with a branch of machine learning called deep learning.

Deep learning has led to great results in the last couple

years, especially in domains like image classification,

which we'll be working with today.

And here's one reason why.

Recall that way back in episode one,

we talked about telling the difference between apples

and oranges.

We saw it's impossible to do this

by hand because there's too much variation in the world.

But now we also know that classifiers take features

as input.

And with images, it's incredibly hard

to write code to extract useful features by hand.

For example, you wouldn't want to write code

to detect the texture of a piece of fruit.

To get around this, we use deep learning

because it has a major advantage when working with images.

And it's this.

You don't need to extract features manually.

Instead, you can use the raw pixels of the image's features,

and the classifier will do the rest.

To see the difference in our training data

looks, let's compare the Iris data set

with our directories of images.

In Iris, each column is a feature

that describes the flower.

And you can imagine we came up with these features

manually, say, by measuring the flower with a ruler.

Now by contrast, here's our training data

in TensorFlow for Poets.

It's just a list of labeled images.

And again, a classifier is just a function.

f of x equals y.

Here x is a 2D array of pixels from the image.

And y is a label like rose.

Now when we're talking about deep learning,

the classifier we'll be using is called a neural network.

At a high level, that's just another type of classifier,

like the nearest neighbor one wrote last time.

The difference is a neural network

can learn more complex functions.

In this code lab, TensorFlow for Poets

takes care of setting up and training the neural network

for you behind the scenes.

That doesn't mean that TensorFlow code is any harder

to write than what we've seen so far.

In fact, my favorite way of writing TensorFlow programs

is by using TF Learn.

And TF Learn is a high level machine learning library

on top of TensorFlow.

And the syntax is similar to scikit-learn

like we've seen so far.

For example, here's a code snippet

that shows you how to import a neural network,

train it, and use it to classify new data.

And you can do this using the skills you've already learned.

If you want to learn more, no pun intended,

about this stuff right now, I put links

in the description you can check out.

OK, now let's return to TensorFlow for Poets

and train our classifier.

To do that, we'll kick it off with this script.

It's covered in detail in the code lab,

so I won't say too much about it here.

But I will give you context on two more things

you might want to know about.

First, the script takes about 20 minutes

to train the classifier.

Now ask yourself, is that a long time?

The answer turns out to be no.

Under the hood, TensorFlow for Poets

isn't actually training a classifier from scratch.

Instead, it's starting with an existing classifier called

Inception.

And Inception is one of Google's best image classifiers.

And it's open source.

Whereas we have just a couple thousand images in our training

data, Inception was trained on 1.2 million images

from 1,000 different categories.

Training Inception took about two weeks on a fast desktop

with eight GPUs.

In TensorFlow for Poets, we'll begin with Inception

and then use a technique called retraining

to adjust it to work with our images.

This lets us re-use some of the parameters Inception

has previously learned so we can create a new high accuracy

classifier with far less training data.

I'll fast forward til our training finishes.

And once we have a trained classifier, we can try it out.

To do that, I'll download this image of a rose

from Wikimedia Commons and use our classifier

to predict what type of flower it is.

As we can see, it gets it right.

And we can see the confidence distribution

for the other types of flowers as well.

Now keep in mind our classifier only

knows about the training data we've shown it.

So if we ask it to classify an image,

say, of the Roman Colosseum, it must predict

that it's a type of flower.

Hopefully, though, the confidence will be low.

Now let me give you one or two more closing thoughts.

To train a good image classifier,

the name of the game is diversity and quantity.

By diversity, I mean the more images

of different types of roses we have, the better off we'll be.

For example, our training data includes

pictures of red, white, and yellow roses.

We also have pictures taken at different angles,

say, from above or to the side.

And we've included pictures of roses in the foreground

as well as the background.

Now by quantity, I mean the more training data we have,

the better a classifier we're likely to create.

There are several hundred images inside the roses folder.

That's enough to retrain Inception.

And you can probably get away with even fewer images,

though your accuracy might decrease.

OK, that's it for now.

As a next step, you'll probably want

to dig deeper and try writing your own TensorFlow code.

Here's a link to a tutorial that will show you how to do that.

And you can use exactly the same technology we saw here.

As always, thanks very much for watching.

And I'll see you guys next time.

[MUSIC PLAYING]