Deep Learning with TensorFlow 2.0 [2020]

Before we begin explaining, we must cover two key concepts in machine learning: training and learning. We explore them through the example of a coffee machine.

Machine learning can be split into three major types: supervised, unsupervised, and reinforcement learning. This course focuses on supervised learning with TensorFlow; thus, we further differentiate between the two types of supervised learning: classification and regression.

The linear model is the basis of neural networks. In this lesson, we introduce xw+b as the basic linear model on which we later build the deep net.

Building on the basic linear model, we extend it to its matrix form for multiple inputs. 

In this lesson, we further extend the linear model to multiple inputs and multiple outputs. This is also its most general form, which we will use later in the TensorFlow framework.

A picture is worth a thousand words. We explore a machine learning algorithm graphic of a regression and a classification through the linear model. We further make a note on why we must also employ non-linearities.

The third main building block of a deep learning algorithm is the objective function. We explain the concept and introduce the two most commonly used objective functions: the L2-norm loss and the cross-entropy loss.

In the presence of regression, we often employ the L2-norm loss. The L2-norm loss is equivalent to the OLS in statistics or the Euclidean distance in mathematics.

In the presence of classification, one of the most common objective functions is the cross-entropy loss. We look into an image classification example that helps us picture the classification problem better.

The final ingredient of a machine learning algorithm is the optimization algorithm. The most basic method is the gradient descent. We start from the 1-parameter gradient descent to get a good idea of the methodology.

Building on the 1-parameter gradient descent, we reach the n-parameter gradient descent, which is also the basic method of optimization used in machine learning. 

In this lesson we introduce the tools we will need in this course. They are the programming language Python, the most popular Python data science platform (Anaconda), the Jupyter notebook as the main place where we will program, and, finally, the machine learning framework on which we focus: TensorFlow.

We describe our choice of programming language and environment. 

In this short lecture, we show how to download and install the Anaconda platform.

This lesson is about basic things you can do with Jupyter. We also show useful shortcuts for faster coding.

In this article you can find a PDF file with all Jupyter shortcuts. Enjoy!

To use the TensorFlow package, we must first install it. This is a very important lecture in which we show how that’s done.

‘pip install TensorFlow’ and ‘conda install TensorFlow’ are the two ways you can achieve that in Anaconda.

In this lesson we generate data on which we will later train. This step is not part of the machine learning algorithm. Essentially, we will create fake data with a linear relationship. That’s the approach we have taken to prove that the machine learning methodology we showed so far is working.

An important step in the machine learning algorithm we have not discussed is the initialization of variables. This lecture tackles that problem in practice. Later in the course, we will feature a separate section on the issue.

The final part of this minimal machine learning example is the actual training of the model. That is not deep learning just yet, but the logic follows the neural networks one, which will later be unfolded into a deep net.

This lecture is an introduction to TensorFlow. We explain our choice of framework and compare TensorFlow and sklearn.

TensorFlow 2.0 is 2 for a reason. There is still version 1 of TensorFlow. In this lecture we compare the two releases and highlight the improvements that come with TF2.

Why it makes sense to code in TF and what to expect!

TensorFlow works with tensors; thus, it requires the data to be organized in a TensorFlow-friendly way. One solution to the problem is through the NumPy file format *.npz

In TensorFlow, the model is programmed in a different way. We take the same minimal example but show it in the context of the TensorFlow framework. Essentially, we expect the same result.

Like the model, the objective function and the optimization algorithm are implemented in a different way in TensorFlow. 

We interpret the result of our training and check the weights and biases.

TensorFlow is very flexible in terms of customization. In fact that's what deep learning is all about. In this lecture we peek into the different ways in which we can customize our model.

To have deep learning and deep nets, we require (at least) several layers. However, they must be stacked with the help of non-linearities.

Stacking layers produces a deep net. But why do we need non-linearities?

In a machine learning context, non-linearities are also called activation functions. Henceforth, that’s how we will refer to them. In this lesson, we explain the basic rationale behind an activation function.

After looking into the most common activation functions, we notice that one of them is special. In this lecture we explore softmax activation and explain why it is used as the activation of the output layer in deep learning.

The most intuitive lesson, yet the hardest to grasp in mathematical terms. In this couple of lessons, we explore the intuition behind backpropagation, while in the next section, we look into the mathematics of it.

Now that we know what backpropagation is, let’s explore the intuition behind it through an example. We take a machine learning diagram of a neural network with a single hidden layer and backpropagate through it.

The mathematics behind backpropagation must be quite interesting for anyone with a quantitative background. Here they are!

One of the most commonly asked questions in data science interviews is about overfitting. Two concepts are interrelated: underfitting and overfitting. We look into both and why each one of them yields in a suboptimal machine learning algorithm. We look into a regression example.

Once we know the difference between underfitting and overfitting, we look into a classification example.

Machine learning practitioners approach the overfitting issue by dividing the initial dataset into three parts: training, validation, and test. In this lesson we explain why this is the case.

Machine learning practitioners approach the overfitting issue by dividing the initial dataset into three parts: training, validation, and test. In this lesson we look into the test dataset.

Sometimes there is not enough data to split your dataset into training, validation, and test. N-fold cross-validation is one solution to the problem.

Training, validation, and test datasets cannot prevent overfitting on their own. They should be implemented together with an early stopping mechanism.

When you use clumsy or inappropriate methods, even the fastest computer in the world won’t be able to help you with your machine learning. As they say, the devil is in the details, and this saying is as true as it gets for initialization. 

There are two simple types of initialization: random uniform and random normal initialization.

Simple initialization methods have major setbacks for a machine learning algorithm. A state-of-the-art solution to that problem is the Xavier (Glorot) initializer.

Since we’ve seen only the gradient descent, it is time to discuss improvements that will lead to enhanced machine learning algorithms. The stochastic gradient descent and batching as a whole are great improvements over the status quo.

In real life, loss functions are not as regular as we imagine them to be. Some issues are worth discussing when we use the gradient descent.

Choosing the learning rate of a machine learning algorithm is no easy task. But why choose one, when you can have a learning rate schedule?

Simply talking about the learning rate without seeing it doesn’t inform us as well as seeing a graph does. As they say, a picture is worth a thousand words.

Once, there were two leading adaptive learning rate schedules: AdaGrad and RMSprop. They are also the basis for advanced optimizers.

Adam, or the adaptive moment estimation, is the state-of-the-art optimization method. We introduce it so we can employ it later in our TensorFlow algorithms.