Multilayer Perceptron with TensorFlow - Deep Learning with Tensorflow Video Lecture | Tensorflow: Learning made Easy - AI & ML

hello and welcome in this video we will
use tensor flow to create a multi-layer
perceptron for the M NIST
database M NIST contains a large set of
highly optimized images that contain
handwritten digits when running code
with tensor flow we have the option to
build all the graphs and then run the
session or we can use an interactive
session in order to create code and run
everything on the fly since the latter
case is more suitable for a jupiter
notebook environment
we'll use the interactive session it's
good practice to create placeholders in
tensor flow before variable assignment
placeholder X represents the space that
will be allocated to the input which is
the set of handwritten digit images
placeholder Y represents the final
output which are the digit labels you'll
need to select a D type for both of the
placeholders and if you're not sure just
use TF float32
it's worth noting that the softmax
function which we'll cover shortly only
accepts float 32 and float 64 for more d
types you can check out tensor flows
documentation here now we are going to
create the weights and biases for our
neural network the initial choice of
values is critical but at this point
we'll just use arrays filled with zeros
before we told tensor flow that we
assign the weights and biases but we
didn't initialize them with null values
as a result tensorflow needs to
initialize the variables that you assign
also note that we're using the notation
says run since we previously started an
interactive session the picture below
shows how weights and biases are added
to the neurons in a network our code
performs this using the mathematical
notation with matrices the TF dot Matt
mole operation performs a matrix
multiplication between X and W which are
the inputs and weights
respectively the code also adds on the
bias values softmax is a popular
activation function for classification
problems rather than simply outputting a
yes/no answer for its prediction it will
generate a probability value for each
potential output the model will never be
100% certain of its answer so this
technique is useful for gauging the
model's confidence for each potential
answer so for example the model might
calculate that the digit nine has the
highest probability here you can see the
one hot vector representation of the
label for the digit nine to understand
the machines prediction we'd like to
know the probabilities that it placed on
each digit here's what that distribution
might look like the cost function
measures the difference between the
correct answers from the data set and
the predictions of the network we train
the network by minimizing this function
in a learning process then we need to
configure an optimizer for the neural
network there are many options to choose
from but we'll stick with the gradient
descent in practice batch gradient
descent typically isn't used since it's
computationally expensive this method
works well because it computes the true
gradient but that requires it to operate
on the entire data set at once because
of this neural networks generally use
mini-batch to Train then we're going to
test our model as well to put our result
into perspective the best algorithm as
of June 2016
produced an error of 0.21% which equates
to an accuracy of ninety-nine point
seven nine percent there are a few
techniques to improve our model some of
these techniques include drop connect
multi-column deep nets augmented pattern
classification and dropout but by now
you should understand how to train and
run a basic multi-layer perceptron using
tensorflow
thank you for watching this video too
practice and learn more go to the lab
and run the code for yourself