Real-World Python Neural Nets Tutorial (Image Classification w/ CNN)

00:00:00 hey how's it going everyone and welcome
00:00:01 back to another video in this video
00:00:04 we're gonna walk through a real-world
00:00:05 example of using neural nets and so in
00:00:07 it we're going to classify images of
00:00:09 rock paper and scissors using a
00:00:12 convolutional neural net written in
00:00:13 tensorflow and Cara's this is kind of a
00:00:16 follow-up to my previous video on neural
00:00:17 nets so if you haven't watched that I'd
00:00:19 definitely recommend checking it out and
00:00:20 we walk through a lot of the kind of
00:00:22 background information on how neural
00:00:23 nets work and writing some simple ones
00:00:26 from scratch this video also can work as
00:00:28 a standalone video though so don't feel
00:00:30 like you have to watch that one but we
00:00:32 might move through some of the things a
00:00:33 little bit quickly alright to get
00:00:35 started I recommend opening up a Google
00:00:37 collab file so if you go to collab
00:00:39 research Google com
00:00:41 you can open up a Jupiter notebook there
00:00:43 and it's kind of nice that we can do
00:00:45 this in browser because we can make sure
00:00:47 that we all are running the same kind of
00:00:49 system all right the first thing we're
00:00:51 going to do is install some libraries
00:00:53 that we need so let's go ahead and do in
00:00:58 our Google cloud file do a pip install
00:01:02 of make this slightly bigger tensorflow
00:01:06 and tensorflow datasets and I'm gonna
00:01:13 run this with the dash Q so I don't see
00:01:15 as many logs as we normally would to
00:01:17 kind of keep this notebook a little bit
00:01:18 cleaner and the next thing we're going
00:01:21 to do while that runs is we're going to
00:01:23 now import the libraries that we're
00:01:26 going to need in this tutorial so
00:01:28 important necessary libraries and so
00:01:32 we're gonna be using tensorflow and
00:01:34 caris specifically but we'll also be
00:01:36 using some other helper libraries like
00:01:38 numpy and matplotlib so let's import all
00:01:40 those so import matplotlib lib pipe lot
00:01:47 as PLT import numpy as NP then we'll
00:01:54 import tensorflow as TF and we'll import
00:02:00 tensorflow datasets
00:02:06 as tensorflow das TFTs and then finally
00:02:12 with tensorflow – one thing will be
00:02:14 helpful is just to specifically import
00:02:19 the Charis library so from tensorflow
00:02:22 import Kerris the next thing we're going
00:02:25 to do is i'm going to show how we can
00:02:29 find datasets for whatever sort of
00:02:32 neural net project we want to do or
00:02:34 maybe any sort of general kind of
00:02:35 machine learning project and I think
00:02:44 there's a couple I mean there's all
00:02:46 sorts of place you can look for good
00:02:47 data but one thing that I find very
00:02:49 convenient is that tensorflow has a
00:02:52 bunch of datasets built into their
00:02:55 library so if you go to either of these
00:02:57 two locations you'll be able to find
00:02:59 some datasets that you can use but we
00:03:04 can also see these datasets very easily
00:03:07 with PFDs dot list builders we run that
00:03:12 method you'll see all of these different
00:03:15 lists here and so when I was prepping
00:03:20 for this tutorial I ultimately did this
00:03:22 and I kind of looked through what they
00:03:24 offered by default here and I kind of
00:03:28 kept scrolling
00:03:28 the thing I didn't want to do here is I
00:03:31 feel like everyone does tutorials on em
00:03:32 nest and the fashion M nest so I wanted
00:03:36 to do something a little bit different
00:03:37 than the M nest
00:03:38 which is classifying images of digits
00:03:41 with a CNN or with yeah and Narol that
00:03:45 so didn't want to do that
00:03:47 so I kept looking and ultimately I found
00:03:49 this dataset call it a
00:03:52 rock-paper-scissors and I thought that
00:03:54 sounded pretty cool let's see what it's
00:03:55 about and so let's load that data set in
00:04:01 so the first thing we can do is we can
00:04:05 get some information on the data
00:04:13 and to do this we can use the the tensor
00:04:17 flow data sets builder to load in some
00:04:19 information about a specific data set so
00:04:22 we're going to do builder equals T FD s
00:04:25 dot builder and then we need to take
00:04:29 that example that we saw up here so that
00:04:32 was rock-paper-scissors with underscore
00:04:33 so I'm gonna just copy that real quick
00:04:35 paste it in and then this is nice
00:04:38 convenient method on builder which is

00:04:41 builder dot info it will load in all
00:04:44 sorts of information about the data set
00:04:46 and then if we just go ahead and print
00:04:48 that out we'll see some information
00:04:53 about the data set we're working with so
00:04:56 rock-paper-scissors images of hands
00:04:59 playing rock paper scissor game that
00:05:01 sounds pretty cool and it's sounds very
00:05:03 like appropriate for a neural net
00:05:05 tutorial so what do we have here well we
00:05:09 have images that have 300 dimensions
00:05:12 height of 300 with the 303 color
00:05:15 channels so that means it's an RGB image
00:05:18 we can learn the data type here which is
00:05:21 a you ain't 8 so what that ultimately is
00:05:24 telling me is that these are numbers
00:05:27 each of these images are numbers from 0
00:05:30 to 255 and then we also have the class
00:05:33 label which is just a integer that's
00:05:37 basically representing
00:05:39 rock-paper-scissors then finally another
00:05:41 thing that's helpful here is that gives
00:05:43 us some information about the splits so
00:05:45 we have 2520 images that we can use for
00:05:49 training and then 372 that we'll use for
00:05:53 our test set and our validation and
00:05:55 there's also a URL to learn more about
00:05:58 this data set so that's useful we can
00:06:01 definitely utilize this but let's
00:06:03 continue onward and start prepping the
00:06:08 data so
00:06:18 okay and to do this this step is kind of
00:06:22 specific because we're using the tensor
00:06:24 flow data sets library to do this really
00:06:27 the same process is done with wherever
00:06:29 you're loading your data set from but
00:06:31 specifically because we're working with
00:06:32 tensor flow data sets the way we're
00:06:34 going to do this is tensorflow
00:06:35 datasets dot load and now the name is
00:06:40 going to be equal to rock paper scissors
00:06:43 that same file that we saw before and
00:06:47 the other thing we're going to access
00:06:49 here is and if I actually look at this
00:06:52 class method you'll see some information
00:06:54 I can get split is the next key word and
00:06:57 that's what we're going to grab here we
00:06:59 want to separate our training data and
00:07:01 our test data so we're gonna say split
00:07:02 equals train here and then for the other
00:07:10 one for our test data we will do the
00:07:13 same thing and but this time our split
00:07:22 will be equal to test and that matches
00:07:27 up with what we found when we looked up
00:07:29 the information on this data set so we
00:07:31 can go ahead and run that and one thing
00:07:36 I will note is that there's an
00:07:38 additional option we can add to one of
00:07:40 our previous cells if you don't want all
00:07:43 this information to pop up and kind of
00:07:45 mess up our the neatness of our data set
00:07:48 and we can go ahead and pass in we when
00:07:53 we imported the library if we passed in
00:08:00 disabled progress bar what we'll see
00:08:04 when we run that again and I can show
00:08:08 you that TFTs disabled progress bar and
00:08:12 when we run this command again instead
00:08:15 of seeing all this these bars and all
00:08:17 this extra information they'll just run
00:08:19 neatly okay so now we've loaded in our
00:08:23 data I think the next thing that's
00:08:25 gonna be helpful for us to do is
00:08:27 actually see some examples of what we're
00:08:29 working with because it's really hard to
00:08:31 start writing a neural net unless you've
00:08:33 actually seen some images so let's go
00:08:36 ahead and and show some examples and so
00:08:42 with the tensorflow datasets library we
00:08:47 can do this as follows we can do tensor
00:08:51 flow datasets thought show examples and
00:08:55 this is going to be using two things
00:08:57 you're going to have the dataset info as
00:08:59 well as the specific data set so the
00:09:04 info we loaded up here with our builder
00:09:07 that's the info and then we can either
00:09:09 use DS train or d s test use as the
00:09:12 actual data set that method so we have
00:09:14 info and then we have yes train and
00:09:18 really again like we're doing in a
00:09:21 specific way here with tension flow
00:09:24 dataset but often times the same process
00:09:26 no matter how you're working with your
00:09:28 data it's good to kind of follow and
00:09:29 just get a feel for your data before you
00:09:31 start trying to build a model around it
00:09:33 okay so this is what we got you see that
00:09:35 their hands doing rock paper and
00:09:38 scissors and one thing you might notice
00:09:40 about these hands is that they're a
00:09:42 little bit some of them are a little bit

