Deep Learning with Tensorflow - Convolution with Python and TensorFlow

hello and welcome in this video we will
demonstrate the convolution operation
using Python and tensorflow
all the code will be run in the
Interactive Jupiter notebook for the
first example we're going to use the
pure mathematical notation here we have
a one dimensional convolution operation
you can use the following code to
perform convolution between two arrays
as you can see it's fairly easy to do
with Python will also verify pythons
output using the convolution equation
and then will manually execute the
computation as the kernel slides across
the array we can Pat the array with
zeros this has an important effect in
certain applications so let's see how it
works with an example notice the
position of the - this is where we'll
append a zero to the array for
convolution we're also going to invert
the filter X otherwise we'd be
performing an operation known as cross
correlation for the first step with zero
padding we'd have two times zero plus
six times 1 which equals 6 for the
second step we'd simply have 2 times 1
plus 6 times 2 which equals 14 the
arrows represent the connection between
the kernel and the input then it
continues on for the third step and the
fourth step for the fifth step we're
going to use a padded zero on the other
end of the array so we'd have 2 times 4
plus 6 times 0 which is 8 so the final
result of our convolution is the array
containing 6 14 34 34 and 8 we can
verify this using numpy
sometimes you'd want to perform
dimensionality reduction in which case
you'd want the resulting array to be
smaller in that case you can perform the
operation without padding the array with
zeros so let's take a look at that again
will invert our filter before starting
for the first step we'd simply have 2
times 1 plus 6 times 2 which is 14 we'll
slide the kernel across and repeat to
get 34 and one last time we get the
value 34 again since we're not using
zero padding we'll stop at the end of
the array so the result of this
convolution is an array with the values
14 34 and 34 will use numpy to verify
again the 2d convolution operation is
defined by this equation we're going to
apply this equation to an image matrix
using G equals negative 1 1 as our
function notice that when we apply the
kernel we always invert at first the
following code will perform this
operation for us you can also see a more
difficult case here numpy is a great
tool because it has optimized matrix
operations that use a C and C++ back end
but to work with deep-learning numpy
typically isn't enough tensorflow
performs the same operations but instead
of relying heavily on python it creates
graphs for the operations and executes
them only once with a highly optimized
back end suppose we have two tensors a
three by three filter and a ten by ten
image with zero padding the output size
will be the same as the input which is
ten by ten this is known as same mode
without zero padding the output size
would be the input size - the kernel
dimension plus one this is known as
valid mode in an arcade
the resulting dimensions are 8x8 you can
upload your own images to this window in
order to experiment with convolution a
pre-processing step will first convert
the image to grayscale if you want to
use a default image type bird dot jpg we
can also experiment with an edge
detector kernel if we start changing the
kernel and analyzing the outputs we'd be
doing what a convolutional neural
network does automatically changing the
weights and biases will affect the
behavior of the feature maps it's
important to note that a convolutional
net typically Maps the pixel values into
the range from 0 to 1 in a process known
as normalization by now you should
understand how to perform convolution
using Python and tensorflow
thank you for watching this video to
practice and learn more go to the lab
and run the code for yourself