Hello, and welcome!

In this video, we will introduce you to the MNIST database, which contains a large
set
of handwritten digits.
This database is a great tool for experimenting with deep learning models.
But before we get into the structure of MNIST, let's briefly cover the main ideas
behind
deep learning.
Deep learning is a branch of machine learning that uses algorithms to model high-
level abstractions
in data.
Typically, this involves the use of multiple processing layers, complex structures,
and
multiple non-linear transformations.
The main thing to note is that since our brains use a large, interconnected
structure, a machine
should do the same to achieve better results.
In this context, the term 'deep' refers to a Neural Network with a large number of
hidden
layers, regardless of the type of layers that are used.
Research papers have shown that Deep Neural Network Architectures can achieve
better results
than their shallow counterparts.
In our case, the term 'learning' refers to the process of supervised learning.
For the handwritten digit problem, we start with a set of images that are labelled
with
the known correct digit.
Each image is broken down into pixels, and these pixel intensities form the image's
features.
The network goes through a training process in order to build a function that will
map
the inputs to the desired outputs.
In other words, it needs to learn how to map a set of pixels that describe an
image, into
a digit from zero to nine.
This training process is performed using the previously labeled images, and it
continues
until the network achieves a desired level of accuracy.
According to Yann Lecun's website, MNIST is a database of handwritten digits with
60,000
samples for training and 10,000 samples for testing.
The database is a subset of a larger set available from NIST.
The authors have invested a lot of time on the dataset with normalization and
centering
operations.
So each digit is centered in a fixed-size image.
We're going to import the MNIST dataset using TensorFlow, but keep in mind that
this is
a highly optimized dataset.
As a result, you'll need to build your own code if you actually want to visualize
the
digits.
The 'One-hot = True' argument means that the label for each digit will have one,
distinct
bit turned on.
For example, five and zero in standard binary would look like this:
But using the single-bit, one-hot vector representation, they would look like this:
The imported data can be broken up into a few distinct subsets.
The training set is used throughout the learning process.
So for example, when the neural network analyzes a digit, it can observe the
corresponding
label in order to improve its predictions.
From the training data, we also reserve 5,000 data points for a validation set.
The validation set is used to generate model properties, like classification error,
for
example.
It's also used to determine the optimal number of hidden units or the stopping
point of the
back-propagation algorithm.
The 10,000-point test set contains data that the model never saw during training.
It's used to evaluate the model's performance on unfamiliar data, in order to gauge
how
much the model truly learned.
At this point, you should have a basic understanding of the structure of the MNIST
dataset.
Thank you for watching this video.