# Top 8 Recommended Deep Learning Self-Study Materials! [September 2024]

This page introduces the best in educational materials for beginners who are trying to learn **Deep Learning** on their own.

## Table of Contents:

## 1. Description of this page

We introduce 8 recommended video courses on various platforms for those who want to learn Deep Learning on their own.

What is Deep Learning?

Deep learning is a machine learning technique that uses neural networks with multiple hidden layers. Neural networks have a structure that imitates the neural circuits of the human brain, and can automatically learn features from data. With the use of neural networks with numerous hidden layers, deep learning makes it possible to extract advanced features and achieve higher accuracy than conventional machine learning methods. Deep learning is widely used in various fields such as image recognition, speech recognition, and natural language processing, and is expected to realize more advanced artificial intelligence by mimicking human cognitive abilities.

Our site, "Outlecture," evaluates courses using our proprietary algorithm that balances course rating, freshness of information, number of purchasers and viewers, and recent rate of increase, in order to extract only the most suitable courses for users.

In addition, we will explain the features of each video platform and provide use cases such as "this is better for people in this situation."

We hope this will be a reference for everyone who is going to learn Deep Learning.

## 2. Top 5 Recommended Udemy Courses

Here are Outlecture's top 5 recommended Udemy courses, carefully selected for you.

Title | Ratings | Subscribers | Subscribers last month (August 2024) | Level | Video Duration | Created | Last updated | Price |
---|---|---|---|---|---|---|---|---|

TensorFlow for Deep Learning Bootcamp | 4.63 | 74,916 | 955 | all | 62 hours 27 minutes | Dec 9th, 2020 | May 12th, 2024 | $119.99 |

Tensorflow 2.0: Deep Learning and Artificial Intelligence | 4.78 | 56,960 | 863 | all | 23 hours 52 minutes | Jun 26th, 2019 | Aug 1st, 2024 | $149.99 |

Deep Learning A-Z 2024: Neural Networks, AI & ChatGPT Prize | 4.53 | 384,812 | 1,661 | all | 22 hours 27 minutes | Mar 20th, 2017 | Aug 5th, 2024 | $129.99 |

A deep understanding of deep learning (with Python intro) | 4.72 | 35,539 | 840 | beginner | 57 hours 18 minutes | Aug 4th, 2021 | Aug 31st, 2024 | $119.99 |

Curiosity Driven Deep Reinforcement Learning | 4.7 | 1,432 | - | expert | 4 hours 9 minutes | Oct 3rd, 2021 | Jul 9th, 2023 | $54.99 |

Udemy, Inc. is an education technology company that provides the world's largest online learning and teaching platform.

The features of Udemy include:

- Over 155,000 course
- Instructors who are leading experts in their fields
- Affordable prices range from tens to hundreds of dollars per course, with discounts of up to 70-90% during campaigns
- Courses can be viewed without expiration after purchase, and come with a 30-day money-back guarantee
- Courses can be taken at the student's own pace, with playback speeds of 0.5 to 2 times normal speed, and can be viewed offline on a smartphone with a dedicated app
- Students can ask questions directly to the instructor on the course discussion board, allowing them to resolve any doubts and receive support for self-study

These are some of the benefits of using Udemy.

The management team at Outlecture consists of active software engineers, creators, and web designers. We often catch up on learning new programming languages and products by taking courses on Udemy.

As for our experience, we find that Udemy offers courses of very high quality. The instructors are all leading figures in their fields, and they teach cutting-edge knowledge and practical know-how in a clear and detailed manner. You can acquire the knowledge and skills that are actually used in the field and in practical projects, rather than just knowledge for exams.

We highly recommend Udemy courses, especially for those who want to apply what they learn in practical situations or for those who want to start self-studying. Once you purchase a course, you can take it without a time limit, and there is a 30-day money-back guarantee, so you can start learning with peace of mind.

Recommended for

- Planning to use Deep Learning in actual projects
- Wanting to learn the know-how of professionals who are active in the world's cutting-edge fields
- Hesitant to use a subscription service
- Having basic IT knowledge

The details of each course are as follows:

Learn TensorFlow by Google. Become an AI, Machine Learning, and Deep Learning expert!

- Ratings
- 4.63
- Subscribers
- 74,916
- Subscribers last month

(August 2024) - 955
- Level
- all
- Video Duration
- 62 hours 27 minutes
- Created
- Dec 9th, 2020
- Last updated
- May 12th, 2024
- Price
- $119.99

**Just launched with all modern best practices for building neural networks with TensorFlow and becoming a TensorFlow & Deep Learning Expert!**

**Join a live online community of over 900,000+ students and a course taught by a TensorFlow expert. This course will take you from absolute beginner with TensorFlow, to creating state-of-the-art deep learning neural networks.**

TensorFlow experts earn up to **$204,000 USD** a year, with the average salary hovering around **$148,000 USD**. By taking this course you will be joining the growing Machine Learning industry and becoming a top paid TensorFlow Developer!

**Here is a full course breakdown of everything we will teach (yes, it's very comprehensive, but don't be intimidated, as we will teach you everything from scratch!):**

The goal of this course is to teach you all the skills necessary for you to become a top 10% TensorFlow Developer.

*This course will be very hands on and project based. You won't just be staring at us teach, but you will actually get to experiment, do exercises, and build machine learning models and projects to mimic real life scenarios. By the end of it all, you will develop skillsets needed to develop modern deep learning solutions that big tech companies encounter. *

0 — TensorFlow Fundamentals

Introduction to tensors (creating tensors)

Getting information from tensors (tensor attributes)

Manipulating tensors (tensor operations)

Tensors and NumPy

Using @tf.function (a way to speed up your regular Python functions)

Using GPUs with TensorFlow

1 — Neural Network Regression with TensorFlow

Build TensorFlow sequential models with multiple layers

Prepare data for use with a machine learning model

Learn the different components which make up a deep learning model (loss function, architecture, optimization function)

Learn how to diagnose a regression problem (predicting a number) and build a neural network for it

**2 — Neural Network Classification with TensorFlow**

Learn how to diagnose a classification problem (predicting whether something is one thing or another)

Build, compile & train machine learning classification models using TensorFlow

Build and train models for binary and multi-class classification

Plot modelling performance metrics against each other

Match input (training data shape) and output shapes (prediction data target)

3 — Computer Vision and Convolutional Neural Networks with TensorFlow

Build convolutional neural networks with Conv2D and pooling layers

Learn how to diagnose different kinds of computer vision problems

Learn to how to build computer vision neural networks

Learn how to use real-world images with your computer vision models

4 — Transfer Learning with TensorFlow Part 1: Feature Extraction

Learn how to use pre-trained models to extract features from your own data

Learn how to use TensorFlow Hub for pre-trained models

Learn how to use TensorBoard to compare the performance of several different models

5 — Transfer Learning with TensorFlow Part 2: Fine-tuning

Learn how to setup and run several machine learning experiments

Learn how to use data augmentation to increase the diversity of your training data

Learn how to fine-tune a pre-trained model to your own custom problem

Learn how to use Callbacks to add functionality to your model during training

6 — Transfer Learning with TensorFlow Part 3: Scaling Up (Food Vision mini)

Learn how to scale up an existing model

Learn to how evaluate your machine learning models by finding the most wrong predictions

Beat the original Food101 paper using only 10% of the data

**7 — Milestone Project 1: Food Vision**

Combine everything you've learned in the previous 6 notebooks to build Food Vision: a computer vision model able to classify 101 different kinds of foods. Our model well and truly beats the original Food101 paper.

8 — NLP Fundamentals in TensorFlow

Learn to:

Preprocess natural language text to be used with a neural network

Create word embeddings (numerical representations of text) with TensorFlow

Build neural networks capable of binary and multi-class classification using:

RNNs (recurrent neural networks)

LSTMs (long short-term memory cells)

GRUs (gated recurrent units)

CNNs

Learn how to evaluate your NLP models

9 — Milestone Project 2: SkimLit

Replicate a the model which powers the PubMed 200k paper to classify different sequences in PubMed medical abstracts (which can help researchers read through medical abstracts faster)

10 — Time Series fundamentals in TensorFlow

Learn how to diagnose a time series problem (building a model to make predictions based on data across time, e.g. predicting the stock price of AAPL tomorrow)

Prepare data for time series neural networks (features and labels)

Understanding and using different time series evaluation methods

