Your cart is empty.
Keep shopping
Teach on Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn MoreDeep Learning with Python and Keras
Deep Learning with Python and Keras
Understand and build Deep Learning models for images, text and more using Python and Keras
Created byData Weekends, Jose Portilla, Francesco Mosconi, Pierian Training
Last updated 8/2019
English
English [Auto],Spanish [Auto],
What you'll learn
- To describe what Deep Learning is in a simple yet accurate way
- To explain how deep learning can be used to build predictive models
- To distinguish which practical applications can benefit from deep learning
- To install and use Python and Keras to build deep learning models
- To apply deep learning to solve supervised and unsupervised learning problems involving images, text, sound, time series and tabular data.
- To build, train and use fully connected, convolutional and recurrent neural networks
- To look at the internals of a deep learning model without intimidation and with the ability to tweak its parameters
- To train and run models in the cloud using a GPU
- To estimate training costs for large models
- To re-use pre-trained models to shortcut training time and cost (transfer learning)
Explore related topics
Course content
9 sections • 148 lectures • 9h 56m total length
- Welcome to the course!1:13
- Introduction1:31
Welcome to the course!
- Real world applications of deep learning9:29
This is a hands-on course where you learn to train deep learning models. Deep learning models are used in real world applications to power technologies such as language translation and object recognition.
- Download and install Anaconda2:35
Lets get our development environment ready. Let's install Anaconda python and additional python packages you will need in order to follow the course.
- Installation Video Guide6:21
Clone the course repository from GitHub and create the Xpdl conda environment. Activate the environment, install Python 3.6, TensorFlow, and Keras, then launch Jupyter Notebook to run the first notebook.
- Obtain the code for the course0:29
Let's get the source code that we will use during the course.
- Course Folder Walkthrough5:02
- Your first deep learning model10:31
Running your first model will help us check that you have installed all the material correctly.
- Section 2 Intro1:00
- Tabular data6:06
First of all let's establish a common vocabulary and introduce some common terms that will be used throughout the course
- Data exploration with Pandas code along10:47
Descriptive statistics and a few simple checks can be very useful to formulate an initial intuition about the data.
- Visual data Exploration4:54
Plotting is a powerful way to explore the data and different kinds of plots are useful in different situations.
- Plotting with Matplotlib10:56
Let's show an example of plotting with Matplotlib!
- Unstructured Data4:59
Most often than not data is not just tabular. Deep learning can handle text documents, images, sound, and even binary data.
- Images and Sound in Jupyter5:14
Often Deep Learning uses Image or Audio data, let's see how we can work with it in the Jupyter Environment!
- Feature Engineering2:42
Feature engineering is the process through which we can transform an unstructured datapoint to a structured, tabular record.
- Exercise 1 Presentation1:45
- Exercise 1 Solution3:17
In this exercise you will load and plot a dataset, exploring it visually to gather some insights and also to familiarize with python's plotting library: Matplotlib.
- Exercise 2 Presentation1:04
Load the weight height csv dataset, inspect its columns, and create a scatter plot of weight versus height; differentiate male and female data with two colors and label the axes.
- Exercise 2 Solution4:06
Let's continue working through and explaining the solutions!
- Exercise 3 Presentation0:56
Practice creating overlapping histograms of heights for males and females from the same dataset, using alpha for transparency. Add vertical lines at the mean of each population.
- Exercise 3 Solution1:53
Let's continue working through and explaining the solutions!
- Exercise 4 Presentation0:48
Plot male and female weights using a box plot from the same dataset, and compare readability with a histogram, including titles, axes, and legends.
- Exercise 4 Solution1:36
Let's continue working through and explaining the solutions!
- Exercise 5 Presentation1:10
Learn to use a scatter matrix to explore the Titanic train dataset, visualizing gender, fare, cabin, embark port, and survival status with sample code.
- Exercise 5 Solution1:45
Let's continue working through and explaining the solutions!
- Section 3 Intro1:45
Section 3 introduces machine learning, outlining how cheap memory, compute, and data spurred its growth. It reviews core concepts like regression, classification, cross-validation, and cost function optimization as pillars.
- Machine Learning Problems3:41
There are several types of machine learning, including supervised learning, unsupervised learning, reinforcement learning etc. This course focuses primarily on Supervised Learning.
- Supervised Learning5:13
Supervised learning allows computers to learn patterns from examples. It is used in several domains and applications and here you learn to identify problems that can be solved using it.
- Linear Regression4:46
The easiest example of supervised learning is Linear Regression. LR looks for a functional relation between input and output variables.
- Cost Function3:23
In order to find the best possible linear model to describe our data, we need to define a criterion to evaluate the "goodness" of a particular model. This is the role of the cost function.
- Cost Function code along6:26
Let's begin to work through the notebook example for the cost function!
- Finding the best model2:43
Now that we have both a hypothesis (linear model) and a cost function (mean squared error), we need to find the combination of parameters that minimizes such cost.
- Linear Regression code along10:56
Let's play with Keras to create a Linear Regression Model!
- Evaluating Performance5:04
How can we know if the model we just trained is good? Since the purpose of our model is to learn to generalize from examples let's test how the model performs on a new set of data not used for training.
- Evaluating Performance code along4:31
Let's code through an example of evaluating model performance!
- Classification7:45
Classification is a technique to use when the target variable is discrete, instead of continuous. Here we introduce similarities and differences from a regression.
- Classification code along7:45
Let's code through a classification example!
- Overfitting5:01
In some cases our model may seem to be performing really well on the training data, but poorly on the test data. This is called overfitting.
- Cross Validation6:22
A more accurate way to assess the ability of our model to generalize to unseen datapoints is to repeat the train/test split procedure multiple times and then average the results. This is called cross-validation.
- Cross Validation code along4:18
Let's code through some cross validation!
- Confusion matrix5:57
Explore the confusion matrix as a better metric than accuracy to assess model errors in binary and multi-class classification, and learn about precision, recall, and the F1 score.
- Confusion Matrix code along3:29
In a binary classification we can define several types of error and choose which one to reduce.
- Feature Preprocessing code along6:00
Sometimes we need to preprocess the features, for example if we have categorical data or if the scale is too big or too small.
- Exercise 1 Presentation2:34
Build a house price regression model in Keras using features like bedrooms, square feet, and age. Load data, create X and Y, train, test, and evaluate with R2.
- Exercise 1 solution11:37
Let's code through an example solution of the pre-processing problems!
- Exercise 2 Presentation2:40
Practice binary classification on employee left company data, from loading and benchmarking to feature engineering with dummy columns, train-test split, and model evaluation using confusion matrix, precision, recall, and cross-validation.
- Exercise 2 solution12:15
Let's code through an example solution of the pre-processing problems!
- Section 4 Intro1:23
Discover section four of deep learning with Python and Keras, introducing the perceptron and neural nets for regression and classification, covering weights, biases, nodes, layers, and activation functions.
- Deep Learning successes4:36
Deep learning is successfully applied to many different domains. Here we review a few of them.
- Neural Networks5:21
The perceptron is the simplest neural network and here we learn all about Nodes, Edges, Biases, Weights as well as the need for an Activation function
- Deeper Networks3:55
We can combine the output of a perceptron to the input of another one, stacking them into layers. A fully connected architecture is just a series of such layers. Forward propagation still applies.
- Neural Networks code along6:25
Let's code through a NN example!
- Multiple Outputs5:28
Let's learn how to work with multiple outputs!
- Multiclass classification code along9:14
Let's code through an example of multi-class classification!
- Activation Functions4:42
The activation function is what makes neural networks so powerful. In this lecture we review several types of activation functions and understand why it is necessary.
- Feed forward5:20
A neural network formulates a prediction using "forward propagation". Here you will learn what it is.
- Exercise 1 Presentation1:41
Predict diabetes using a Pima Indians dataset; load data, inspect features with histograms and Seaborn pair plots, consider standardization, and prepare X and Y for a binary classifier.
- Exercise 1 Solution7:25
Let's work through our Deep Learning Introduction exercises!
- Exercise 2 Presentation1:28
- Exercise 2 Solution8:12
Let's work through our Deep Learning Introduction exercises!
- Exercise 3 Presentation1:28
Compare neural networks to other models on the Pima Indian dataset, using the same train/test split, and test with four features; then review the solution in the next video.
- Exercise 3 Solution3:14
Let's work through our Deep Learning Introduction exercises!
- Exercise 4 Presentation1:03
Explore TensorFlow Playground in exercise four to build and experiment with simple, fully connected neural nets on two labeled data groups, blue and orange, building intuition through playful exploration.
- Exercise 4 Solution5:44
The Tensorflow playground is a nice web app that allows you to play around with simple neural network parameters to get a feel for what they do.
- Section 5 Intro1:22
- Derivatives and Gradient5:26
What is the gradient and why is it important? In this lecture we introduce the gradient in 1 dimension and then extend it to many dimensions.
- Backpropagation intuition3:58
The gradient is important because it allows us to know how to adjust the parameters of our model in order to find the best model. Here I will give you some intuition about it.
- Chain Rule4:17
Let's quickly cover the Chain Rule that you'll need to understand!
- Derivative Calculation3:44
How does backpropagation work when we have a more complex neural network? The chain rule of derivation is the answer. As we shall see this reduces to a lot of matrix multiplications.
- Fully Connected Backpropagation3:58
The learning rate is the external parameter that we can control to decide the size of our updates to the weights.
- Matrix Notation4:20
How do we feed the data to our model in order to adjust the weights by gradient descent? The answer is in batches. In this lecture you will learn all about epochs, batches and mini-batches.
- Numpy Arrays code along7:33
Let's briefly go over working with NumPy arrays!
- Learning Rate2:01
The learning rate is an important parameter of your model, let's go over it!
- Learning Rate code along9:24
Let's see how models can be effected using the learning rate
- Gradient Descent3:27
Gradient descent is a first-order iterative optimization algorithm. To find a local minimum of a function using gradient descent, one takes steps proportional to the negative of the gradient (or of the approximate gradient) of the function at the current point.
- Gradient Descent code along3:42
Let's code through an example of Gradient Descent!
- EWMA4:12
Exponentially Weighted Moving Average is one of the most common algorithms used for smoothing!
- Optimizers4:17
Many improved optimization algorithms use the ewma filter. Here we review a few improvements to the naive backpropagation algorithm.
- Optimizers code along4:16
Let's code through some optimization algorithms that are using ewma.
- Initialization code along4:33
Let's code through some initialization, assigning weights to the initial values of our model.
- Inner Layers Visualization code along8:16
Let's visualize the inner layers of our network!
- Exercise 1 Presentation1:22
practice exercise one in section five guides you to build a deep learning classifier predicting wine quality, from loading data to choosing cost function, optimizer, batch size, and epochs.
- Exercise 1 Solution5:22
Let's work through the solutions for exercise 1!
- Exercise 2 Presentation1:09
Build a fully connected deep network with 8-5-2-3 nodes, train it, and use the first three layers as feature encoders to plot a two-dimensional scatter of layer three's two outputs.
- Exercise 2 Solution3:51
Let's work through the solutions for exercise 2!
- Exercise 3 Presentation1:30
Explore building and training a model with the functional API to display data in a smaller dimensional space, contrasting it with the sequential API, and appreciate its versatility.
- Exercise 3 Solution4:17
Let's work through the solutions for exercise 3!
- Exercise 4 Presentation1:49
Explore three Keras callbacks—early stopping, model checkpoint, and TensorBoard—to monitor training across epochs, save models, and visualize accuracy and loss in an interactive web UI.
- Exercise 4 Solution3:39
Let's work through the solutions for exercise 4!
- Tensorboard3:29
Tensorflow comes equipped with a small visualization server that allows us to display a bunch of things.
- Section 6 Intro1:35
Explore convolutional neural networks and their image and sequence processing strengths by learning about convolutions and tensors, and applying convolutional neural network concepts in section six.
- Features from Pixels3:37
Images can be viewed as a sequence of pixels or we can extract ad hoc features from them. Both approaches offer advantages and limitations.
- MNIST Classification1:26
- MNIST Classification code along6:12
Let's work through this classic dataset to identify and classify hand written digits!
- Beyond Pixels3:19
Nearby pixels are correlated and this can be exploited to build a more intelligent model.
- Images as Tensors5:24
In this lecture we introduce tensors as extensions of matrices and see how they are added and multiplied.
- Tensor Math code along6:14
Let's work through some of the mathematics related to Tensors!
- Convolution in 1 D3:08
Let's explore 1 dimensional convolution!
- Convolution in 1 D code along1:36
Let's code through an example 1 dimensional convolution!
- Convolution in 2 D3:22
Let's explore 2 dimensional convolution!
- Image Filters code along2:27
What is the effect of convolving an image with a gaussian filter? Here we find out.
- Convolutional Layers6:15
How are layers connected in a CNN. Here we look at weights, channels and feature maps.
- Convolutional Layers code along6:19
Let's code through some convolutional layers examples
- Pooling Layers1:32
Max pooling and Average pooling layers are useful to reduce the size of our model, forcing it to focus on the most important features.
- Pooling Layers code along1:56
Let's code through an example of pooling layers!
- Convolutional Neural Networks2:12
Combine several pooling and convolutional layers and finally connect them to a prediction fully connected layer.
- Convolutional Neural Networks code along5:51
Let's code through a CNN example!
- Weights in CNNs2:46
Compare the parameter count and the performance of convolutional and fully connected architectures.
- Beyond Images2:39
CNNs are not just useful when dealing with images. We can use them to classify other data such as sound and text. Convolutional architectures are useless when there is no correlation between nearby rows and columns, for example with tabular data
- Exercise 1 Presentation2:02
Set up a classifier to classify images (hot or not, cat or dog etc.), realize training is too slow and a GPU is needed.
- Exercise 1 Solution4:12
Set up a classifier to classify images (hot or not, cat or dog etc.), realize training is too slow and a GPU is needed.
- Exercise 2 Presentation2:55
A more complex exercise involving CNNs
- Exercise 2 Solution3:34
Let's work through another exercise solution!
- Google Colaboratory GPU notebook setup0:31
- Floyd GPU notebook setup0:37
Let's work through an example of setting up our notebook on Floydhub!
- Section 8 Intro1:05
Explore recurrent neural networks for sequence data like text, music, and movies, generating continuous predictions from a single input, with gru s and lstm s for anomaly detection and data generation.
- Time Series5:27
If you have never dealt with time-series, this lecture reviews a few concepts like rolling windows, feature extraction and validation on time series.
- Sequence problems4:47
We introduce several sequence-specific problems including one to one, one to many and many to many and show practical cases of where they are encountered.
- Vanilla RNN2:57
Explore vanilla recurrent neural networks, unrolling time to form shallow and deep rnn with u and w, using tanh to blend outputs with inputs, noting short-term memory and long-term dependency.
- LSTM and GRU6:17
Recently introduced, GRUs solve the vanishing gradient problem and allow for an effective implementation of recurrent neural networks.
- Time Series Forecasting code along6:31
Forecast time series with neural networks using a Canada retail sales dataset, clean and index by date, compare unadjusted versus seasonally adjusted series, and test a simple fully connected model.
- Time Series Forecasting with LSTM code along3:44
Load the LSTM layer from Keras, reshape inputs to [batch, time steps, features], and build a one-layer LSTM with six units; training shows only marginal improvement over the prior approach.
- Rolling Windows2:39
Explore rolling windows to extract time-series features and predict future values by sliding a fixed-size window and using its features with RNNs, CNNs, or fully connected models.
- Rolling Windows code along6:45
Explore predicting time-series values using past twelve months with a recurrent neural network and a fully connected model. Build features via pandas shift, train with early stopping, and compare performances.
- Exercise 1 Presentation1:22
Reshape the 12 months into sequences for the lstm, turning a 12-coordinate vector into a sequential input, retrain the model, and compare performance with the previous approach.
- Exercise 1 Solution2:27
- Exercise 2 Presentation1:12
Apply RNNs to images by reshaping the Mnist dataset into a long sequence of pixels, train a recurrent model, and compare its performance with fully connected and convolutional models.
- Exercise 2 Solution
- Section 9 Intro0:52
- Learning curves3:02
Learning curves are a useful tool to answer the question: do we need more data or a better algorithm? The performance of a large neural network keeps improving the more data we throw at it.
- Learning curves code along7:05
Plot learning curves for a small eight-by-eight digits dataset using a Keras fully connected model, comparing training and test performance across progressively larger training sizes.
- Batch Normalization1:58
One technique to speed up training is batch normalization.
- Batch Normalization code along5:41
- Dropout2:53
Another technique to improve convergence of a network is to make it more robust to internal failure.
- Dropout and Regularization code along2:40
Let's code through a dropout example!
- Data Augmentation2:57
In some cases, more data can be obtained by slightly modifying the existing training data. For example, applying noise to sound or distortions to an image.
- Continuous Learning2:53
In some cases we can continuously generate new data to feed to deep learning model.
- Image Generator code along6:15
Let's create an image generator!
- Hyperparameter search4:04
Let's show how we can search for optimal network architecture
- Embeddings3:32
Sometimes we can represent data in a better way before feeding it to a model.
- Embeddings code along2:34
Demonstrate a Keras embedding layer that maps indices 0–99 to 2D vectors, contrast with a fully connected layer, in a simple model with input 100 and output 2.
- Movies Reviews Sentiment Analysis code along10:53
Train a sentiment classifier on IMDb movie reviews using embedding layers and an LSTM, loading the IMDb dataset, padding sequences, and evaluating performance on train and test sets.
- Exercise 1 Presentation1:08
Review exercise one by reloading IMDb data with the first 20,000 most common words and padding reviews to a max length. Rerun the model and compare training time and performance.
- Exercise 1 Solution
Let's work through an image recognition system!
- Exercise 2 Presentation0:53
- Exercise 2 Solution
Let's work through the second exercise solution!
- Exercise 3 Presentation2:20
Review exercise three by building a 64x64 color image binary gender classifier using Crowdflower data, applying augmentation and a generator-based training loop, and evaluating misclassifications.
Requirements
- Knowledge of Python, familiarity with control flow (if/else, for loops) and pythonic constructs (functions, classes, iterables, generators)
- Use of bash shell (or equivalent command prompt) and basic commands to copy and move files
- Basic knowledge of linear algebra (what is a vector, what is a matrix, how to calculate dot product)
- Use of ssh to connect to a cloud computer
Description
This course is designed to provide a complete introduction to Deep Learning. It is aimed at beginners and intermediate programmers and data scientists who are familiar with Python and want to understand and apply Deep Learning techniques to a variety of problems.
We start with a review of Deep Learning applications and a recap of Machine Learning tools and techniques. Then we introduce Artificial Neural Networks and explain how they are trained to solve Regression and Classification problems.
Over the rest of the course we introduce and explain several architectures including Fully Connected, Convolutional and Recurrent Neural Networks, and for each of these we explain both the theory and give plenty of example applications.
This course is a good balance between theory and practice. We don't shy away from explaining mathematical details and at the same time we provide exercises and sample code to apply what you've just learned.
The goal is to provide students with a strong foundation, not just theory, not just scripting, but both. At the end of the course you'll be able to recognize which problems can be solved with Deep Learning, you'll be able to design and train a variety of Neural Network models and you'll be able to use cloud computing to speed up training and improve your model's performance.
Who this course is for:
- Software engineers who are curious about data science and about the Deep Learning buzz and want to get a better understanding of it
- Data scientists who are familiar with Machine Learning and want to develop a strong foundational knowledge of deep learning