In the previous video,
you looked at convolutions
and got a glimpse for how they worked.
By passing filters over
an image to reduce the amount of information,
they then allowed the neural network
to effectively extract
features that can distinguish
one class of image from another.
You also saw how pooling
compresses the information to make it more manageable.
This is a really nice way to
improve our image recognition performance.
Let's now look at it in action using a notebook.
Here's the same neural network that you used before for
loading the set of images of
clothing and then classifying them. *long pause*
By the end of epoch five,
you can see the loss is around 0.29,
meaning, your accuracy is
pretty good on the training data.
It took just a few seconds to train,
so that's not bad.
With the test data as before and as expected,
the losses a little higher and thus,
the accuracy is a little lower.
So now, you can see the code that
adds convolutions and pooling.
We're going to do two convolutional layers
each with 64 convolution,
and each followed by a max pooling layer.
You can see that we defined our convolutions to be
three-by-three and our pools to
be two-by-two. Let's train.
The first thing you'll notice is that
the training is much slower.
For every image, 64 convolutions are being tried,
and then the image is compressed and
then another 64 convolutions,
and then it's compressed again,
and then it's passed through the DNN,
and that's for 60,000 images
that this is happening on each epoch.
So it might take a few minutes instead of a few seconds.
Now that it's done,
you can see that the loss has improved a little.
In this case, it's brought our accuracy up a bit for
both our test data and with
our training data. That's pretty cool, right?
Now, let's take a look at the code
at the bottom of the notebook.
Now, this is a really fun visualization
of the journey of an image through the convolutions.
First, I'll print out the first 100 test labels.
The number nine as we saw earlier is a shoe or boots.
I picked out a few instances of this whether the zero,
the 23rd and the 28th labels are all nine.
So let's take a look at their journey.
The Keras API gives us
each convolution and each pooling and each dense,
etc. as a layer.
So with the layers API,
I can take a look at each layer's outputs,
so I'll create a list of each layer's output.
I can then treat each item in the layer as
an individual activation model
if I want to see the results of just that layer.
Now, by looping through the layers,
I can display the journey of the image
through the first convolution and
then the first pooling and
then the second convolution and then the second pooling.
Note how the size of the image is
changing by looking at the axes.
If I set the convolution number to one,
we can see that it almost immediately detects
the laces area as a common feature between the shoes.
So, for example, if I change the third image to be one,
which looks like a handbag,
you'll see that it also has a bright line near
the bottom that could look like the sole of the shoes,
but by the time it gets through the convolutions,
that's lost, and that area
for the laces doesn't even show up at all.
So this convolution definitely
helps me separate issue from a handbag.
Again, if I said it's a two,
it appears to be trousers,
but the feature that detected something that
the shoes had in common fails again.
Also, if I changed my third image back to that for shoe,
but I tried a different convolution number,
you'll see that for convolution two,
it didn't really find any common features.
To see commonality in a different image,
try images two, three, and five.
These all appear to be trousers.
Convolutions two and four seem to detect
this vertical feature as
something they all have in common.
If I again go to the list and
find three labels that are the same,
in this case six, I can see what they signify.
When I run it, I can see that they appear to be shirts.
Convolution four doesn't do
a whole lot, so let's try five.
We can kind of see that the color
appears to light up in this case.
Let's try convolution one.
I don't know about you, but I can play with this all day.
Then see what you do when you run it for yourself.
When you're done playing,
try tweaking the code with these suggestions,
editing the convolutions, removing the final convolution,
and adding more, etc.
Also, in a previous exercise,
you added a callback that
finished training once the loss had a certain amount.
So try to add that here.
When you're done, we'll move to the next stage,
and that's dealing with images that are
larger and more complex than these ones.
To see how convolutions can maybe detect
features when they aren't always in the same place,
like they would be in these tightly
controlled 28 by 28 images.