00:09:43 funky looking like this one right here
00:09:45 I'm looking at and that is I remember
00:09:48 looking into the data set a little bit I
00:09:49 believe these are all artificially
00:09:51 generated images of rock paper and
00:09:52 scissors so they're not actual images as
00:09:58 far as I know but they work the same
00:10:00 when we're kind of going ahead and
00:10:03 training our network we can kind of
00:10:06 utilize them as we'd use a a real image
00:10:08 but here yeah here's what we're working
00:10:10 with and they have the labels 0 for rock
00:10:12 papers along scissors is a – all right
00:10:16 we have the examples now let's do a
00:10:20 little bit of additional data prep
00:10:27 if this step this is really kind of for
00:10:30 any sort of image classification task
00:10:32 I'd say this is a pretty similar type of
00:10:35 processing I would probably do but we're
00:10:37 basically converting the tensorflow
00:10:40 datasets format into a numpy format
00:10:43 that's a little bit more Universal a
00:10:45 little bit more easy to work with in my
00:10:47 opinion so that's what we're gonna do in
00:10:49 this next step I thought the easiest way
00:10:51 to figure out how to do this was to
00:10:53 first look at the documentation for the
00:10:56 data sets library within tensorflow so
00:11:00 into tensorflow org slash data sets
00:11:03 slash overview and in there it told me
00:11:06 how to iterate over a data set and
00:11:08 that's what we have and the key insight
00:11:10 I saw here was that in the data set
00:11:13 there's images and labels so those are
00:11:18 the two items that we really want when
00:11:19 we're breaking up our data so if we
00:11:22 iterate over the examples in our data
00:11:24 set we can grab those things and to make
00:11:26 it a little bit more concise let's do
00:11:28 that in the form of a list comprehension
00:11:31 so we're going to say our train images
00:11:36 are going to be equal to example and
00:11:41 then we're going to use get the image
00:11:43 for example in the data set and that's
00:11:49 basically all we have to do I guess the
00:11:52 one we could run this real quick and see
00:11:55 what happens
00:11:55 I don't know Oh data set train sorry
00:12:03 this might take a second to run
00:12:10 okay so let's just look at the first
00:12:13 image in there and let's just get the
00:12:17 type of that so this is a tensor flow
00:12:24 tensor so what I want to do instead is
00:12:28 grab it as a numpy array and so this dot
00:12:34 numpy is a shorthand thing we can do
00:12:38 with tensor flow to get it in numpy
00:12:40 format so rerun these two cells again
00:12:42 let's see what happens okay so now we
00:12:45 have it in the form of a numpy array the
00:12:49 one thing i do want to know though is
00:12:50 what is the shape of the overall images
00:12:55 and oh i guess we have one other issue
00:12:59 is that we did this at a list
00:13:00 comprehension but the surrounding data
00:13:03 type is just a list right now and if we
00:13:05 want to make it also a numpy array we
00:13:07 need to surround it with NPRA okay so
00:13:10 run those two things again okay we have
00:13:14 two thousand five hundred twenty by 300
00:13:18 by 300 by three so it's two thousand
00:13:21 five hundred twenty images with this
00:13:24 shape the one thing I would say and this
00:13:26 is getting really gonna be problem
00:13:28 independent is that we are working with
00:13:31 you know these hands and in my opinion
00:13:35 the colors don't really matter too much
00:13:37 so right now we have these three colour
00:13:40 channels RGB but in my opinion we only
00:13:43 really need one color Channel because
00:13:45 we're really looking at trying to find
00:13:47 edges and whatnot so I think we have
00:13:49 three color channels we might kind of
00:13:52 have more data than we actually need so
00:13:55 we're trying to reduce the number of
00:13:57 things that the network has to learn so
00:14:00 ultimately I think it would be nice to
00:14:02 have this in grayscale so we're gonna do
00:14:04 everything for the dimensions for the
00:14:08 first two dimensions so we need to take
00:14:10 all these same points still but for the
00:14:13 last dimension the color Channel we'll
00:14:15 just take the first color Channel we'll
00:14:17 just take that red color Channel and I
00:14:19 think that's good
00:14:21 and so now let's see what we have now we
00:14:23 don't have a color channel that's cool
00:14:26 we'll have to do a little bit of
00:14:27 additional processing but let's now in
00:14:30 addition to train images let's get train
00:14:31 labels and that will be NPRA this will