MAE — mean absolute error

Build time series forecasting models with TensorFlow

RNNs (recurrent neural networks)

CNNs (convolutional neural networks)

11 — Milestone Project 3: (Surprise)

If you've read this far, you are probably interested in the course. This last project will be good... we promise you, so see you inside the course ;)

TensorFlow is growing in popularity and more and more job openings are appearing for this specialized knowledge. As a matter of fact, TensorFlow is outgrowing other popular ML tools like PyTorch in job market. Google, Airbnb, Uber, DeepMind, Intel, IBM, Twitter, and many others are currently powered by TensorFlow. There is a reason these big tech companies are using this technology and you will find out all about the power that TensorFlow gives developers. **We guarantee you this is the most comprehensive online course on TensorFlow. **So why wait?** **Make yourself stand out by becoming a TensorFlow Expert and advance your career.**See you inside the course!**

- Introduction
- Course Outline
- Join Our Online Classroom!
- Exercise: Meet Your Classmates & Instructor
- All Course Resources + Asking Questions + Getting Help
- ZTM Resources
- Deep Learning and TensorFlow Fundamentals
- What is deep learning?
- Why use deep learning?
- What are neural networks?
- Python + Machine Learning Monthly
- What is deep learning already being used for?
- What is and why use TensorFlow?
- What is a Tensor?
- What we're going to cover throughout the course
- How to approach this course
- Need A Refresher?
- Creating your first tensors with TensorFlow and tf.constant()
- Creating tensors with TensorFlow and tf.Variable()
- Creating random tensors with TensorFlow
- Shuffling the order of tensors
- Creating tensors from NumPy arrays
- Getting information from your tensors (tensor attributes)
- Indexing and expanding tensors
- Manipulating tensors with basic operations
- Matrix multiplication with tensors part 1
- Matrix multiplication with tensors part 2
- Matrix multiplication with tensors part 3
- Changing the datatype of tensors
- Tensor aggregation (finding the min, max, mean & more)
- Tensor troubleshooting example (updating tensor datatypes)
- Finding the positional minimum and maximum of a tensor (argmin and argmax)
- Squeezing a tensor (removing all 1-dimension axes)
- One-hot encoding tensors
- Trying out more tensor math operations
- Exploring TensorFlow and NumPy's compatibility
- Making sure our tensor operations run really fast on GPUs
- TensorFlow Fundamentals challenge, exercises & extra-curriculum
- Monthly Coding Challenges, Free Resources and Guides
- LinkedIn Endorsements
- Neural network regression with TensorFlow
- Introduction to Neural Network Regression with TensorFlow
- Inputs and outputs of a neural network regression model
- Anatomy and architecture of a neural network regression model
- Creating sample regression data (so we can model it)
- Note: Code update for upcoming lecture(s) for TensorFlow 2.7.0+ fix
- The major steps in modelling with TensorFlow
- Steps in improving a model with TensorFlow part 1
- Steps in improving a model with TensorFlow part 2
- Steps in improving a model with TensorFlow part 3
- Evaluating a TensorFlow model part 1 ("visualise, visualise, visualise")
- Evaluating a TensorFlow model part 2 (the three datasets)
- Evaluating a TensorFlow model part 3 (getting a model summary)
- Evaluating a TensorFlow model part 4 (visualising a model's layers)
- Evaluating a TensorFlow model part 5 (visualising a model's predictions)
- Evaluating a TensorFlow model part 6 (common regression evaluation metrics)
- Evaluating a TensorFlow regression model part 7 (mean absolute error)
- Evaluating a TensorFlow regression model part 7 (mean square error)
- Setting up TensorFlow modelling experiments part 1 (start with a simple model)
- Setting up TensorFlow modelling experiments part 2 (increasing complexity)
- Comparing and tracking your TensorFlow modelling experiments
- How to save a TensorFlow model
- How to load and use a saved TensorFlow model
- (Optional) How to save and download files from Google Colab
- Putting together what we've learned part 1 (preparing a dataset)
- Putting together what we've learned part 2 (building a regression model)
- Putting together what we've learned part 3 (improving our regression model)
- Preprocessing data with feature scaling part 1 (what is feature scaling?)
- Preprocessing data with feature scaling part 2 (normalising our data)
- Preprocessing data with feature scaling part 3 (fitting a model on scaled data)
- TensorFlow Regression challenge, exercises & extra-curriculum
- Learning Guideline
- Neural network classification in TensorFlow
- Introduction to neural network classification in TensorFlow
- Example classification problems (and their inputs and outputs)
- Input and output tensors of classification problems
- Typical architecture of neural network classification models with TensorFlow
- Creating and viewing classification data to model
- Checking the input and output shapes of our classification data
- Building a not very good classification model with TensorFlow
- Trying to improve our not very good classification model
- Creating a function to view our model's not so good predictions
- Note: Updates for TensorFlow 2.7.0
- Make our poor classification model work for a regression dataset
- Non-linearity part 1: Straight lines and non-straight lines
- Non-linearity part 2: Building our first neural network with non-linearity
- Non-linearity part 3: Upgrading our non-linear model with more layers
- Non-linearity part 4: Modelling our non-linear data once and for all
- Non-linearity part 5: Replicating non-linear activation functions from scratch
- Getting great results in less time by tweaking the learning rate
- Using the TensorFlow History object to plot a model's loss curves
- Using callbacks to find a model's ideal learning rate
- Training and evaluating a model with an ideal learning rate
- Introducing more classification evaluation methods
- Finding the accuracy of our classification model
- Creating our first confusion matrix (to see where our model is getting confused)
- Making our confusion matrix prettier
- Putting things together with multi-class classification part 1: Getting the data
- Multi-class classification part 2: Becoming one with the data
- Multi-class classification part 3: Building a multi-class classification model
- Multi-class classification part 4: Improving performance with normalisation
- Multi-class classification part 5: Comparing normalised and non-normalised data
- Multi-class classification part 6: Finding the ideal learning rate
- Multi-class classification part 7: Evaluating our model
- Multi-class classification part 8: Creating a confusion matrix
- Multi-class classification part 9: Visualising random model predictions
- What "patterns" is our model learning?
- TensorFlow classification challenge, exercises & extra-curriculum
- Computer Vision and Convolutional Neural Networks in TensorFlow
- Introduction to Computer Vision with TensorFlow
- Introduction to Convolutional Neural Networks (CNNs) with TensorFlow
- Downloading an image dataset for our first Food Vision model
- Becoming One With Data
- Becoming One With Data Part 2
- Becoming One With Data Part 3
- Building an end to end CNN Model
- Using a GPU to run our CNN model 5x faster
- Trying a non-CNN model on our image data
- Improving our non-CNN model by adding more layers
- Breaking our CNN model down part 1: Becoming one with the data
- Breaking our CNN model down part 2: Preparing to load our data
- Breaking our CNN model down part 3: Loading our data with ImageDataGenerator
- Breaking our CNN model down part 4: Building a baseline CNN model
- Breaking our CNN model down part 5: Looking inside a Conv2D layer
- Breaking our CNN model down part 6: Compiling and fitting our baseline CNN
- Breaking our CNN model down part 7: Evaluating our CNN's training curves
- Breaking our CNN model down part 8: Reducing overfitting with Max Pooling
- Breaking our CNN model down part 9: Reducing overfitting with data augmentation
- Breaking our CNN model down part 10: Visualizing our augmented data
- Breaking our CNN model down part 11: Training a CNN model on augmented data
- Breaking our CNN model down part 12: Discovering the power of shuffling data
- Breaking our CNN model down part 13: Exploring options to improve our model
- Downloading a custom image to make predictions on
- Writing a helper function to load and preprocessing custom images
- Making a prediction on a custom image with our trained CNN
- Multi-class CNN's part 1: Becoming one with the data
- Multi-class CNN's part 2: Preparing our data (turning it into tensors)
- Multi-class CNN's part 3: Building a multi-class CNN model
- Multi-class CNN's part 4: Fitting a multi-class CNN model to the data
- Multi-class CNN's part 5: Evaluating our multi-class CNN model
- Multi-class CNN's part 6: Trying to fix overfitting by removing layers
- Multi-class CNN's part 7: Trying to fix overfitting with data augmentation
- Multi-class CNN's part 8: Things you could do to improve your CNN model
- Multi-class CNN's part 9: Making predictions with our model on custom images
- Saving and loading our trained CNN model
- TensorFlow computer vision and CNNs challenge, exercises & extra-curriculum
- Transfer Learning in TensorFlow Part 1: Feature extraction
- What is and why use transfer learning?
- Downloading and preparing data for our first transfer learning model
- Introducing Callbacks in TensorFlow and making a callback to track our models
- Exploring the TensorFlow Hub website for pretrained models
- Building and compiling a TensorFlow Hub feature extraction model
- Blowing our previous models out of the water with transfer learning
- Plotting the loss curves of our ResNet feature extraction model
- Building and training a pre-trained EfficientNet model on our data
- Different Types of Transfer Learning
- Comparing Our Model's Results
- TensorFlow Transfer Learning Part 1 challenge, exercises & extra-curriculum
- Exercise: Imposter Syndrome
- Transfer Learning in TensorFlow Part 2: Fine tuning
- Introduction to Transfer Learning in TensorFlow Part 2: Fine-tuning
- Importing a script full of helper functions (and saving lots of space)
- Downloading and turning our images into a TensorFlow BatchDataset
- Discussing the four (actually five) modelling experiments we're running
- Comparing the TensorFlow Keras Sequential API versus the Functional API
- Note: Fixes for EfficientNetB0 model creation + weight loading
- Creating our first model with the TensorFlow Keras Functional API
- Compiling and fitting our first Functional API model
- Getting a feature vector from our trained model
- Drilling into the concept of a feature vector (a learned representation)
- Downloading and preparing the data for Model 1 (1 percent of training data)
- Building a data augmentation layer to use inside our model
- Note: Small fix for next video, for images not augmenting
- Visualizing what happens when images pass through our data augmentation layer
- Building Model 1 (with a data augmentation layer and 1% of training data)
- Building Model 2 (with a data augmentation layer and 10% of training data)
- Creating a ModelCheckpoint to save our model's weights during training
- Fitting and evaluating Model 2 (and saving its weights using ModelCheckpoint)
- Loading and comparing saved weights to our existing trained Model 2
- Preparing Model 3 (our first fine-tuned model)
- Fitting and evaluating Model 3 (our first fine-tuned model)
- Comparing our model's results before and after fine-tuning
- Downloading and preparing data for our biggest experiment yet (Model 4)
- Preparing our final modelling experiment (Model 4)
- Fine-tuning Model 4 on 100% of the training data and evaluating its results
- Comparing our modelling experiment results in TensorBoard
- How to view and delete previous TensorBoard experiments
- Transfer Learning in TensorFlow Part 2 challenge, exercises and extra-curriculum
- Transfer Learning with TensorFlow Part 3: Scaling Up
- Introduction to Transfer Learning Part 3: Scaling Up
- Getting helper functions ready and downloading data to model
- Outlining the model we're going to build and building a ModelCheckpoint callback
- Creating a data augmentation layer to use with our model
- Creating a headless EfficientNetB0 model with data augmentation built in
- Fitting and evaluating our biggest transfer learning model yet
- Unfreezing some layers in our base model to prepare for fine-tuning
- Fine-tuning our feature extraction model and evaluating its performance
- Saving and loading our trained model
- Downloading a pretrained model to make and evaluate predictions with
- Making predictions with our trained model on 25,250 test samples

Machine Learning & Neural Networks for Computer Vision, Time Series Analysis, NLP, GANs, Reinforcement Learning, +More!

- Ratings
- 4.78
- Subscribers
- 56,960
- Subscribers last month

(August 2024) - 863
- Level
- all
- Video Duration
- 23 hours 52 minutes
- Created
- Jun 26th, 2019
- Last updated
- Aug 1st, 2024
- Price
- $149.99

Ever wondered how AI technologies like **OpenAI** **ChatGPT**,** GPT-4**, **DALL-E**, **Midjourney**, and **Stable Diffusion** really work? In this course, you will learn the foundations of these groundbreaking applications.

Welcome to Tensorflow 2.0!

What an exciting time. It's been nearly 4 years since Tensorflow was released, and the library has evolved to its official second version.

Tensorflow is Google's library for **deep learning** and **artificial intelligence**.

Deep Learning has been responsible for some amazing achievements recently, such as:

Generating beautiful, photo-realistic images of people and things that never existed (GANs)

Beating world champions in the strategy game Go, and complex video games like CS:GO and Dota 2 (Deep Reinforcement Learning)

Self-driving cars (Computer Vision)

Speech recognition (e.g. Siri) and machine translation (Natural Language Processing)

Even creating videos of people doing and saying things they never did (DeepFakes - a potentially nefarious application of deep learning)

Tensorflow is the world's most popular library for deep learning, and it's built by Google, whose parent Alphabet recently became the most cash-rich company in the world (just a few days before I wrote this). It is the library of choice for many companies doing AI and machine learning.

In other words, if you want to do deep learning, you gotta know Tensorflow.

**This course is for beginner-level students all the way up to expert-level students.** How can this be?

If you've just taken my free Numpy prerequisite, then you know everything you need to jump right in. We will start with some very basic machine learning models and advance to state of the art concepts.

Along the way, you will learn about all of the major deep learning architectures, such as Deep Neural Networks, Convolutional Neural Networks (image processing), and Recurrent Neural Networks (sequence data).

Current projects include:

**Natural Language Processing (NLP)****Recommender Systems****Transfer Learning for Computer Vision****Generative Adversarial Networks (GANs)****Deep Reinforcement Learning Stock Trading Bot**

Even if you've taken all of my previous courses already, you will still learn about how to convert your previous code so that it uses Tensorflow 2.0, and there are all-new and never-before-seen projects in this course such as **time series forecasting** and how to do **stock predictions.**

This course is designed for students who want to learn fast, but there are also "in-depth" sections in case you want to dig a little deeper into the theory (like what is a loss function, and what are the different types of gradient descent approaches).

Advanced Tensorflow topics include:

Deploying a model with

**Tensorflow Serving**(Tensorflow in the cloud)Deploying a model with

**Tensorflow Lite**(mobile and embedded applications)Distributed Tensorflow training with

**Distribution Strategies**Writing your own custom Tensorflow model

Converting Tensorflow 1.x code to Tensorflow 2.0

Constants, Variables, and Tensors

Eager execution

Gradient tape

Instructor's Note: This course focuses on *breadth* rather than *depth*, with less theory in favor of building more cool stuff. If you are looking for a more theory-dense course, this is not it. Generally, for each of these topics (recommender systems, natural language processing, reinforcement learning, computer vision, GANs, etc.) I already have courses singularly focused on those topics.

Thanks for reading, and I’ll see you in class!

WHAT ORDER SHOULD I TAKE YOUR COURSES IN?:

Check out the lecture "Machine Learning and AI Prerequisite Roadmap" (available in the FAQ of any of my courses, including the free Numpy course)

UNIQUE FEATURES

Every line of code explained in detail - email me any time if you disagree

No wasted time "typing" on the keyboard like other courses - let's be honest, nobody can really write code worth learning about in just 20 minutes from scratch

Not afraid of university-level math - get important details about algorithms that other courses leave out

- Welcome
- Introduction
- Outline
- Where to get the code, notebooks, and data
- Google Colab
- Intro to Google Colab, how to use a GPU or TPU for free
- Tensorflow 2.0 in Google Colab
- Uploading your own data to Google Colab
- Where can I learn about Numpy, Scipy, Matplotlib, Pandas, and Scikit-Learn?
- How to Succeed in This Course
- Temporary 403 Errors
- Machine Learning and Neurons
- What is Machine Learning?
- Code Preparation (Classification Theory)
- Classification Notebook
- Code Preparation (Regression Theory)
- Regression Notebook
- The Neuron
- How does a model "learn"?
- Making Predictions
- Saving and Loading a Model
- Why Keras?
- Suggestion Box
- Feedforward Artificial Neural Networks
- Artificial Neural Networks Section Introduction
- Beginners Rejoice: The Math in This Course is Optional
- Forward Propagation
- The Geometrical Picture
- Activation Functions
- Multiclass Classification
- How to Represent Images
- Color Mixing Clarification
- Code Preparation (ANN)
- ANN for Image Classification
- ANN for Regression
- Convolutional Neural Networks
- What is Convolution? (part 1)
- What is Convolution? (part 2)
- What is Convolution? (part 3)
- Convolution on Color Images
- CNN Architecture
- CNN Code Preparation
- CNN for Fashion MNIST
- CNN for CIFAR-10
- Data Augmentation
- Batch Normalization
- Improving CIFAR-10 Results
- Recurrent Neural Networks, Time Series, and Sequence Data
- Sequence Data
- Forecasting
- Autoregressive Linear Model for Time Series Prediction
- Proof that the Linear Model Works
- Recurrent Neural Networks
- RNN Code Preparation
- RNN for Time Series Prediction
- Paying Attention to Shapes
- GRU and LSTM (pt 1)
- GRU and LSTM (pt 2)
- A More Challenging Sequence
- Demo of the Long Distance Problem
- RNN for Image Classification (Theory)
- RNN for Image Classification (Code)
- Stock Return Predictions using LSTMs (pt 1)
- Stock Return Predictions using LSTMs (pt 2)
- Stock Return Predictions using LSTMs (pt 3)
- Other Ways to Forecast
- Natural Language Processing (NLP)
- Embeddings
- Code Preparation (NLP)
- Text Preprocessing
- Text Classification with LSTMs
- CNNs for Text
- Text Classification with CNNs
- Recommender Systems
- Recommender Systems with Deep Learning Theory
- Recommender Systems with Deep Learning Code
- Transfer Learning for Computer Vision
- Transfer Learning Theory
- Some Pre-trained Models (VGG, ResNet, Inception, MobileNet)
- Large Datasets and Data Generators
- 2 Approaches to Transfer Learning
- Transfer Learning Code (pt 1)
- Transfer Learning Code (pt 2)
- GANs (Generative Adversarial Networks)
- GAN Theory
- GAN Code
- Deep Reinforcement Learning (Theory)
- Deep Reinforcement Learning Section Introduction
- Elements of a Reinforcement Learning Problem
- States, Actions, Rewards, Policies
- Markov Decision Processes (MDPs)
- The Return
- Value Functions and the Bellman Equation
- What does it mean to “learn”?
- Solving the Bellman Equation with Reinforcement Learning (pt 1)
- Solving the Bellman Equation with Reinforcement Learning (pt 2)
- Epsilon-Greedy
- Q-Learning
- Deep Q-Learning / DQN (pt 1)
- Deep Q-Learning / DQN (pt 2)
- How to Learn Reinforcement Learning
- Stock Trading Project with Deep Reinforcement Learning
- Reinforcement Learning Stock Trader Introduction
- Data and Environment
- Replay Buffer
- Program Design and Layout
- Code pt 1
- Code pt 2
- Code pt 3
- Code pt 4
- Reinforcement Learning Stock Trader Discussion
- Help! Why is the code slower on my machine?
- Advanced Tensorflow Usage
- What is a Web Service? (Tensorflow Serving pt 1)
- Tensorflow Serving pt 2
- Tensorflow Lite (TFLite)
- Why is Google the King of Distributed Computing?
- Training with Distributed Strategies
- Using the TPU
- Low-Level Tensorflow
- Differences Between Tensorflow 1.x and Tensorflow 2.x
- Constants and Basic Computation
- Variables and Gradient Tape
- Build Your Own Custom Model
- In-Depth: Loss Functions
- Mean Squared Error
- Binary Cross Entropy
- Categorical Cross Entropy
- In-Depth: Gradient Descent
- Gradient Descent
- Stochastic Gradient Descent
- Momentum
- Variable and Adaptive Learning Rates
- Adam (pt 1)
- Adam (pt 2)
- Course Conclusion
- How to get the Tensorflow Developer Certificate
- What to Learn Next
- Extras
- How to Choose Hyperparameters
- Get the Exercise Pack for This Course
- Setting up your Environment (FAQ by Student Request)
- Pre-Installation Check
- How to install Numpy, Scipy, Matplotlib, Pandas, IPython, Theano, and TensorFlow
- Anaconda Environment Setup
- Installing NVIDIA GPU-Accelerated Deep Learning Libraries on your Home Computer
- Extra Help With Python Coding for Beginners (FAQ by Student Request)
- Get Your Hands Dirty, Practical Coding Experience, Data Links
- How to use Github & Extra Coding Tips (Optional)
- Beginner's Coding Tips
- How to Code Yourself (part 1)
- How to Code Yourself (part 2)
- Proof that using Jupyter Notebook is the same as not using it
- Is Theano Dead?
- Effective Learning Strategies for Machine Learning (FAQ by Student Request)
- How to Succeed in this Course (Long Version)
- Is this for Beginners or Experts? Academic or Practical? Fast or slow-paced?
- Machine Learning and AI Prerequisite Roadmap (pt 1)
- Machine Learning and AI Prerequisite Roadmap (pt 2)
- Common Beginner Questions: What if I'm "advanced"?
- Appendix / FAQ Finale
- What is the Appendix?
- BONUS

Learn to create Deep Learning models in Python from two Machine Learning, Data Science experts. Code templates included.

- Ratings
- 4.53
- Subscribers
- 384,812
- Subscribers last month

(August 2024) - 1,661
- Level
- all
- Video Duration
- 22 hours 27 minutes
- Created
- Mar 20th, 2017
- Last updated
- Aug 5th, 2024
- Price
- $129.99

*** As seen on Kickstarter ***

Artificial intelligence is growing exponentially. There is no doubt about that. Self-driving cars are clocking up millions of miles, IBM Watson is diagnosing patients better than armies of doctors and Google Deepmind's AlphaGo beat the World champion at Go - a game where intuition plays a key role.

But the further AI advances, the more complex become the problems it needs to solve. And only Deep Learning can solve such complex problems and that's why it's at the heart of Artificial intelligence.

**--- Why Deep Learning A-Z? ---**

Here are five reasons we think Deep Learning A-Z really is different, and stands out from the crowd of other training programs out there:

**1. ROBUST STRUCTURE **

The first and most important thing we focused on is giving the course a robust structure. Deep Learning is very broad and complex and to navigate this maze you need a clear and global vision of it.

That's why we grouped the tutorials into two volumes, representing the two fundamental branches of Deep Learning: Supervised Deep Learning and Unsupervised Deep Learning. With each volume focusing on three distinct algorithms, we found that this is the best structure for mastering Deep Learning.

**2. INTUITION TUTORIALS**

So many courses and books just bombard you with the theory, and math, and coding... But they forget to explain, perhaps, the most important part: **why you are doing what you are doing. **And that's how this course is so different. We focus on developing an intuitive **feel** for the concepts behind Deep Learning algorithms.

With our intuition tutorials you will be confident that you understand all the techniques on an instinctive level. And once you proceed to the hands-on coding exercises you will see for yourself how much more meaningful your experience will be. This is a game-changer.

**3. EXCITING PROJECTS**

Are you tired of courses based on over-used, outdated data sets?

Yes? Well then you're in for a treat.

Inside this class we will work on Real-World datasets, to solve Real-World business problems. (Definitely not the boring iris or digit classification datasets that we see in every course). In this course we will solve six real-world challenges:

Artificial Neural Networks to solve a Customer Churn problem

Convolutional Neural Networks for Image Recognition

Recurrent Neural Networks to predict Stock Prices

Self-Organizing Maps to investigate Fraud

Boltzmann Machines to create a Recomender System

Stacked Autoencoders* to take on the challenge for the

**Netflix $1 Million prize**

**Stacked Autoencoders is a brand new technique in Deep Learning which didn't even exist a couple of years ago. We haven't seen this method explained anywhere else in sufficient depth.*

**4. HANDS-ON CODING **

In Deep Learning A-Z we code together with you. Every practical tutorial starts with a blank page and we write up the code from scratch. This way you can follow along and understand exactly how the code comes together and what each line means.

In addition, we will purposefully structure the code in such a way so that you can download it and apply it in your own projects. Moreover, we explain step-by-step where and how to modify the code to insert YOUR dataset, to tailor the algorithm to your needs, to get the output that you are after.

This is a course which naturally extends into your career.

**5. IN-COURSE SUPPORT**

Have you ever taken a course or read a book where you have questions but cannot reach the author?

Well, this course is different. We are fully committed to making this the most disruptive and powerful Deep Learning course on the planet. With that comes a responsibility to constantly be there when you need our help.

In fact, since we physically also need to eat and sleep we have put together a team of professional Data Scientists to help us out. Whenever you ask a question you will get a response from us within 48 hours maximum.

No matter how complex your query, we will be there. The bottom line is we want you to succeed.

**--- The Tools ---**

Tensorflow and Pytorch are the two most popular open-source libraries for Deep Learning. In this course you will learn both!

TensorFlow was developed by Google and is used in their speech recognition system, in the new google photos product, gmail, google search and much more. Companies using Tensorflow include AirBnb, Airbus, Ebay, Intel, Uber and dozens more.

PyTorch is as just as powerful and is being developed by researchers at Nvidia and leading universities: Stanford, Oxford, ParisTech. Companies using PyTorch include Twitter, Saleforce and Facebook.

So which is better and for what?

Well, in this course you will have an opportunity to work with both and understand when Tensorflow is better and when PyTorch is the way to go. Throughout the tutorials we compare the two and give you tips and ideas on which could work best in certain circumstances.

The interesting thing is that both these libraries are barely over 1 year old. That's what we mean when we say that in this course we teach you the most cutting edge Deep Learning models and techniques.

**--- More Tools ---**

*Theano *is another open source deep learning library. It's very similar to Tensorflow in its functionality, but nevertheless we will still cover it.

*Keras *is an incredible library to implement Deep Learning models. It acts as a wrapper for Theano and Tensorflow. Thanks to Keras we can create powerful and complex Deep Learning models with only a few lines of code. This is what will allow you to have a global vision of what you are creating. Everything you make will look so clear and structured thanks to this library, that you will really get the intuition and understanding of what you are doing.

**--- Even More Tools ---**

*Scikit-learn *the most practical Machine Learning library. We will mainly use it:

to evaluate the performance of our models with the most relevant technique, k-Fold Cross Validation

to improve our models with effective Parameter Tuning

to preprocess our data, so that our models can learn in the best conditions

And of course, we have to mention the usual suspects. This whole course is based on Python and in every single section you will be getting hours and hours of invaluable hands-on practical coding experience.

Plus, throughout the course we will be using Numpy to do high computations and manipulate high dimensional arrays, Matplotlib to plot insightful charts and Pandas to import and manipulate datasets the most efficiently.

**--- Who Is This Course For? ---**

As you can see, there are lots of different tools in the space of Deep Learning and in this course we make sure to show you the most important and most progressive ones so that when you're done with Deep Learning A-Z your skills are on the cutting edge of today's technology.

**If you are just starting out into Deep Learning, **then you will find this course extremely useful. Deep Learning A-Z is structured around special coding blueprint approaches meaning that you won't get bogged down in unnecessary programming or mathematical complexities and instead you will be applying Deep Learning techniques from very early on in the course. You will build your knowledge from the ground up and you will see how with every tutorial you are getting more and more confident.

**If you already have experience with Deep Learning, **you will find this course refreshing, inspiring and very practical. Inside Deep Learning A-Z you will master some of the most cutting-edge Deep Learning algorithms and techniques (some of which didn't even exist a year ago) and through this course you will gain an immense amount of valuable hands-on experience with real-world business challenges. Plus, inside you will find inspiration to explore new Deep Learning skills and applications.

**--- Real-World Case Studies ---**

Mastering Deep Learning is not just about knowing the intuition and tools, it's also about being able to apply these models to real-world scenarios and derive actual measurable results for the business or project. That's why in this course we are introducing six exciting challenges:

**#1 Churn Modelling Problem**

In this part you will be solving a data analytics challenge for a bank. You will be given a dataset with a large sample of the bank's customers. To make this dataset, the bank gathered information such as customer id, credit score, gender, age, tenure, balance, if the customer is active, has a credit card, etc. During a period of 6 months, the bank observed if these customers left or stayed in the bank.

Your goal is to make an Artificial Neural Network that can predict, based on geo-demographical and transactional information given above, if any individual customer will leave the bank or stay (customer churn). Besides, you are asked to rank all the customers of the bank, based on their probability of leaving. To do that, you will need to use the right Deep Learning model, one that is based on a probabilistic approach.

If you succeed in this project, you will create significant added value to the bank. By applying your Deep Learning model the bank may significantly reduce customer churn.

**#2 Image Recognition**

In this part, you will create a Convolutional Neural Network that is able to detect various objects in images. We will implement this Deep Learning model to recognize a cat or a dog in a set of pictures. However, this model can be reused to detect anything else and we will show you how to do it - by simply changing the pictures in the input folder.

For example, you will be able to train the same model on a set of brain images, to detect if they contain a tumor or not. But if you want to keep it fitted to cats and dogs, then you will literally be able to a take a picture of your cat or your dog, and your model will predict which pet you have. We even tested it out on Hadelin’s dog!

**#3 Stock Price Prediction**

In this part, you will create one of the most powerful Deep Learning models. We will even go as far as saying that you will create the Deep Learning model closest to *“Artificial Intelligence”*. Why is that? Because this model will have long-term memory, just like us, humans.

The branch of Deep Learning which facilitates this is Recurrent Neural Networks. Classic RNNs have short memory, and were neither popular nor powerful for this exact reason. But a recent major improvement in Recurrent Neural Networks gave rise to the popularity of LSTMs (Long Short Term Memory RNNs) which has completely changed the playing field. We are extremely excited to include these cutting-edge deep learning methods in our course!

In this part you will learn how to implement this ultra-powerful model, and we will take the challenge to use it to predict the real Google stock price. A similar challenge has already been faced by researchers at Stanford University and we will aim to do at least as good as them.

** #4 Fraud Detection**

According to a recent report published by Markets & Markets the Fraud Detection and Prevention Market is going to be worth $33.19 Billion USD by 2021. This is a huge industry and the demand for advanced Deep Learning skills is only going to grow. That’s why we have included this case study in the course.

This is the first part of Volume 2 - Unsupervised Deep Learning Models. The business challenge here is about detecting fraud in credit card applications. You will be creating a Deep Learning model for a bank and you are given a dataset that contains information on customers applying for an advanced credit card.

This is the data that customers provided when filling the application form. Your task is to detect potential fraud within these applications. That means that by the end of the challenge, you will literally come up with an explicit list of customers who potentially cheated on their applications.

**#5 & 6 Recommender Systems**

From Amazon product suggestions to Netflix movie recommendations - good recommender systems are very valuable in today's World. And specialists who can create them are some of the top-paid Data Scientists on the planet.

We will work on a dataset that has exactly the same features as the Netflix dataset: plenty of movies, thousands of users, who have rated the movies they watched. The ratings go from 1 to 5, exactly like in the Netflix dataset, which makes the Recommender System more complex to build than if the ratings were simply “Liked” or “Not Liked”.

Your final Recommender System will be able to predict the ratings of the movies the customers didn’t watch. Accordingly, by ranking the predictions from 5 down to 1, your Deep Learning model will be able to recommend which movies each user should watch. Creating such a powerful Recommender System is quite a challenge so we will give ourselves two shots. Meaning we will build it with two different Deep Learning models.

Our first model will be Deep Belief Networks, complex Boltzmann Machines that will be covered in Part 5. Then our second model will be with the powerful AutoEncoders, my personal favorites. You will appreciate the contrast between their simplicity, and what they are capable of.

And you will even be able to apply it to yourself or your friends. The list of movies will be explicit so you will simply need to rate the movies you already watched, input your ratings in the dataset, execute your model and voila! The Recommender System will tell you exactly which movies you would love one night you if are out of ideas of what to watch on Netflix!

**--- Summary ---**

In conclusion, this is an exciting training program filled with intuition tutorials, practical exercises and real-World case studies.

We are super enthusiastic about Deep Learning and hope to see you inside the class!

Kirill & Hadelin

- Welcome to the course!
- Welcome Challenge!
- What is Deep Learning?
- Get the Datasets and slides here
- EXTRA: Use ChatGPT to Boost your Deep Learning Skills
- --------------------- Part 1 - Artificial Neural Networks ---------------------
- Welcome to Part 1 - Artificial Neural Networks
- ANN Intuition
- What You'll Need for ANN
- Plan of Attack
- The Neuron
- The Activation Function
- How do Neural Networks work?
- How do Neural Networks learn?
- Gradient Descent
- Stochastic Gradient Descent
- Backpropagation
- Building an ANN
- Business Problem Description
- IMPORTANT NOTE
- Building an ANN - Step 1
- Check out our free course on ANN for Regression
- Building an ANN - Step 2
- Building an ANN - Step 3
- Building an ANN - Step 4
- Building an ANN - Step 5
- -------------------- Part 2 - Convolutional Neural Networks --------------------
- Welcome to Part 2 - Convolutional Neural Networks
- CNN Intuition
- What You'll Need for CNN
- Plan of attack
- What are convolutional neural networks?
- Step 1 - Convolution Operation
- Step 1(b) - ReLU Layer
- Step 2 - Pooling
- Step 3 - Flattening
- Step 4 - Full Connection
- Summary
- Softmax & Cross-Entropy
- Building a CNN
- IMPORTANT NOTE
- Building a CNN - Step 1
- Building a CNN - Step 2
- Building a CNN - Step 3
- Building a CNN - Step 4
- Building a CNN - Step 5
- Quick Note
- Building a CNN - FINAL DEMO!
- ---------------------- Part 3 - Recurrent Neural Networks ----------------------
- Welcome to Part 3 - Recurrent Neural Networks
- RNN Intuition
- What You'll Need for RNN
- Plan of attack
- The idea behind Recurrent Neural Networks
- The Vanishing Gradient Problem
- LSTMs
- Practical intuition
- EXTRA: LSTM Variations
- Building a RNN
- IMPORTANT NOTE
- Building a RNN - Step 1
- Building a RNN - Step 2
- Building a RNN - Step 3
- Building a RNN - Step 4
- Building a RNN - Step 5
- Building a RNN - Step 6
- Building a RNN - Step 7
- Building a RNN - Step 8
- Building a RNN - Step 9
- Building a RNN - Step 10
- Building a RNN - Step 11
- Building a RNN - Step 12
- Building a RNN - Step 13
- Building a RNN - Step 14
- Building a RNN - Step 15
- Evaluating and Improving the RNN
- Evaluating the RNN
- Improving the RNN
- ------------------------ Part 4 - Self Organizing Maps ------------------------
- Welcome to Part 4 - Self Organizing Maps
- SOMs Intuition
- Plan of attack
- How do Self-Organizing Maps Work?
- Why revisit K-Means?
- K-Means Clustering (Refresher)
- How do Self-Organizing Maps Learn? (Part 1)
- How do Self-Organizing Maps Learn? (Part 2)
- Live SOM example
- Reading an Advanced SOM
- EXTRA: K-means Clustering (part 2)
- EXTRA: K-means Clustering (part 3)
- Building a SOM
- How to get the dataset
- Building a SOM - Step 1
- Building a SOM - Step 2
- Building a SOM - Step 3
- Building a SOM - Step 4
- Mega Case Study
- Mega Case Study - Step 1
- Mega Case Study - Step 2
- Mega Case Study - Step 3
- Mega Case Study - Step 4
- ------------------------- Part 5 - Boltzmann Machines -------------------------
- Welcome to Part 5 - Boltzmann Machines
- Boltzmann Machine Intuition
- Plan of attack
- Boltzmann Machine
- Energy-Based Models (EBM)
- Editing Wikipedia - Our Contribution to the World
- Restricted Boltzmann Machine
- Contrastive Divergence
- Deep Belief Networks
- Deep Boltzmann Machines
- Building a Boltzmann Machine
- How to get the dataset
- Installing PyTorch
- Building a Boltzmann Machine - Introduction
- Same Data Preprocessing in Parts 5 and 6
- Building a Boltzmann Machine - Step 1
- Building a Boltzmann Machine - Step 2
- Building a Boltzmann Machine - Step 3
- Building a Boltzmann Machine - Step 4
- Building a Boltzmann Machine - Step 5
- Building a Boltzmann Machine - Step 6
- Building a Boltzmann Machine - Step 7
- Building a Boltzmann Machine - Step 8
- Building a Boltzmann Machine - Step 9
- Building a Boltzmann Machine - Step 10
- Building a Boltzmann Machine - Step 11
- Building a Boltzmann Machine - Step 12
- Building a Boltzmann Machine - Step 13
- Building a Boltzmann Machine - Step 14
- Evaluating the Boltzmann Machine
- ---------------------------- Part 6 - AutoEncoders ----------------------------
- Welcome to Part 6 - AutoEncoders
- AutoEncoders Intuition
- Plan of attack
- Auto Encoders
- A Note on Biases
- Training an Auto Encoder
- Overcomplete hidden layers
- Sparse Autoencoders
- Denoising Autoencoders
- Contractive Autoencoders
- Stacked Autoencoders
- Deep Autoencoders
- Building an AutoEncoder
- How to get the dataset
- Installing PyTorch
- Same Data Preprocessing in Parts 5 and 6
- Building an AutoEncoder - Step 1
- Building an AutoEncoder - Step 2
- Building an AutoEncoder - Step 3
- Homework Challenge - Coding Exercise
- Building an AutoEncoder - Step 4
- Building an AutoEncoder - Step 5
- Building an AutoEncoder - Step 6
- Building an AutoEncoder - Step 7
- Building an AutoEncoder - Step 8
- Building an AutoEncoder - Step 9
- Building an AutoEncoder - Step 10
- Building an AutoEncoder - Step 11
- THANK YOU Video
- ------------------- Annex - Get the Machine Learning Basics -------------------
- Annex - Get the Machine Learning Basics
- Regression & Classification Intuition
- What You Need for Regression & Classification
- Simple Linear Regression Intuition - Step 1
- Simple Linear Regression Intuition - Step 2
- Multiple Linear Regression Intuition
- Logistic Regression Intuition
- Data Preprocessing
- Data Preprocessing
- The Machine Learning process
- Splitting the data into a Training and Test set
- Feature Scaling
- Data Preprocessing in Python
- Getting Started - Step 1
- Getting Started - Step 2
- Importing the Libraries
- Importing the Dataset - Step 1
- Importing the Dataset - Step 2
- Importing the Dataset - Step 3
- For Python learners, summary of Object-oriented programming: classes & objects
- Taking care of Missing Data - Step 1
- Taking care of Missing Data - Step 2
- Encoding Categorical Data - Step 1
- Encoding Categorical Data - Step 2
- Encoding Categorical Data - Step 3
- Splitting the dataset into the Training set and Test set - Step 1
- Splitting the dataset into the Training set and Test set - Step 2
- Splitting the dataset into the Training set and Test set - Step 3
- Feature Scaling - Step 1
- Feature Scaling - Step 2
- Feature Scaling - Step 3
- Feature Scaling - Step 4
- Logistic Regression
- Logistic Regression Intuition
- Maximum Likelihood
- Logistic Regression in Python - Step 1a

Master deep learning in PyTorch using an experimental scientific approach, with lots of examples and practice problems.

- Ratings
- 4.72
- Subscribers
- 35,539
- Subscribers last month

(August 2024) - 840
- Level
- beginner
- Video Duration
- 57 hours 18 minutes
- Created
- Aug 4th, 2021
- Last updated
- Aug 31st, 2024
- Price
- $119.99

**Deep learning is increasingly dominating technology and has major implications for society.**

From self-driving cars to medical diagnoses, from face recognition to deep fakes, and from language translation to music generation, deep learning is spreading like wildfire throughout all areas of modern technology.

But deep learning is not only about super-fancy, cutting-edge, highly sophisticated applications. Deep learning is increasingly becoming a standard tool in machine-learning, data science, and statistics. Deep learning is used by small startups for data mining and dimension reduction, by governments for detecting tax evasion, and by scientists for detecting patterns in their research data.

Deep learning is now used in most areas of technology, business, and entertainment. And it's becoming more important every year.

**How does deep learning work?**

Deep learning is built on a really simple principle: Take a super-simple algorithm (weighted sum and nonlinearity), and repeat it many many times until the result is an incredibly complex and sophisticated learned representation of the data.

*Is it really that simple?* mmm OK, it's actually a tiny bit more complicated than that ;) but that's the core idea, and everything else -- literally everything else in deep learning -- is just clever ways of putting together these fundamental building blocks. That doesn't mean the deep neural networks are trivial to understand: there are important architectural differences between feedforward networks, convolutional networks, and recurrent networks.

Given the diversity of deep learning model designs, parameters, and applications, you can only learn deep learning -- I mean, *really* learn deep learning, not just have superficial knowledge from a youtube video -- by having an experienced teacher guide you through the math, implementations, and reasoning. And of course, you need to have lots of hands-on examples and practice problems to work through. Deep learning is basically just applied math, and, as everyone knows, math is not a spectator sport!

**What is this course all about?**

Simply put: The purpose of this course is to provide a deep-dive into deep learning. You will gain flexible, fundamental, and lasting expertise on deep learning. You will have a deep understanding of the fundamental concepts in deep learning, so that you will be able to learn new topics and trends that emerge in the future.

Please note: This is not a course for someone who wants a quick overview of deep learning with a few solved examples. Instead, this course is designed for people who really want to understand how and why deep learning works; when and how to select metaparameters like optimizers, normalizations, and learning rates; how to evaluate the performance of deep neural network models; and how to modify and adapt existing models to solve new problems.

**You can learn everything about deep learning in this course.**

In this course, you will learn

*Theory*: Why are deep learning models built the way they are?*Math*: What are the formulas and mechanisms of deep learning?*Implementation*: How are deep learning models actually constructed in Python (using the PyTorch library)?*Intuition*: Why is this or that metaparameter the right choice? How to interpret the effects of regularization? etc.*Python*: If you're completely new to Python, go through the 8+ hour coding tutorial appendix. If you're already a knowledgeable coder, then you'll still learn some new tricks and code optimizations.*Google-colab*: Colab is an amazing online tool for running Python code, simulations, and heavy computations using Google's cloud services. No need to install anything on your computer.

**Unique aspects of this course**

Clear and comprehensible explanations of concepts in deep learning, including transfer learning, generative modeling, convolutional neural networks, feedforward networks, generative adversarial networks (GAN), and more.

Several distinct explanations of the same ideas, which is a proven technique for learning.

Visualizations using graphs, numbers, and spaces that provide intuition of artificial neural networks.

*LOTS*of exercises, projects, code-challenges, suggestions for exploring the code. You learn best by doing it yourself!Active Q&A forum where you can ask questions, get feedback, and contribute to the community.

8+ hour Python tutorial. That means you don't need to master Python before enrolling in this course.

**So what are you waiting for??**

Watch the course introductory video and free sample videos to learn more about the contents of this course and about my teaching style. If you are unsure if this course is right for you and want to learn more, feel free to contact with me questions before you sign up.

I hope to see you soon in the course!

Mike

- Introduction
- How to learn from this course
- Using Udemy like a pro
- Download all course materials
- Downloading and using the code
- My policy on code-sharing
- Concepts in deep learning
- What is an artificial neural network?
- How models "learn"
- The role of DL in science and knowledge
- Running experiments to understand DL
- Are artificial "neurons" like biological neurons?
- About the Python tutorial
- Should you watch the Python tutorial?
- Math, numpy, PyTorch
- PyTorch or TensorFlow?
- Introduction to this section
- Spectral theories in mathematics
- Terms and datatypes in math and computers
- Converting reality to numbers
- Vector and matrix transpose
- OMG it's the dot product!
- Matrix multiplication
- Softmax
- Logarithms
- Entropy and cross-entropy
- Min/max and argmin/argmax
- Mean and variance
- Random sampling and sampling variability
- Reproducible randomness via seeding
- The t-test
- Derivatives: intuition and polynomials
- Derivatives find minima
- Derivatives: product and chain rules
- Gradient descent
- Overview of gradient descent
- What about local minima?
- Gradient descent in 1D
- CodeChallenge: unfortunate starting value
- Gradient descent in 2D
- CodeChallenge: 2D gradient ascent
- Parametric experiments on g.d.
- CodeChallenge: fixed vs. dynamic learning rate
- Vanishing and exploding gradients
- Tangent: Notebook revision history
- ANNs (Artificial Neural Networks)
- The perceptron and ANN architecture
- A geometric view of ANNs
- ANN math part 1 (forward prop)
- ANN math part 2 (errors, loss, cost)
- ANN math part 3 (backprop)
- ANN for regression
- CodeChallenge: manipulate regression slopes
- ANN for classifying qwerties
- Learning rates comparison
- Multilayer ANN
- Linear solutions to linear problems
- Why multilayer linear models don't exist
- Multi-output ANN (iris dataset)
- CodeChallenge: more qwerties!
- Comparing the number of hidden units
- Depth vs. breadth: number of parameters
- Defining models using sequential vs. class
- Model depth vs. breadth
- CodeChallenge: convert sequential to class
- Diversity of ANN visual representations
- Reflection: Are DL models understandable yet?
- Overfitting and cross-validation
- What is overfitting and is it as bad as they say?
- Cross-validation
- Generalization
- Cross-validation -- manual separation
- Cross-validation -- scikitlearn
- Cross-validation -- DataLoader
- Splitting data into train, devset, test
- Cross-validation on regression
- Regularization
- Regularization: Concept and methods
- train() and eval() modes
- Dropout regularization
- Dropout regularization in practice
- Dropout example 2
- Weight regularization (L1/L2): math
- L2 regularization in practice
- L1 regularization in practice
- Training in mini-batches
- Batch training in action
- The importance of equal batch sizes
- CodeChallenge: Effects of mini-batch size
- Metaparameters (activations, optimizers)
- What are "metaparameters"?
- The "wine quality" dataset
- CodeChallenge: Minibatch size in the wine dataset
- Data normalization
- The importance of data normalization
- Batch normalization
- Batch normalization in practice
- CodeChallenge: Batch-normalize the qwerties
- Activation functions
- Activation functions in PyTorch
- Activation functions comparison
- CodeChallenge: Compare relu variants
- CodeChallenge: Predict sugar
- Loss functions
- Loss functions in PyTorch
- More practice with multioutput ANNs
- Optimizers (minibatch, momentum)
- SGD with momentum
- Optimizers (RMSprop, Adam)
- Optimizers comparison
- CodeChallenge: Optimizers and... something
- CodeChallenge: Adam with L2 regularization
- Learning rate decay
- How to pick the right metaparameters
- FFNs (Feed-Forward Networks)
- What are fully-connected and feedforward networks?
- The MNIST dataset
- FFN to classify digits
- CodeChallenge: Binarized MNIST images
- CodeChallenge: Data normalization
- Distributions of weights pre- and post-learning
- CodeChallenge: MNIST and breadth vs. depth
- CodeChallenge: Optimizers and MNIST
- Scrambled MNIST
- Shifted MNIST
- CodeChallenge: The mystery of the missing 7
- Universal approximation theorem
- More on data
- Anatomy of a torch dataset and dataloader
- Data size and network size
- CodeChallenge: unbalanced data
- What to do about unbalanced designs?
- Data oversampling in MNIST
- Data noise augmentation (with devset+test)
- Data feature augmentation
- Getting data into colab
- Save and load trained models
- Save the best-performing model
- Where to find online datasets
- Measuring model performance
- Two perspectives of the world
- Accuracy, precision, recall, F1
- APRF in code
- APRF example 1: wine quality
- APRF example 2: MNIST
- CodeChallenge: MNIST with unequal groups
- Computation time
- Better performance in test than train?
- FFN milestone projects
- Project 1: A gratuitously complex adding machine
- Project 1: My solution
- Project 2: Predicting heart disease
- Project 2: My solution
- Project 3: FFN for missing data interpolation
- Project 3: My solution
- Weight inits and investigations
- Explanation of weight matrix sizes
- A surprising demo of weight initializations
- Theory: Why and how to initialize weights
- CodeChallenge: Weight variance inits
- Xavier and Kaiming initializations
- CodeChallenge: Xavier vs. Kaiming
- CodeChallenge: Identically random weights
- Freezing weights during learning
- Learning-related changes in weights
- Use default inits or apply your own?
- Autoencoders
- What are autoencoders and what do they do?
- Denoising MNIST
- CodeChallenge: How many units?
- AEs for occlusion
- The latent code of MNIST
- Autoencoder with tied weights
- Running models on a GPU
- What is a GPU and why use it?
- Implementation
- CodeChallenge: Run an experiment on the GPU
- Convolution and transformations
- Convolution: concepts
- Feature maps and convolution kernels
- Convolution in code
- Convolution parameters (stride, padding)
- The Conv2 class in PyTorch
- CodeChallenge: Choose the parameters
- Transpose convolution
- Max/mean pooling
- Pooling in PyTorch
- To pool or to stride?
- Image transforms
- Creating and using custom DataLoaders
- Understand and design CNNs
- The canonical CNN architecture
- CNN to classify MNIST digits
- CNN on shifted MNIST
- Classify Gaussian blurs
- Examine feature map activations
- CodeChallenge: Softcode internal parameters
- CodeChallenge: How wide the FC?
- Do autoencoders clean Gaussians?
- CodeChallenge: AEs and occluded Gaussians

How Agents Can Learn In Environments With No Rewards

- Ratings
- 4.7
- Subscribers
- 1,432
- Subscribers last month

(August 2024) - -
- Level
- expert
- Video Duration
- 4 hours 9 minutes
- Created
- Oct 3rd, 2021
- Last updated
- Jul 9th, 2023
- Price
- $54.99

If reinforcement learning is to serve as a viable path to artificial general intelligence, it must learn to cope with environments with sparse or totally absent rewards. Most real life systems provided rewards that only occur after many time steps, leaving the agent with little information to build a successful policy on. Curiosity based reinforcement learning solves this problem by giving the agent an innate sense of curiosity about its world, enabling it to explore and learn successful policies for navigating the world.

In this advanced course on deep reinforcement learning, motivated students will learn how to implement cutting edge artificial intelligence research papers from scratch. This is a fast paced course for those that are experienced in coding up actor critic agents on their own. We'll code up two papers in this course, using the popular PyTorch framework.

The first paper covers asynchronous methods for deep reinforcement learning; also known as the popular **asynchronous advantage actor critic algorithm (A3C)**. Here students will discover a new framework for learning that doesn't require a GPU. We will learn how to implement multithreading in Python and use that to train multiple actor critic agents in parallel. We will go beyond the basic implementation from the paper and implement a recent improvement to reinforcement learning known as **generalized advantage estimation**. We will test our agents in the Pong environment from the **Open AI Gym's Atari library, **and achieve nearly world class performance in just a few hours.

From there, we move on to the heart of the course: learning in environments with sparse or totally absent rewards. This new paradigm leverages the agent's curiosity about the environment as an intrinsic reward that motivates the agent to explore and learn generalizable skills. We'll implement the **intrinsic curiosity module (ICM), **which is a bolt-on module for any deep reinforcement learning algorithm. We will train and test our agent in an maze like environment that only yields rewards when the agent reaches the objective. A clear performance gain over the vanilla A3C algorithm will be demonstrated, conclusively showing the power of curiosity driven deep reinforcement learning.

Please keep in mind this is a **fast paced course for motivated and advanced students**. There will be only a very brief review of the fundamental concepts of reinforcement learning and actor critic methods, and from there we will jump right into reading and implementing papers.

The beauty of both the ICM and asynchronous methods is that these paradigms can be applied to nearly any other reinforcement learning algorithm. Both are highly adaptable and can be plugged in with little modification to algorithms like proximal policy optimization, soft actor critic, or deep Q learning.

Students will learn how to:

Implement deep reinforcement learning papers

Leverage multi core CPUs with parallel processing in Python

Code the A3C algorithm from scratch

Code the ICM from first principles

Code generalized advantage estimation

Modify the Open AI Gym Atari Library

Write extensible modular code

This course is launching with the PyTorch implementation, with a Tensorflow 2 version coming.

I'll see you on the inside.

- Introduction
- What You Will Learn in this Course
- How to Succeed in this Course
- Required Background, Software, and Hardware
- Fundamental Concepts
- A Brief Review of Deep Reinforcement Learning and Actor Critic Methods
- Code Review of Basic Actor Critic Agent
- A Crash Course in Asynchronous Advantage Actor Critic Methods
- Our Code Structure
- Paper Analysis: Asynchronous Methods for Deep Reinforcement Learning
- How to Read and Implement Research Papers
- A3C Paper: Abstract and Introduction
- Crash Course in Parallel Processing in Python
- A3C Paper: Related Work, Reinforcement Learning Background
- A3C Paper: The Asynchronous Reinforcement Learning Framework
- Coding our Actor Critic Network
- Learning with Generalized Advantage Estimation
- Coding a Minimalist Replay Memory
- Coding the Shared Adam Optimizer
- A3C Paper: Experiments and Discussion
- How to Modify the Open AI Gym Atari Environments
- Coding Our Main Loop and Evaluating Our Agent
- Paper Analysis: Curiosity Driven Exploration by Self Supervised Prediction
- Paper Overview
- ICM Paper: Abstract and Introduction
- ICM Paper: Curiosity Driven Exploration
- Experimental Setup and Coding Our ICM Module
- ICM Paper: Experiments, Related Work, and Discussion
- Setting Up the Mini World and Training Our ICM Agent
- Appendix
- Setting Up Our Virtual Environment for the New Open AI Gym
- Making Our Agents Compliant with the New Gym Interface

## 3. Top 3 Recommended YouTube Videos

Here are Outlecture's top 3 recommended YouTube videos, carefully selected for you.

Title | View count | View count last month (August 2024) | Like count | Publish date |
---|---|---|---|---|

AI vs Machine Learning Channel: IBM Technology | 1,094,331 | 39,941 | 32,873 | Apr 10th, 2023 |

TensorFlow in 100 Seconds Channel: Fireship | 945,475 | 19,464 | 44,494 | Aug 3rd, 2022 |

PyTorch in 100 Seconds Channel: Fireship | 907,278 | 25,615 | 34,915 | Mar 20th, 2023 |

YouTube has become a familiar platform for everyday use, where viewers can watch videos for free, although they may contain advertisements. Recently, there has been an increase in the availability of high-quality educational materials on this platform.
It is an excellent option for those who want to learn without paying or simply obtaining a quick understanding of a topic.

We highly recommend utilizing YouTube as a valuable learning resource.

Recommended for

- Wanting to learn without spending money
- Wanting to quickly understand the overview of Deep Learning

The details of each course are as follows:

IBM Technology

- View count
- 1,094,331
- View count last month

(August 2024) - 39,941
- Like count
- 32,873
- Publish date
- Apr 10th, 2023

What is really the difference between Artificial intelligence (AI) and machine learning (ML)? Are they actually the same thing? In this video, Jeff Crume explains the differences and relationship between AI & ML, as well as how related topics like Deep Learning (DL) and other types and properties of each.

#ai #ml #dl #artificialintelligence #machinelearning #deeplearning #watsonx

Fireship

- View count
- 945,475
- View count last month

(August 2024) - 19,464
- Like count
- 44,494
- Publish date
- Aug 3rd, 2022

#programming #deeplearning #100secondsofcode

🔗 Resources

TensorFlow Docs https://www.tensorflow.org/

Fashion MNIST Tutorial https://www.tensorflow.org/tutorials/keras/classification

Neural Networks Overview for Data Scientists https://www.ibm.com/cloud/learn/neural-networks

Machine Learning in 100 Seconds https://youtu.be/PeMlggyqz0Y

🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro

Use code lORhwXd2 for 25% off your first payment.

🎨 My Editor Settings

- Atom One Dark

- vscode-icons

- Fira Code Font

🔖 Topics Covered

- What is TensorFlow?

- How to build a neural network with TensorFlow

- What is TensorFlow used for?

- Who created TensorFlow?

- How neural networks work

- Easy neural network tutorial

- What is a mathematical Tensor?

Fireship

- View count
- 907,278
- View count last month

(August 2024) - 25,615
- Like count
- 34,915
- Publish date
- Mar 20th, 2023

#ai #python #100SecondsOfCode

💬 Chat with Me on Discord

https://discord.gg/fireship

🔗 Resources

PyTorch Docs https://pytorch.org

Tensorflow in 100 Seconds

Python in 100 Seconds https://youtu.be/x7X9w_GIm1s

🔥 Get More Content - Upgrade to PRO

Upgrade at https://fireship.io/pro

Use code YT25 for 25% off PRO access

🎨 My Editor Settings

- Atom One Dark

- vscode-icons

- Fira Code Font

🔖 Topics Covered

- What is PyTorch?

- PyTorch vs Tensorflow

- Build a basic neural network with PyTorch

- PyTorch 2 basics tutorial

- What is a tensor?

- Which AI products use PyTorch?

## 5. Wrap-up

We introduced recommended courses for Deep Learning. If you are interested in learning other related courses, please refer to the following.

If you want to further explore and learn after taking one of the courses we introduced today, we recommend visiting the official website or community site.

If you want to stay up-to-date on the latest information, we suggest following the official Twitter account.

Furthermore, We highly recommend utilizing General AI such as ChatGPT as a study aid. This can enable more effective learning, so please give it a try.

We hope you found our website and article helpful. Thank you for visiting.