Deep Learning with Tensorflow - Convolutional Network with TensorFlow Video Lecture | Tensorflow: Learning made Easy - AI & ML

hello and welcome in this video we will
show you how to build a convolutional
neural network using tensorflow we'll
also train the network on the M NIST
data set which is a large collection of
handwritten digits all of the following
code cells will be run in an interactive
session in the Jupiter notebook let's
retrieve the M NIST data will then
create the general parameters for our
model and will create placeholders for
the inputs and outputs next we'll define
a function to generate weights it's
important that the weights have a small
amount of noise and that we prevent
gradients with a value of zero
after the weights we'll define a
function to generate biases an important
note about the Riu activation function
is that neurons can be very sensitive
during training if a large gradient
flows through a real owner on the
weights could be updated in such a way
that the neuron will never activate on
any data point to avoid these dead
neurons will set slightly positive
initial biases afterwards we'll define a
function to create the convolutional
layers then define a function to perform
max pooling max pooling is an operation
that finds the maximum values and
simplifies the inputs using spatial
correlations the kernel size is two by
two if the image is a two by two matrix
the output would be one pixel the
strides will dictate the sliding
behavior of the kernel in this case it
will move two pixels every time without
overlapping so this is our first
convolutional and max pooling layer
let's now set the weights and biases our
kernel size is five by five we have one
greyscale input channel and we have 30
to feature maps now we need to convert
the images of our data set into tensors
the images are 28 pixels by 28 pixels
and again since they're grayscale
there's only one channel in this case
the first dimension is the ID number of
the image which is just the inputs
position because of the negative one
there is no size limit next will
convolve with the weight tensor and add
the biases and then we'll apply the Riu
activation function here we apply the
predefined max pooling operation with
that we completed the first layer we'll
move on to the second convolutional and
max pooling layer again we'll set the
weights and biases the kernel is 5 by 5
will have 32 input channels since the
first convolutional air had 32 feature
maps and will have 64 output feature
maps we already converted the images
into tensors during the first layer
phase again we'll perform a convolution
with the weight tensor and add biases
then apply the riilu activation function
and apply max pooling and we completed
the second layer for the third layer
we're going to create a fully connected
layer that will use the softmax function
this way the network will eventually be
able to generate probabilities for its
classifications so as usual we'll add
weights and biases based on the last
layer we need to multiply the 7 by 7
feature map by the number of feature
maps which is 64 the softmax layer will
have 1,024 outputs then we'll flatten
the second layer
use matrix multiplication to apply
weights and biases apply the riilu
activation function and we completed the
third layer we can optionally use a
strategy called dropout where we
intentionally cause the network to
forget some of the features this may
help prevent overfitting although not
everyone agrees that this is the case
the final layer of the network is the
readout layer and it will also be a
fully connected layer with the softmax
function it will need 1024 input
channels due to the size of the third
layer and ten output features this will
form our classification probabilities
for each of the ten digits
we'll use matrix multiplication to apply
the weights and biases will apply the
softmax function and that's it there's a
lot of layers to keep track of so here's
a brief overview we start with the input
from our data set then we have two
convolutional and max pooling layers a
fully connected layer our dropout layer
to prevent overfitting the read out
layer to generate probabilities and then
the outputs themselves at this point
we're ready to train the model so we can
define the loss function define the
optimizer define the prediction define
the accuracy then run the session and
train and you may want a fast result
since training does take some time if
you'd like you can run even more
iterations though this will demand more
time and finally we can evaluate the
model at this point you should
understand how to implement a
convolutional neural network using
tensor flow thank you for watching this
video
to practice and learn more go to the lab
and run the code for yourself