00:14:35 be pretty similar
00:14:36 it'll be example label dot dot and on P
00:14:44 we can just take whatever label it is
00:14:46 because it's just going to be a integer
00:14:48 as we looked at the data a little bit
00:14:50 earlier in this tutorial for example in
00:14:53 DS train ok I'm going to now just copy
00:14:58 this code and also do the same thing for
00:15:03 the test images so I'm just going to
00:15:05 change this out to test change this out
00:15:07 to test and change this to test labels
00:15:11 and this to test all right let's load
00:15:18 all this alright so with this cell we've
00:15:22 now loaded everything in in numpy format
00:15:25 we need to do a little bit of a
00:15:27 processing before we're ready to pass it
00:15:29 on to our network and there's a couple
00:15:30 items here so once again we can see the
00:15:33 shape and if we wanted to check out the
00:15:36 test images shape it'll be pretty
00:15:37 similar except lower number of examples
00:15:40 right first thing is we need to reshape
00:15:43 these so I want to just say train images
00:15:47 equals train images dot reshape and if
00:15:52 you remember what it was I'm just going
00:15:54 to comment this out just to see this
00:15:56 again
00:16:01 we had 2,500 180 by 300 by 300 so we're
00:16:05 gonna reshape this one to twenty five
00:16:09 twenty by 300 by 300 501 and the reason
00:16:15 we have this one here is that whenever
00:16:17 we use convolutional neural networks in
00:16:19 Kerris we always have to have some sort
00:16:21 of semblance of a color channel and so
00:16:24 by changing this to one we don't change
00:16:27 the number of values we have at all we
00:16:29 just are basically letting Kerris know
00:16:31 hey this is just a grayscale these are
00:16:34 just grayscale images so do that and
00:16:38 also now I need to just figure out my
00:16:40 shape of the test images 372 so I'll do
00:16:47 the same line basically but now we'll do
00:16:51 372 by 300 by 300 by 1 and this is 372
00:17:02 okay that now reshapes it and we didn't
00:17:08 get any error so that's cool some other
00:17:11 things we'll want to do here so we've
00:17:13 got reshaped it and I think let's see if
00:17:17 I can do that info is that something I
00:17:21 think by data type okay this is this is
00:17:28 good this is you int 8 so it's all
00:17:31 integer values and they're up if they're
00:17:33 RGB I guess they're just our channel
00:17:36 values from 0 to 255 when we're doing
00:17:40 image classification we like to work
00:17:42 with float values specifically between
00:17:44 the range of 0 to 1 so one thing we're
00:17:47 gonna do is we're gonna say train images
00:17:51 we're gonna say train images equals
00:17:54 train images dot as type and now it's
00:17:59 going to be a float 32 instead of the
00:18:02 int 8 that we had before so this is just
00:18:05 basically getting us ready to be able to
00:18:07 convert it from a scale of 0 to 1
00:18:09 instead of 0 to 255
00:18:16 and so the last step we're gonna do is
00:18:20 say train images dividing equal by 255
00:18:26 so the max value we can have is 255
00:18:29 because RGB values are between 0 and 255
00:18:32 so by doing this we're scaling every
00:18:34 value to be between 0 & 1 and this is
00:18:38 just a good common practice that helps
00:18:41 you classify it helps the basically
00:18:44 network learn better than if you use the
00:18:47 0 to 255 values you could leave it 0 to
00:18:50 255 but it's just ultimately it's gonna
00:18:53 probably decrease your performance a bit
00:18:55 so it's a common step to normalize
00:18:57 between 0 & 1 and that's what we're
00:18:59 doing right here I think that's all we
00:19:01 need to do the labels are all fine from
00:19:04 before so we don't need to do any
00:19:05 additional processing to the label so
00:19:07 we'll just rerun this so and now if we
00:19:11 look at training images data type we'll
00:19:15 see it's a flirt 32s and if we actually
00:19:18 wanted to like look at one of the values
00:19:21 here we'll see that all the values are
00:19:25 between 0 & 1 and we can also even look
00:19:28 at the shape here of a single example
00:19:33 300 by 300 by one that looks all good
00:19:36 so I think that's good for the
00:19:37 processing steps alright now let's go
00:19:40 ahead and train our first neural network
00:19:42 for this task and I'm gonna go through
00:19:46 this pretty quickly because I've already
00:19:49 covered kind of a lot of this in my
00:19:51 previous neural network video I had to
00:19:53 start off let's define a model and that
00:19:55 will be a sequential model and so in
00:19:59 that we're gonna have to pass in some

00:20:01 layers so the first layer we'll pass in
00:20:05 is Karis layers dense so as the kind of
00:20:09 basic approach we'll make it a fully
00:20:11 connected no network so let's say that
00:20:13 the first layer of the dense network is
00:20:16 512 when we're defining our first layer
00:20:20 we're gonna want to find the input shape
00:20:22 so in our case now it's 300
00:20:24 by three hundred by one and then we'll
00:20:28 also want to define the activation and a
00:20:30 good one to use is rail you okay that's
00:20:33 our first layer our next layer is going
00:20:35 to be another dense layer so we'll do
00:20:38 Karis layers dense and we'll make this
00:20:42 one a little bit smaller so how about we
00:20:43 do 256 here and then make the activation
00:20:48 another arel you and then finally let's
00:20:52 define our output layer and so the
00:20:54 output layer is going to be the same
00:20:56 size as you have labels that you're
00:20:58 trying to classify it between so in our
00:21:01 case this will be a dense layer of three
00:21:03 because we have rock paper and scissors
00:21:05 and let's also define a activation layer
00:21:09 for our output and when we're doing
00:21:12 classification of and just identifying
00:21:15 one label softmax is a good choice here
00:21:17 alright that looks good
00:21:19 and then we're gonna have to setup the
00:21:21 loss function for this so I'll do model
00:21:23 compile we'll pass in the atom optimizer
00:21:28 we will use for a loss function we will
00:21:32 use Karis losses dots Perce categorical
00:21:38 cross entropy and then finally we will
00:21:43 pass in our metrics and that will just
00:21:47 be accuracy okay so we have our loss
00:21:51 function set up and finally we need to
00:21:55 fit our data to the model so model dot
00:21:58 fit will do train or train images train
00:22:03 labels and then we'll do a parks let's
00:22:07 say equal five and batch size equals 32
00:22:14 on that input shape is not defined
00:22:19 equals 300 by 300 by one
00:22:24 okay go on all right so we got an issue
00:22:28 invalid incompatible shapes 32 or one
00:22:31 versus 32 300 300
00:22:35 and ultimately I think our issue here is
00:22:37 because we're passing in an input shape
00:22:39 and this is kind of a complex you know
00:22:41 this is an actual image and it has a
00:22:42 complex dimensionality so instead of
00:22:45 doing this what we're gonna do and this
00:22:47 is usually what you're going to do if
00:22:49 you're trying to use a fully connected
00:22:51 layer for images we're gonna do Karis
00:22:53 dot layer so we're going to add one more
00:22:55 layer and this is gonna be called a
00:22:56 flatten layer and basically what this
00:22:59 does is it transforms that 300 by 300
00:23:01 image into just a single column which
00:23:05 would probably be of dimension 90,000 so
00:23:09 that's what we're doing with that layer
00:23:10 so now I think we should be able to run
00:23:12 this training step and it's running and
00:23:16 because this takes a little while I'm
00:23:17 going to just kind of speed through this
00:23:19 section and I'll do that probably in
00:23:21 general all right it finished and
00:23:24 looking at our results you see that
00:23:27 after the last epoch we had about 90%
00:23:31 accuracy so you might be like wow like
00:23:33 this was so easy we've already
00:23:35 classified these hands these
00:23:37 rock-paper-scissors hands like very well
00:23:40 well I think though it's pretty telling
00:23:42 if we try to do a model dot evaluate on
00:23:45 the test images and the test labels this
00:23:51 will tell us how well our model
00:23:52 generalizes to unseen data and so if
00:23:56 this is also high then like we're golden
00:23:57 but I don't think it will be yeah and as
00:24:02 you see here it got 50% on the test data
00:24:07 so there's a big disconnect you know we
00:24:09 were able to classify 90% of the
00:24:11 training examples properly but only 50%
00:24:14 of the test so it's not doing a very
00:24:17 well job on the test data and the big
00:24:20 disconnect here is is that we are using
00:24:23 this fully connected layer for these 300
00:24:25 by 300 images and so that's a total of a
00:24:28 90 thousand like single I guess pixels
00:24:32 that we are connecting to the next layer
00:24:34 of our network and ultimately we don't
00:24:37 have
00:24:38 we're putting too much importance in
00:24:40 those little single pixels so what's
00:24:42 happening here is that we're basically
00:24:44 we're overfitting to our training data
00:24:46 and we're not really learning good
00:24:49 patterns because as you see in our test

00:24:52 data we got 50 percent so ultimately
00:24:54 this is what's going to lead us to want
00:24:55 to use convolutional neural networks to
00:24:58 kind of get a more sense of
00:25:01 generalizable features within our
00:25:03 rock-paper-scissors images so that's
00:25:06 what we're going to do for our next
00:25:07 network I'm not going to go through the
00:25:09 details of a convolutional network in
00:25:11 great depth but basically we can think
00:25:13 of all of our images as a grid and
00:25:14 before we are using each pixel to feed
00:25:17 into our network now within our grid
00:25:20 image we are passing over a smaller grid
00:25:23 across the entire image and basically
00:25:27 with these smaller grids that we're
00:25:28 passing on the in the entire image these
00:25:31 convolutions were performing we're
00:25:33 learning features that occupy a little
00:25:36 bit more space and as we think about it
00:25:38 like images there's so much variance in
00:25:40 how they are so we need to like at a
00:25:42 higher level be able to pick up on those
00:25:44 features so that's why we're gonna pass
00:25:46 these smaller grids over our bigger grid
00:25:49 to hopefully pull out general features
00:25:52 in our images all right and so we're
00:25:55 gonna again
00:25:56 start this off by defining a sequential
00:25:58 model and this time what we're gonna do
00:26:03 is our first layer is going to be
00:26:06 caressed layers thought con-con for
00:26:11 convolution and to-day because this is a
00:26:13 2d image and then we have to pass in the
00:26:18 appropriate parameters so if we look at
00:26:22 our Google collab we need a first pass
00:26:24 in filters so this is basically how many
00:26:27 different smaller grids we're gonna pass
00:26:30 on top of our image and each of these
00:26:33 smaller grids is going to have a
00:26:34 different kind of shape and try to find
00:26:36 a different pattern I'll link to some
00:26:38 resources that can explain this in more
00:26:40 depth it's basically how many times
00:26:42 we're passing over a smaller grid on our
00:26:44 image so we're gonna say this is 64
00:26:47 there's just a kind of a see first
00:26:48 answer our kernel size
00:26:51 this is how big our smaller grid is so
00:26:53 if I said three and I didn't pass in any
00:26:56 other parameters this would assume three
00:26:57 by three I think you could also pass in
00:27:00 if you wanted to have a different sized
00:27:02 the X and y direction you could do like
00:27:04 three by six and that would be a
00:27:06 rectangular that'd be a rectangular
00:27:08 kernel size so we'll say let's just say
00:27:11 three to start off and we'll leave the
00:27:15 strides at one two one
00:27:17 that just means they'll move one every
00:27:18 time so it's gonna be a sliding window
00:27:20 of three by three all right
00:27:22 and how about we and we'll give that an
00:27:27 activation of rel you just like we have
00:27:31 been and let's now we actually do need
00:27:33 to define the input shape and this time
00:27:35 it will expect a multi dimensional shape
00:27:38 so we can do 300 by 300 by one that's
00:27:41 totally fine now I'm going to just pass
00:27:45 in another convolutional layer so we're
00:27:49 gonna do another 2d convolution this
00:27:51 time we're gonna make it a little bit
00:27:52 smaller
00:27:53 we'll say thirty two filters with kernel
00:27:56 size of three activation equals real you
00:28:00 and all right I think that's good we're
00:28:04 having we have two convolutional layers
00:28:06 and now we're gonna want to pass this to
00:28:08 a kind of the output layer and to do
00:28:11 that we first need to flatten the output
00:28:14 of all these convolutions so we're gonna
00:28:16 pass another flatten layer
00:28:18 caris dot layers dot flatten and then
00:28:24 we'll just like in the last case we'll
00:28:25 do Karos layers dense and this is our
00:28:29 output layer so we look three with an
00:28:31 activation of softmax cool it looks good
00:28:37 and we're just going to go ahead and
00:28:39 copy our loss function from above great
00:28:48 and let's go ahead and try to train this
00:28:52 it's working but it seems to be going
00:28:57 really really slow like too slow to
00:29:01 let's see yeah really really slow
00:29:05 one insight here and this is something
00:29:07 it might have been annoying that I
00:29:08 haven't told you already
00:29:10 but within google collab we can actually
00:29:11 run on a GPU if we want to so like right
00:29:14 now it shows that like this single epoch
00:29:17 will take ten minutes and it's not ideal

00:29:19 so what we're gonna do is we're gonna
00:29:22 stop this real quick if I can stop stop
00:29:27 okay no no stop I stopped it but then I
00:29:29 tried again all right so we're gonna
00:29:33 real quick just change our run time so
00:29:36 you go to run time and then change run
00:29:38 time type we're going to use a GPU
00:29:40 hardware accelerator and really only use
00:29:44 a GP if you need one as they kind of say
00:29:46 so I'm gonna save that we're gonna go
00:29:50 back and now basically we need to
00:29:52 rewrite everything because it's using a
00:29:53 different different hardware so I'm just
00:29:56 going to run all the cells that are
00:29:57 relevant here
00:30:13 and we don't have to run this one again
00:30:15 because that's all focused on right now
00:30:18 we'll run this one again once everything
00:30:20 else is done let's just let these
00:30:22 execute all right and now let's run our
00:30:27 convolutional neural net last time it
00:30:29 said it was gonna take like ten minutes
00:30:30 door in a single epoch let's see how
00:30:32 well it runs with the GPU and look at
00:30:37 that from what it was taking about ten
00:30:40 minutes we've now run a single epoch in
00:30:42 about ten seconds so that's really cool
00:30:46 look at this it's like really performing
00:30:49 well now that we've used that
00:30:50 convolutional layer on top and wow it's
00:30:54 at the last layer here it's predicting
00:30:56 all the training utterances properly but
00:31:00 you know the ultimate test is it doesn't
00:31:02 matter if we can do really well in
00:31:03 training data that does have that has no
00:31:05 meaning unless we can do well on test
00:31:08 data so we're gonna do model evaluate
00:31:10 test images and test labels and then see
00:31:13 how we do geez we actually did worse
00:31:18 than we did before with the fully
00:31:21 connected approach so obviously we over
00:31:25 fit again so let's see how we can
00:31:28 improve this convolutional approach and
00:31:30 hopefully avoid our overfitting problem
00:31:32 all right so now that's we're going to
00:31:35 find another cell
00:31:37 I'm just call this a better
00:31:39 convolutional Network all right how can
00:31:44 we improve this network that obviously
00:31:45 overfit I'm gonna just go ahead and copy
00:31:49 this into our new cell no need to start
00:31:53 from scratch but let's look at this what
00:31:56 is the main issue that we're having and
00:31:58 why are we overfitting and this is
00:32:00 definitely not obvious unless you've
00:32:02 kind of started to work with image
00:32:04 classification a bit I would say the the
00:32:07 problem kind of boils down to the fact
00:32:09 that we don't have that many training
00:32:11 examples you know only we have under
00:32:14 3000 training examples or yeah thank I
00:32:18 forget the exact number yeah I think we
00:32:21 have 2500 20 training examples so that's
00:32:24 not that many and the grand scheme of
00:32:26 things
00:32:26 and also the other real big issue that I
00:32:29 see here is that our images are 300 by
00:32:32 300 by one but our kernel size here the
00:32:37 small grid that we're passing on top of
00:32:39 the image when we're doing the
00:32:40 convolution is just three by three so
00:32:45 it's still like a really small rectangle
00:32:48 we're passing on top of the big
00:32:50 rectangle so what we're all Tamayo and
00:32:53 like obviously like if we're thinking
00:32:55 about our image we don't need
00:32:57 high-resolution images as long as like
00:33:00 the base features are there we should be
00:33:02 good so ultimately what we want to do
00:33:04 here is reduce the size of this input
00:33:07 image before we start performing the
00:33:10 convolutions on it so what we're gonna
00:33:12 do is a average pool we're gonna add an
00:33:15 average pooling layer so Karis layers
00:33:19 dot average I think it's average pooling
00:33:24 average pooling 2d that sounds good to
00:33:26 me and what are our options here is pool
00:33:30 size will say our pool size is going to
00:33:34 be 6 we can pass in if we if it's square
00:33:39 we can just pass in 1/4 in it again but
00:33:42 we could also pass in multiple
00:33:44 coordinates so and then our stride our
00:33:47 stride is how far if we have a six by
00:33:49 six box our stride is how much we move
00:33:52 that box each time we do an average so
00:33:55 I'm going to say that this is three so
00:33:57 basically what we're doing here in this
00:33:59 layer is that as we pass it and we're
00:34:02 gonna also have the pass in the input
00:34:03 shape here so what we're basically doing

00:34:10 is that we have this 300 by 300 input
00:34:13 image and what we're doing is basically
00:34:16 passing a six by six box on top of that
00:34:19 image and every time we do that we're a
00:34:22 bridging all the pixels and that's our
00:34:25 kind of new representation of that box
00:34:28 and instead of removing the box entirely
00:34:30 over we're moving the box three so every
00:34:34 two times we move the box we are any
00:34:37 like basically new location so you
00:34:39 basically have
00:34:39 this and this and this and this second
00:34:44 time you move that box here kind of
00:34:45 covering new squares I guess from the
00:34:48 first time you did it so I guess the
00:34:50 better way to say this is that each
00:34:52 pixel is counted twice in this
00:34:53 representation but basically we're gonna
00:34:55 boil this down if we have six and
00:35:01 removing on top of it it's going to boil
00:35:05 this down from 300 – 300 – I believe if
00:35:09 I'm not mistaken 100 by 100 as the new
00:35:13 kind of input and you could reduce this
00:35:15 further further if you wanted to if we
00:35:18 did six by six here with a stride of six
00:35:21 think this would reduce it down to 50 by
00:35:23 50 so that's another thing to try but I
00:35:25 want to count each pixel twice here and
00:35:29 then we'll feed this now into our
00:35:32 convolutional Network so this is
00:35:34 basically just the image with instead of
00:35:36 size 300 by 300 after this layer it's
00:35:39 100 by 100 and let's see what happens to
00:35:42 our network when we just do that
00:35:44 reduction in image size so still like
00:35:48 basic classifies the test data very well
00:35:50 let's see what happens when we evaluate
00:35:54 it so test images test labels want to do
00:36:01 better than last time okay
00:36:03 56% I mean that's definitely better I
00:36:06 think we can still do better here and I
00:36:10 would say what our issues here are now
00:36:12 and this is kind of comes with practice
00:36:14 and you know I wouldn't notice these
00:36:16 things unless I really looked at this
00:36:18 for a while and I have looked at this
00:36:20 example before doing this so I have more
00:36:23 of an intuition I would coming into this
00:36:25 exercise cold but we have a lot here
00:36:28 another very common thing in
00:36:29 convolutional neural nets is to do some
00:36:34 max pooling
00:36:37 and this is basically for the same
00:36:39 reason is we don't want to take too many
00:36:42 dimensions when we're doing these things
00:36:44 so max pool 2d is going to basically do
00:36:49 the similar thing as an average pool but
00:36:51 now we're gonna pass over our output
00:36:53 with two by two grids and just take the
00:36:56 max pixel in every 2×2 grid and this
00:36:59 time we're moving the 2×2 grid to every
00:37:02 time so each pixel is only counted one
00:37:04 but we're just taking the max pixel
00:37:06 value from each of those so let's see
00:37:09 what happens if we add that and I
00:37:11 screwed something up now
00:37:15 caris top layers
00:37:23 all right how we doing all right
00:37:26 66% accuracy on the test data that's a
00:37:29 lot better and it's ultimately because
00:37:30 we're reducing the size of things and
00:37:33 basically individual pixels don't have
00:37:35 as much weight anymore so it's smaller
00:37:37 input space smaller parameter size so
00:37:40 that our model should generalize more
00:37:43 but there's one major thing that I'm
00:37:44 thinking of that we can do to probably
00:37:48 help things out and that is to use
00:37:50 dropout so one of our main issues with
00:37:54 our training examples is that we don't
00:37:57 have many
00:37:57 and so what dropout will do is that
00:38:00 after we're done with the max pool 2d
00:38:02 layer we're going to basically cut out
00:38:04 50% of the connections so as we train
00:38:09 things 50% of the connections that this
00:38:11 lay are going to be dropped out and
00:38:12 ultimately the epochs will be more
00:38:15 effective because the data will be kind
00:38:17 of more interesting because these things
00:38:20 are getting dropped out randomly so each
00:38:22 of the individual connections will kind
00:38:24 of have to generalize more and be able
00:38:26 to handle more variation so this is
00:38:29 going to kind of help us simulate having
00:38:32 more training examples by using this
00:38:34 dropout layer and 50% is a good it's
00:38:37 kind of in research the common value to
00:38:40 go to with this dropout layer so let's
00:38:42 try this and thankfully we're on the GPU

00:38:45 so everything's going really fast so we
00:38:50 went from 66 and the last layer okay and
00:38:53 we're about the same 65 percent didn't
00:38:56 seem to help too much the last thing
00:38:58 that I'm gonna recommend doing and this
00:39:02 is something that you just really play
00:39:04 around with but we're gonna add another
00:39:06 dense layer here so instead of going
00:39:09 from everything to three we're going to
00:39:11 try to learn an inter minute
00:39:12 intermediary representation before we
00:39:16 actually do the output so we're hoping
00:39:17 that maybe this layer can capture some
00:39:20 higher-level information and boil it
00:39:22 down to the three better than just
00:39:23 passing all the outputs of the
00:39:25 convolution and the dropout and
00:39:27 everything straight to our
00:39:28 classification layer so make this 128
00:39:31 we'll use see what happens if you use
00:39:34 lü activation comment here all right
00:39:47 moment of truth all right look at that
00:39:50 70 percent accuracy that's pretty good
00:39:53 on the test date on scene data I'm
00:39:54 pretty happy with that so I think as far
00:39:57 as on your own you could tune these
00:40:00 values and play around with adding more
00:40:02 values and whatnot
00:40:03 maybe you'll get better results but our
00:40:05 next and final basically step of this
00:40:07 example will be to look at automatically
00:40:10 tuning the values in this network and
00:40:12 maybe adding more layers to see if we
00:40:14 can get even better test accuracy than
00:40:16 69% to automatically tune our network
00:40:20 we're gonna use a tool called Terrace
00:40:24 tuner and it just does a lot of the work
00:40:28 for us
00:40:29 and it makes it very easy to find the
00:40:30 best parameters for a network so I think
00:40:33 the easiest way to learn about carries
00:40:35 tuner is to go to the cares tuner
00:40:37 website I'll link this in the
00:40:40 description but here we are so to start
00:40:45 off we need to install it so we can use
00:40:47 pip install – hewharris tuner so I'll
00:40:50 just copy that command and I'll run that
00:40:53 with my notebook and while that's going
00:40:56 I think we can look back at that
00:40:58 documentation and just read through
00:41:02 usage the basics and I think it already
00:41:04 kind of starts making things clear so
00:41:07 here we have this build model with this
00:41:11 hyper parameter variable that we're
00:41:14 passing through and as we see this is
00:41:17 used was basically we're defining a
00:41:19 sequential model and this is a slightly
00:41:21 different format than we defined our
00:41:22 SWAT the kind of refactor our current
00:41:26 network a little bit but we are you know
00:41:29 basically in this step they're adding a
00:41:31 dense layer a fully connected layer and
00:41:33 this time the big difference is that the
00:41:37 number of units for that single layer is
00:41:40 defined as a variable like it can be
00:41:43 different values and this is what we're
00:41:45 testing and playing around with so it's
00:41:47 saying
00:41:47 basically that we want to try the min
00:41:49 value of 30 to a max value of 512 for
00:41:53 this layer and a step size of 32 so
00:41:56 behind the scenes this build model and
00:41:59 the Charis tuner will test the numbers
00:42:02 from 32 to 512 skipping every 32 units
00:42:07 for this dense layer and we can do this
00:42:10 for a bunch of things and we don't just
00:42:12 have to use this int command there's
00:42:13 other commands so as you see down here
00:42:15 they're playing around with what
00:42:17 learning rate should we use so it's in
00:42:20 the atom optimizer it's using a choice
00:42:24 of the learning rate so it's trying
00:42:26 these three values at random with the
00:42:29 variability up here as well so it's
00:42:31 allowing us to test different
00:42:33 combinations of things very easily so
00:42:35 let's go ahead and just start writing
00:42:37 this into our code so the first step is
00:42:40 going to be to take our network from up
00:42:42 here and rewrite it kind of in that
00:42:44 format that they were using so if we
00:42:47 look back at that so the first step will
00:42:50 be to import the random search we've
00:42:54 already imported the Charis and the
00:42:55 layers we want to import random search
00:43:04 and then we're going to define that
00:43:06 build model with that hyper parameter
00:43:10 variable being passed in and I've
00:43:13 actually already done this just to speed
00:43:15 it up a little bit the conversion to

00:43:17 this different format so our new model
00:43:19 will look something like this
00:43:24 so this is the same exact model from
00:43:26 above but now I just wrote it with this
00:43:31 different syntax where we define the
00:43:32 model it's just the sequential and we
00:43:34 add to that but same exact model and
00:43:37 we're gonna have to also add in the loss
00:43:41 function again to our function and then
00:43:46 finally we will return the model from
00:43:48 the function that's really all we have
00:43:51 to do but now we can decide if we want
00:43:52 to play around with variables so let's
00:43:55 go back to the documentation we have
00:43:59 next step looks like is defining this
00:44:01 tuner so I'll just copy this in so it's
00:44:09 calling the build model function the
00:44:11 objective is the validation accuracy so
00:44:14 how well does it do on our test set max
00:44:16 trials right now is set to 5 not quite
00:44:19 sure executions per trial is I think
00:44:21 it's how much times it's trying the
00:44:24 different combination of parameters
00:44:26 because there's some randomness involved
00:44:27 I'm not going to keep that for now and
00:44:30 then you can also choose where you save
00:44:31 these results by default it will choose
00:44:34 something so I'm going to just probably
00:44:37 get rid of these directory and project
00:44:39 names for now but know that you could
00:44:41 set those if you want to save it in a
00:44:42 certain spot all right that's good and
00:44:45 then finally once we have now to find
00:44:47 our tuner we need to do a tuner dot
00:44:50 search and we need to pass in some
00:44:53 parameters so we need to pass in first
00:44:56 or x and y so our train images or train
00:44:59 labels and then we need to pass in what
00:45:02 we're trying to optimize this network
00:45:05 for and so that's going to be our
00:45:06 validation data and that's going to be
00:45:09 equal to the test images and the test
00:45:12 labels then we can also set stuff like a
00:45:16 box I'm going to say 10 epochs now and
00:45:18 batch size of 32 cool and now the big
00:45:26 difference is we need to now choose some
00:45:28 of these values to play around and try
00:45:31 to optimize so I'm going to just as an
00:45:34 easy example play around with this dense
00:45:37 layer right here at the end so let's see
00:45:41 what our options are we can use this HP
00:45:44 dot choice I think that will be helpful
00:45:46 or we could probably use this HP dot int
00:45:48 which chooses random int values either
00:45:50 of these options is fine I think it's
00:45:52 sometimes easier to use this HP dot
00:45:54 choice just to kind of limit the number
00:45:57 of things I try so I'm going to go ahead
00:45:58 and do that so I'm going to set this
00:46:02 instead of just 128 it's going to be now
00:46:04 HP dot
00:46:08 HP choice and we now need to pass in a
00:46:11 name whenever using one of these so this
00:46:12 is going to be I'm just gonna call it
00:46:15 dense layer and now what do we want for
00:46:19 our choices well our initial was 128 so
00:46:21 we can keep that in there but how about
00:46:23 we also try 64 maybe 256 maybe 512 maybe
00:46:31 1024 so now we have five different
00:46:34 options here and what we can do is go
00:46:38 ahead and now run this search and we
00:46:42 have five options so max trials 5 is
00:46:44 good but if we had more combinations of
00:46:46 things you might want to bump up this
00:46:48 max trials value to something like 32 it
00:46:51 will run as it'll run random
00:46:54 combinations of the parameters you're
00:46:56 trying to use until it hits 32 or until
00:47:00 all the trials are exhausted so in our
00:47:03 case we only have 5 different things
00:47:05 that can choose from so it should really
00:47:06 just run 5 trials so this is a very
00:47:10 simple example of using the tuner and
00:47:12 let's see how things work and notice
00:47:14 note the tuner can take a while to run
00:47:16 so just be wary of that because we're
00:47:19 only testing 5 different things it
00:47:21 shouldn't be too too bad in our case but
00:47:23 that is something to note all right
00:47:29 awesome
00:47:29 everything executed so everything is
00:47:34 wrong we've now played around with a
00:47:36 different number of parameters here so
00:47:40 let's see some results one of the best
00:47:43 things to do first I guess is you can
00:47:44 actually get the best model it was found
00:47:47 during that by doing tuner dot get best
00:47:50 models models and then grab the 0th
00:47:57 index so that's gonna be the top model
00:47:58 and now best model is actually equal to

00:48:01 tuner Duquette
00:48:03 oh it's get best models like this it's a
00:48:10 function so now best model is set to the
00:48:15 top thing that the tuner found and we
00:48:17 can actually do best model not evaluate
00:48:20 train images or sorry test images test
00:48:25 labels and see how well it does on that
00:48:27 data and look at that so it did got 73%
00:48:35 accuracy so that was like a 4% increase
00:48:37 just by figuring out a better value to
00:48:40 use for this last layer here and one
00:48:48 thing to note too is that this guess get
00:48:51 best models will not only select the
00:48:53 best value that it found here but it
00:48:56 will also select the parameter weights
00:48:58 from the best-performing epoch during
00:49:02 the training so it did give us a boost
00:49:06 in accuracy there we can also do some
00:49:08 other stuff here one thing we could do
00:49:10 is see what actual parameters that best
00:49:12 model is using so summary you can do
00:49:14 best model dot summary and that shows us
00:49:17 that it found that a thousand twenty
00:49:19 four for that last layer did the best
00:49:21 there so that's something to note it
00:49:24 also gives us the kind of info on the
00:49:26 other layers or were using in the
00:49:27 network that's pretty cool you can also
00:49:30 do tuner dot results summary to just get
00:49:35 some high level results on how those
00:49:37 trials went so you can see kind of
00:49:39 scores from each one of those
00:49:40 combinations of layers that we used
00:49:43 alright so that's the basics of using
00:49:45 this search but I think really playing
00:49:48 around with this I was able to I think
00:49:51 get up to like 81 percent accuracy on
00:49:54 the test data and to do that I added
00:49:57 some additional things so I like played
00:49:59 around with how many convolutional
00:50:01 layers were used and how many filters so
00:50:02 that would look something like this so
00:50:05 for I in range HP dot int and now this
00:50:10 is going to be comm volution I'm going
00:50:13 to say con layer how many convolutional
00:50:17 layers we have and that's going to be
00:50:20 let's say between 0 the min value is 0
00:50:27 max value let's say is equal to three
00:50:31 and then you can also with this one set
00:50:34 a step size how many times it skips but
00:50:37 it's default is one so I'm going to
00:50:39 leave that and basically what we could
00:50:41 do here is add we're going to delete
00:50:45 this one basically in our tuner we can
00:50:47 decide how many of these convolutional
00:50:49 layers to add and additionally we could
00:50:52 even like play around with making this a
00:50:57 variable parameter so I'm going to say F
00:51:00 layer so just bear with me for a sec
00:51:06 filters basically I'm going to in the
00:51:11 convolutional layer I'm going to play
00:51:13 around with how many filters we use so
00:51:17 HP tough choice and I'm going to say we
00:51:22 could use maybe 16 32 or 64 and complete
00:51:28 that and then we'll still use a kernel
00:51:31 size of 3 and we'll still use activation
00:51:34 Rella you but basically now what we're
00:51:37 doing if we were to rerun the search
00:51:39 with this is we're deciding whether we
00:51:43 add 0 convolutional layers or up to 3
00:51:47 convolutional layers and within each
00:51:49 convolutional layers we're also playing
00:51:51 around with the number of filters that
00:51:54 we use by using this HP choice so you
00:51:56 can get really creative with this and as
00:51:58 i mentioned if you play around to this
00:52:00 enough i think i got up to like 82
00:52:02 percent accuracy on this test set by
00:52:04 just playing around with these values so
00:52:06 you could rerun this and play around are
00:52:08 things it might be take a little bit of
00:52:10 time to really run this and also one
00:52:13 thing to note is the tuner I think by
00:52:15 default if it sees you have results
00:52:17 already saved you might have to either
00:52:19 delete your results or save it in a
00:52:21 different directory here just because it
00:52:27 doesn't want to run this time intensive
00:52:29 search process again if you've already
00:52:32 gotten results so it's kind of a safety
00:52:34 thing that caris tuner does
00:52:37 and also I'll link to some other videos
00:52:39 I saw one by Centex and one by Krish
00:52:42 Naik that did a good job explaining this
00:52:45 Kerris tuner as well so I'll link to
00:52:47 those but that's all we're going to
00:52:48 cover for the Charis tuner I'd end this
00:52:52 video we're gonna rapid-fire go through
00:52:53 some things that will be helpful as you
00:52:55 try to transition the knowledge you

00:52:56 might have gained in this video to other
00:52:58 projects so the first thing that's
00:53:00 useful is how do we save and load our
00:53:06 models so we can do that by just doing
00:53:09 let's grab the best model from the
00:53:12 tuning step we can do best model that's
00:53:14 save and we could just call this like in
00:53:19 our current directory my model and so
00:53:22 this would save all the parameters in
00:53:23 that model and then you could reload it
00:53:27 with load so like I'll just call this
00:53:32 loaded model equals Karis thought models
00:53:38 dot load and sorry load model and then
00:53:43 we just need to do that same path so my
00:53:45 model and one thing to note is that with
00:53:48 Google collab I don't think that
00:53:49 anything will persist so anything you
00:53:51 save here won't stay saved next time you
00:53:54 run this but if you were to do this
00:53:56 locally on your machine you would have
00:53:59 this model saved there so as you can see
00:54:01 I could do loaded model dot evaluate
00:54:11 and get the same results as before so
00:54:14 that's something useful to know another
00:54:16 thing that is useful as you try to carry
00:54:19 this into your own projects is how do we
00:54:21 plot numpy arrays as images how do we
00:54:24 see those images at from the numpy so
00:54:27 I'm going to say plot image from numpy
00:54:32 array this is something useful want to
00:54:35 do and it's actually pretty easy to do
00:54:38 this so let's say we want to plot one of
00:54:40 our trained images so train images 0
00:54:42 dot shape I'm going to just look at real
00:54:45 quick so it's 300 by 300 by 1 well we
00:54:50 can do is just go ahead and do we need
00:54:54 to import matplotlib which we might have
00:54:57 already done maybe not
00:54:58 let's see plot that show yeah I think we
00:55:05 already did import matplotlib earlier in
00:55:08 this video so using map plot live we can
00:55:10 do plot dot image show of train images 0
00:55:16 and let's see what happens
00:55:20 invalid shape for image data so it
00:55:22 doesn't like the 300 by 300 by 1 but if
00:55:25 we pass in the color map and just let it
00:55:29 know that we're only using Gray's here I
00:55:32 think it should be fine
00:55:35 okay it still doesn't like that I think
00:55:37 it's the weirdness of having this extra
00:55:39 one here so what we can do is it just
00:55:44 need it to be 300 by 300 and not have
00:55:46 any color channel so we're gonna go
00:55:49 ahead and do image equals train images 0
00:55:58 dot reshape 300 300 and now we'll try to
00:56:03 just plot that image
00:56:07 and as you can see we've now plotted the
00:56:10 image in greyscale what we can also do
00:56:13 if let's say we wanted to plot it in RGB
00:56:19 scale we could go ahead and just kind of
00:56:23 looking back from the initial thing we
00:56:26 did so this is just going to be RBG RGB
00:56:28 test I'm going to say our RGB image
00:56:32 equals um P dot array and this is just
00:56:36 copying from earlier example image dot
00:56:43 numpy for example in DS train I'm going
00:56:53 to say take 1 this will only take like
00:56:56 run it for one image so I'll just go a
00:56:58 lot quicker and this is RGB images so
00:57:02 that's going to be an array so RGB image
00:57:05 equals RGB images 0
00:57:10 and now I can also do plot it would show
00:57:14 RGB image and now I don't need a color
00:57:18 map because this is RGB scale and look
00:57:22 at that now I got the image in with
00:57:26 color and just to show you what rvg RGB
00:57:30 image is Dutch shape that is 300 by 300
00:57:36 by 3 so that's plotting images from a
00:57:39 nut B array the other thing you might
00:57:40 want to do is how do we load in a PNG
00:57:44 image or a JPEG image and actually
00:57:46 convert that to numpy so that's another
00:57:48 useful thing so convert PNG / JPEG
00:57:54 images to numpy format that's also
00:57:58 useful we can do this very easily with a
00:58:03 library called image IO so import image
00:58:06 IO and then what we're going to do is
00:58:11 image equals image IO image read and now
00:58:15 you would pass in the path so this would
00:58:17 be path
00:58:18 to image dot like PNG but if you don't
00:58:24 have any images stored or you could also
00:58:26 just read images directly from the
00:58:28 Internet
00:58:29 so if I just went to Wikipedia let's say
00:58:35 and looked up Boston that's where I'm
00:58:38 from
00:58:39 I could just take a picture from like
00:58:42 Wikipedia so you know here is our
00:58:45 capital building so I'm gonna copy the

00:58:49 image address so if I go to that address
00:58:52 you see we have that image so I'm going
00:58:55 to just copy this address and one thing
00:58:57 that's pretty cool is that in the image
00:58:58 read method you can actually just pass
00:59:01 in URLs it works and now we have that
00:59:10 Boston image load it in through the
00:59:14 command here I can go ahead and plot the
00:59:19 image show the image just to show you
00:59:21 that we've read it in and as you see if
00:59:26 that Boston image and then the final
00:59:29 thing is we want to convert it to numpy
00:59:31 so what we would do there is just let's
00:59:35 just print out the type of image it's an
00:59:40 image i/o file but to convert it to
00:59:42 numpy we can just do image dot and P
00:59:45 equals NP dot as array and just pass in
00:59:50 the image and now if we print image NP
00:59:56 that's shape or something like that
01:00:00 we'll see the dimensions of that image
01:00:02 and basically all of our image
01:00:05 information is now stored in this image
01:00:07 NP variable so you could imagine using
01:00:10 this on your own set of images to build
01:00:16 a neural network from scratch so it's
01:00:17 another useful thing to know all right
01:00:20 with that we're gonna end this video
01:00:21 here hopefully you guys enjoyed this one
01:00:23 and hopefully you learn something in the
01:00:25 description of this video I'll link to
01:00:27 some resources to learn more about
01:00:29 convolutional neural net
01:00:30 because I think particularly with
01:00:31 convolutional neural networks it's very
01:00:34 useful to kind of leave read some
01:00:35 literature about them to kind of
01:00:37 ultimately use them as effectively as
01:00:39 possible so check the description for
01:00:41 that if you did enjoy this video it mean
01:00:43 a lot to me if you throw it a thumbs up
01:00:44 and if you haven't already please
01:00:46 subscribe to the channel also check me
01:00:49 out on the other socials Instagram and
01:00:52 Twitter I post probably more frequently
01:00:55 in those places so if you want to stay
01:00:56 up to date with everything I'm doing
01:00:57 check there
01:00:58 anyway this guys has been fun thank you
01:01:01 for watching till next time peace out
01:01:08 [Music]

You may also like