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

Unlock the Power of Machine Learning & AI: Master the Art of Turning Data into Insight

Discover the Future of Technology with Our Comprehensive Machine Learning & AI Course - Featuring Generative AI, Deep Learning, and Beyond!

In an era where Machine Learning (ML) and Artificial Intelligence (AI) are revolutionizing industries across the globe, understanding how giants like Google, Amazon, and Udemy leverage these technologies to extract meaningful insights from vast data sets is more critical than ever. Whether you're aiming to join the ranks of top-tier AI specialists—with an average salary of $159,000 as reported by Glassdoor—or you're driven by the fascinating challenges this field offers, our course is your gateway to an exciting new career trajectory.

Designed for individuals with programming or scripting backgrounds, this course goes beyond the basics, preparing you to stand out in the competitive tech industry. Our curriculum, enriched with over 145 lectures and 20+ hours of video content, is crafted to provide hands-on experience with Python, guiding you from the fundamentals of statistics to the cutting-edge advancements in generative AI.

Why Choose This Course?

• Updated Content on Generative AI: Dive into the latest in AI with modules on transformers, GPT, ChatGPT, the OpenAI API, Advanced Retrieval Augmented Generation (RAG), LLM agents, langchain, and self-attention based neural networks.

• Real-World Application: Learn through Python code examples based on real-life scenarios, making the abstract concepts of ML and AI tangible and actionable.

• Industry-Relevant Skills: Our curriculum is designed based on the analysis of job listings from top tech firms, ensuring you gain the skills most sought after by employers.

• Diverse Topics Covered: From neural networks, TensorFlow, and Keras to sentiment analysis and image recognition, our course covers a wide range of ML models and techniques, ensuring a well-rounded education.

• Accessible Learning: Complex concepts are explained in plain English, focusing on practical application rather than academic jargon, making the learning process straightforward and engaging.

Course Highlights:

• Introduction to Python and basic statistics, setting a strong foundation for your journey in ML and AI.

• Deep Learning techniques, including MLPs, CNNs, and RNNs, with practical exercises in TensorFlow and Keras.

• Extensive modules on the mechanics of modern generative AI, including transformers and the OpenAI API, with hands-on projects like fine-tuning GPT, Advanced RAG, langchain, and LLM agents.

• A comprehensive overview of machine learning models beyond GenAI, including SVMs, reinforcement learning, decision trees, and more, ensuring you have a broad understanding of the field.

• Practical data science applications, such as data visualization, regression analysis, clustering, and feature engineering, empowering you to tackle real-world data challenges.

• A special section on Apache Spark, enabling you to apply these techniques to big data, analyzed on computing clusters.

No previous Python experience? No problem! We kickstart your journey with a Python crash course to ensure you're well-equipped to tackle the modules that follow.

Transform Your Career Today

Join a community of learners who have successfully transitioned into the tech industry, leveraging the knowledge and skills acquired from our course to excel in corporate and research roles in AI and ML.

"I started doing your course... and it was pivotal in helping me transition into a role where I now solve corporate problems using AI. Your course demystified how to succeed in corporate AI research, making you the most impressive instructor in ML I've encountered." - Kanad Basu, PhD

Are you ready to step into the future of technology and make a mark in the fields of machine learning and artificial intelligence? Enroll now and embark on a journey that transforms data into powerful insights, paving your way to a rewarding career in AI and ML.

1. Getting Started
2. Introduction
3. Udemy 101: Getting the Most From This Course
4. Important note
5. Installation: Getting Started
6. [Activity] WINDOWS: Installing and Using Anaconda & Course Materials
7. [Activity] MAC: Installing and Using Anaconda & Course Materials
8. [Activity] LINUX: Installing and Using Anaconda & Course Materials
9. Python Basics, Part 1 [Optional]
10. [Activity] Python Basics, Part 2 [Optional]
11. [Activity] Python Basics, Part 3 [Optional]
12. [Activity] Python Basics, Part 4 [Optional]
13. Introducing the Pandas Library [Optional]
14. Statistics and Probability Refresher, and Python Practice
15. Types of Data (Numerical, Categorical, Ordinal)
16. Mean, Median, Mode
17. [Activity] Using mean, median, and mode in Python
18. [Activity] Variation and Standard Deviation
19. Probability Density Function; Probability Mass Function
20. Common Data Distributions (Normal, Binomial, Poisson, etc)
21. [Activity] Percentiles and Moments
22. [Activity] A Crash Course in matplotlib
23. [Activity] Advanced Visualization with Seaborn
24. [Activity] Covariance and Correlation
25. [Exercise] Conditional Probability
26. Exercise Solution: Conditional Probability of Purchase by Age
27. Bayes' Theorem
28. Predictive Models
29. [Activity] Linear Regression
30. [Activity] Polynomial Regression
31. [Activity] Multiple Regression, and Predicting Car Prices
32. Multi-Level Models
33. Machine Learning with Python
34. Supervised vs. Unsupervised Learning, and Train/Test
35. [Activity] Using Train/Test to Prevent Overfitting a Polynomial Regression
36. Bayesian Methods: Concepts
37. [Activity] Implementing a Spam Classifier with Naive Bayes
38. K-Means Clustering
39. [Activity] Clustering people based on income and age
40. Measuring Entropy
41. [Activity] WINDOWS: Installing Graphviz
42. [Activity] MAC: Installing Graphviz
43. [Activity] LINUX: Installing Graphviz
44. Decision Trees: Concepts
45. [Activity] Decision Trees: Predicting Hiring Decisions
46. Ensemble Learning
47. [Activity] XGBoost
48. Support Vector Machines (SVM) Overview
49. [Activity] Using SVM to cluster people using scikit-learn
50. Recommender Systems
51. User-Based Collaborative Filtering
52. Item-Based Collaborative Filtering
53. [Activity] Finding Movie Similarities using Cosine Similarity
54. [Activity] Improving the Results of Movie Similarities
55. [Activity] Making Movie Recommendations with Item-Based Collaborative Filtering
56. [Exercise] Improve the recommender's results
57. More Data Mining and Machine Learning Techniques
58. K-Nearest-Neighbors: Concepts
59. [Activity] Using KNN to predict a rating for a movie
60. Dimensionality Reduction; Principal Component Analysis (PCA)
61. [Activity] PCA Example with the Iris data set
62. Data Warehousing Overview: ETL and ELT
63. Reinforcement Learning
64. [Activity] Reinforcement Learning & Q-Learning with Gym
65. Understanding a Confusion Matrix
66. Measuring Classifiers (Precision, Recall, F1, ROC, AUC)
67. Dealing with Real-World Data
68. Bias/Variance Tradeoff
69. [Activity] K-Fold Cross-Validation to avoid overfitting
70. Data Cleaning and Normalization
71. [Activity] Cleaning web log data
72. Normalizing numerical data
73. [Activity] Detecting outliers
74. Feature Engineering and the Curse of Dimensionality
75. Imputation Techniques for Missing Data
76. Handling Unbalanced Data: Oversampling, Undersampling, and SMOTE
77. Binning, Transforming, Encoding, Scaling, and Shuffling
78. Apache Spark: Machine Learning on Big Data
79. Warning about Java 21+ and Spark 3!
80. Spark installation notes for MacOS and Linux users
81. [Activity] Installing Spark
82. Spark Introduction
83. Spark and the Resilient Distributed Dataset (RDD)
84. Introducing MLLib
85. Introduction to Decision Trees in Spark
86. [Activity] K-Means Clustering in Spark
87. TF / IDF
88. [Activity] Searching Wikipedia with Spark
89. [Activity] Using the Spark DataFrame API for MLLib
90. Experimental Design / ML in the Real World
91. Deploying Models to Real-Time Systems
92. A/B Testing Concepts
93. T-Tests and P-Values
94. [Activity] Hands-on With T-Tests
95. Determining How Long to Run an Experiment
96. A/B Test Gotchas
97. Deep Learning and Neural Networks
98. Deep Learning Pre-Requisites
99. The History of Artificial Neural Networks
100. [Activity] Deep Learning in the Tensorflow Playground
101. Deep Learning Details
102. Introducing Tensorflow
103. [Activity] Using Tensorflow, Part 1
104. [Activity] Using Tensorflow, Part 2
105. [Activity] Introducing Keras
106. [Activity] Using Keras to Predict Political Affiliations
107. Convolutional Neural Networks (CNN's)
108. [Activity] Using CNN's for handwriting recognition
109. Recurrent Neural Networks (RNN's)
110. [Activity] Using a RNN for sentiment analysis
111. [Activity] Transfer Learning
112. Tuning Neural Networks: Learning Rate and Batch Size Hyperparameters
113. Deep Learning Regularization with Dropout and Early Stopping
114. The Ethics of Deep Learning
115. Generative Models
116. Variational Auto-Encoders (VAE's) - how they work
117. Variational Auto-Encoders (VAE) - Hands-on with Fashion MNIST
118. Generative Adversarial Networks (GAN's) - How they work
119. Generative Adversarial Networks (GAN's) - Playing with some demos
120. Generative Adversarial Networks (GAN's) - Hands-on with Fashion MNIST
121. Learning More about Deep Learning
122. Generative AI: GPT, ChatGPT, Transformers, Self Attention Based Neural Networks
123. The Transformer Architecture (encoders, decoders, and self-attention.)
124. Self-Attention, Masked Self-Attention, and Multi-Headed Self Attention in depth
125. Applications of Transformers (GPT)
126. How GPT Works, Part 1: The GPT Transformer Architecture
127. How GPT Works, Part 2: Tokenization, Positional Encoding, Embedding
128. Fine Tuning / Transfer Learning with Transformers
129. [Activity] Tokenization with Google CoLab and HuggingFace
130. [Activity] Positional Encoding
131. [Activity] Masked, Multi-Headed Self Attention with BERT, BERTViz, and exBERT
132. [Activity] Using small and large GPT models within Google CoLab and HuggingFace
133. [Activity] Fine Tuning GPT with the IMDb dataset
134. From GPT to ChatGPT: Deep Reinforcement Learning, Proximal Policy Gradients
135. From GPT to ChatGPT: Reinforcement Learning from Human Feedback and Moderation
136. The OpenAI API (Developing with GPT and ChatGPT)
137. [Activity] The OpenAI Chat Completions API
138. [Activity] Using Tools and Functions in the OpenAI Chat Completion API
139. [Activity] The Images (DALL-E) API in OpenAI
140. [Activity] The Embeddings API in OpenAI: Finding similarities between words
141. The Legacy Fine-Tuning API for GPT Models in OpenAI
142. [Demo] Fine-Tuning OpenAI's Davinci Model to simulate Data from Star Trek
143. The New OpenAI Fine-Tuning API; Fine-Tuning GPT-3.5 to simulate Commander Data!
144. [Activity] The OpenAI Moderation API
145. [Activity] The OpenAI Audio API (speech to text)
146. Retrieval Augmented Generation (RAG,) Advanced RAG, and LLM Agents
147. Retrieval Augmented Generation (RAG): How it works, with some examples.
148. Demo: Using Retrieval Augmented Generation (RAG) to simulate Data from Star Trek
149. RAG Metrics: The RAG Triad, relevancy, recall, precision, accuracy, and more
150. [Activity] Evaluating our RAG-based Cdr. Data using RAGAS and langchain
151. Advanced RAG: Pre-Retrieval; chunking; semantic chunking; data extraction.
152. Advanced RAG: Query Rewriting
153. Advanced RAG: Prompt Compression, and More Tuning Opportunities
154. [Activity] Simulating Cdr. Data with Advanced RAG and langchain
155. LLM Agents and Swarms of Agents
156. [Activity] Building a Cdr. Data chatbot with LLM Agents, web search & math tools
157. Final Project
158. Your final project assignment: Mammogram Classification
159. Final project review
160. You made it!
161. More to Explore
162. Don't Forget to Leave a Rating!
163. Bonus Lecture

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!

1. Introduction
2. Course Outline
3. Join Our Online Classroom!
4. Exercise: Meet Your Classmates & Instructor
5. All Course Resources + Asking Questions + Getting Help
6. ZTM Resources
7. Deep Learning and TensorFlow Fundamentals
8. What is deep learning?
9. Why use deep learning?
10. What are neural networks?
11. Python + Machine Learning Monthly
12. What is deep learning already being used for?
13. What is and why use TensorFlow?
14. What is a Tensor?
15. What we're going to cover throughout the course
16. How to approach this course
17. Need A Refresher?
18. Creating your first tensors with TensorFlow and tf.constant()
19. Creating tensors with TensorFlow and tf.Variable()
20. Creating random tensors with TensorFlow
21. Shuffling the order of tensors
22. Creating tensors from NumPy arrays
23. Getting information from your tensors (tensor attributes)
24. Indexing and expanding tensors
25. Manipulating tensors with basic operations
26. Matrix multiplication with tensors part 1
27. Matrix multiplication with tensors part 2
28. Matrix multiplication with tensors part 3
29. Changing the datatype of tensors
30. Tensor aggregation (finding the min, max, mean & more)
31. Tensor troubleshooting example (updating tensor datatypes)
32. Finding the positional minimum and maximum of a tensor (argmin and argmax)
33. Squeezing a tensor (removing all 1-dimension axes)
34. One-hot encoding tensors
35. Trying out more tensor math operations
36. Exploring TensorFlow and NumPy's compatibility
37. Making sure our tensor operations run really fast on GPUs
38. TensorFlow Fundamentals challenge, exercises & extra-curriculum
39. Monthly Coding Challenges, Free Resources and Guides
40. LinkedIn Endorsements
41. Neural network regression with TensorFlow
42. Introduction to Neural Network Regression with TensorFlow
43. Inputs and outputs of a neural network regression model
44. Anatomy and architecture of a neural network regression model
45. Creating sample regression data (so we can model it)
46. Note: Code update for upcoming lecture(s) for TensorFlow 2.7.0+ fix
47. The major steps in modelling with TensorFlow
48. Steps in improving a model with TensorFlow part 1
49. Steps in improving a model with TensorFlow part 2
50. Steps in improving a model with TensorFlow part 3
51. Evaluating a TensorFlow model part 1 ("visualise, visualise, visualise")
52. Evaluating a TensorFlow model part 2 (the three datasets)
53. Evaluating a TensorFlow model part 3 (getting a model summary)
54. Evaluating a TensorFlow model part 4 (visualising a model's layers)
55. Evaluating a TensorFlow model part 5 (visualising a model's predictions)
56. Evaluating a TensorFlow model part 6 (common regression evaluation metrics)
57. Evaluating a TensorFlow regression model part 7 (mean absolute error)
58. Evaluating a TensorFlow regression model part 7 (mean square error)
59. Setting up TensorFlow modelling experiments part 1 (start with a simple model)
60. Setting up TensorFlow modelling experiments part 2 (increasing complexity)
61. Comparing and tracking your TensorFlow modelling experiments
62. How to save a TensorFlow model
63. How to load and use a saved TensorFlow model
64. (Optional) How to save and download files from Google Colab
65. Putting together what we've learned part 1 (preparing a dataset)
66. Putting together what we've learned part 2 (building a regression model)
67. Putting together what we've learned part 3 (improving our regression model)
68. Preprocessing data with feature scaling part 1 (what is feature scaling?)
69. Preprocessing data with feature scaling part 2 (normalising our data)
70. Preprocessing data with feature scaling part 3 (fitting a model on scaled data)
71. TensorFlow Regression challenge, exercises & extra-curriculum
72. Learning Guideline
73. Neural network classification in TensorFlow
74. Introduction to neural network classification in TensorFlow
75. Example classification problems (and their inputs and outputs)
76. Input and output tensors of classification problems
77. Typical architecture of neural network classification models with TensorFlow
78. Creating and viewing classification data to model
79. Checking the input and output shapes of our classification data
80. Building a not very good classification model with TensorFlow
81. Trying to improve our not very good classification model
82. Creating a function to view our model's not so good predictions
83. Note: Updates for TensorFlow 2.7.0
84. Make our poor classification model work for a regression dataset
85. Non-linearity part 1: Straight lines and non-straight lines
86. Non-linearity part 2: Building our first neural network with non-linearity
87. Non-linearity part 3: Upgrading our non-linear model with more layers
88. Non-linearity part 4: Modelling our non-linear data once and for all
89. Non-linearity part 5: Replicating non-linear activation functions from scratch
90. Getting great results in less time by tweaking the learning rate
91. Using the TensorFlow History object to plot a model's loss curves
92. Using callbacks to find a model's ideal learning rate
93. Training and evaluating a model with an ideal learning rate
94. Introducing more classification evaluation methods
95. Finding the accuracy of our classification model
96. Creating our first confusion matrix (to see where our model is getting confused)
97. Making our confusion matrix prettier
98. Putting things together with multi-class classification part 1: Getting the data
99. Multi-class classification part 2: Becoming one with the data
100. Multi-class classification part 3: Building a multi-class classification model
101. Multi-class classification part 4: Improving performance with normalisation
102. Multi-class classification part 5: Comparing normalised and non-normalised data
103. Multi-class classification part 6: Finding the ideal learning rate
104. Multi-class classification part 7: Evaluating our model
105. Multi-class classification part 8: Creating a confusion matrix
106. Multi-class classification part 9: Visualising random model predictions
107. What "patterns" is our model learning?
108. TensorFlow classification challenge, exercises & extra-curriculum
109. Computer Vision and Convolutional Neural Networks in TensorFlow
110. Introduction to Computer Vision with TensorFlow
111. Introduction to Convolutional Neural Networks (CNNs) with TensorFlow
112. Downloading an image dataset for our first Food Vision model
113. Becoming One With Data
114. Becoming One With Data Part 2
115. Becoming One With Data Part 3
116. Building an end to end CNN Model
117. Using a GPU to run our CNN model 5x faster
118. Trying a non-CNN model on our image data
119. Improving our non-CNN model by adding more layers
120. Breaking our CNN model down part 1: Becoming one with the data
121. Breaking our CNN model down part 2: Preparing to load our data
122. Breaking our CNN model down part 3: Loading our data with ImageDataGenerator
123. Breaking our CNN model down part 4: Building a baseline CNN model
124. Breaking our CNN model down part 5: Looking inside a Conv2D layer
125. Breaking our CNN model down part 6: Compiling and fitting our baseline CNN
126. Breaking our CNN model down part 7: Evaluating our CNN's training curves
127. Breaking our CNN model down part 8: Reducing overfitting with Max Pooling
128. Breaking our CNN model down part 9: Reducing overfitting with data augmentation
129. Breaking our CNN model down part 10: Visualizing our augmented data
130. Breaking our CNN model down part 11: Training a CNN model on augmented data
131. Breaking our CNN model down part 12: Discovering the power of shuffling data
132. Breaking our CNN model down part 13: Exploring options to improve our model
133. Downloading a custom image to make predictions on
134. Writing a helper function to load and preprocessing custom images
135. Making a prediction on a custom image with our trained CNN
136. Multi-class CNN's part 1: Becoming one with the data
137. Multi-class CNN's part 2: Preparing our data (turning it into tensors)
138. Multi-class CNN's part 3: Building a multi-class CNN model
139. Multi-class CNN's part 4: Fitting a multi-class CNN model to the data
140. Multi-class CNN's part 5: Evaluating our multi-class CNN model
141. Multi-class CNN's part 6: Trying to fix overfitting by removing layers
142. Multi-class CNN's part 7: Trying to fix overfitting with data augmentation
143. Multi-class CNN's part 8: Things you could do to improve your CNN model
144. Multi-class CNN's part 9: Making predictions with our model on custom images
145. Saving and loading our trained CNN model
146. TensorFlow computer vision and CNNs challenge, exercises & extra-curriculum
147. Transfer Learning in TensorFlow Part 1: Feature extraction
148. What is and why use transfer learning?
149. Downloading and preparing data for our first transfer learning model
150. Introducing Callbacks in TensorFlow and making a callback to track our models
151. Exploring the TensorFlow Hub website for pretrained models
152. Building and compiling a TensorFlow Hub feature extraction model
153. Blowing our previous models out of the water with transfer learning
154. Plotting the loss curves of our ResNet feature extraction model
155. Building and training a pre-trained EfficientNet model on our data
156. Different Types of Transfer Learning
157. Comparing Our Model's Results
158. TensorFlow Transfer Learning Part 1 challenge, exercises & extra-curriculum
159. Exercise: Imposter Syndrome
160. Transfer Learning in TensorFlow Part 2: Fine tuning
161. Introduction to Transfer Learning in TensorFlow Part 2: Fine-tuning
162. Importing a script full of helper functions (and saving lots of space)
163. Downloading and turning our images into a TensorFlow BatchDataset
164. Discussing the four (actually five) modelling experiments we're running
165. Comparing the TensorFlow Keras Sequential API versus the Functional API
166. Note: Fixes for EfficientNetB0 model creation + weight loading
167. Creating our first model with the TensorFlow Keras Functional API
168. Compiling and fitting our first Functional API model
169. Getting a feature vector from our trained model
170. Drilling into the concept of a feature vector (a learned representation)
171. Downloading and preparing the data for Model 1 (1 percent of training data)
172. Building a data augmentation layer to use inside our model
173. Note: Small fix for next video, for images not augmenting
174. Visualizing what happens when images pass through our data augmentation layer
175. Building Model 1 (with a data augmentation layer and 1% of training data)
176. Building Model 2 (with a data augmentation layer and 10% of training data)
177. Creating a ModelCheckpoint to save our model's weights during training
178. Fitting and evaluating Model 2 (and saving its weights using ModelCheckpoint)
179. Loading and comparing saved weights to our existing trained Model 2
180. Preparing Model 3 (our first fine-tuned model)
181. Fitting and evaluating Model 3 (our first fine-tuned model)
182. Comparing our model's results before and after fine-tuning
183. Downloading and preparing data for our biggest experiment yet (Model 4)
184. Preparing our final modelling experiment (Model 4)
185. Fine-tuning Model 4 on 100% of the training data and evaluating its results
186. Comparing our modelling experiment results in TensorBoard
187. How to view and delete previous TensorBoard experiments
188. Transfer Learning in TensorFlow Part 2 challenge, exercises and extra-curriculum
189. Transfer Learning with TensorFlow Part 3: Scaling Up
190. Introduction to Transfer Learning Part 3: Scaling Up
191. Getting helper functions ready and downloading data to model
192. Outlining the model we're going to build and building a ModelCheckpoint callback
193. Creating a data augmentation layer to use with our model
194. Creating a headless EfficientNetB0 model with data augmentation built in
195. Fitting and evaluating our biggest transfer learning model yet
196. Unfreezing some layers in our base model to prepare for fine-tuning
197. Fine-tuning our feature extraction model and evaluating its performance
198. Saving and loading our trained model
199. Downloading a pretrained model to make and evaluate predictions with
200. Making predictions with our trained model on 25,250 test samples

*** 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

 

1. Welcome to the course!
2. Welcome Challenge!
3. Introduction to Deep Learning: From Historical Context to Modern Applications
4. Get the codes, datasets and slides here
5. EXTRA: Use ChatGPT to Boost your Deep Learning Skills
6. --------------------- Part 1 - Artificial Neural Networks ---------------------
7. Welcome to Part 1 - Artificial Neural Networks
8. ANN Intuition
9. What You'll Need for ANN
10. How Neural Networks Learn: Gradient Descent and Backpropagation Explained
11. Understanding Neurons: The Building Blocks of Artificial Neural Networks
12. Understanding Activation Functions in Neural Networks: Sigmoid, ReLU, and More
13. How Do Neural Networks Work? Step-by-Step Guide to Property Valuation Example
14. How Do Neural Networks Learn? Understanding Backpropagation and Cost Functions
15. Mastering Gradient Descent: Key to Efficient Neural Network Training
16. How to Use Stochastic Gradient Descent for Deep Learning Optimization
17. Understanding Backpropagation Algorithm: Key to Optimizing Deep Learning Models
18. Building an ANN
19. Get the code and dataset ready
20. Step 1 - Data Preprocessing for Deep Learning: Preparing Neural Network Dataset
21. Check out our free course on ANN for Regression
22. Step 2 - Data Preprocessing for Neural Networks: Essential Steps and Techniques
23. Step 3 - Constructing an Artificial Neural Network: Adding Input & Hidden Layers
24. Step 4 - Compile and Train Neural Network: Optimizers, Loss Functions & Metrics
25. Step 5 - How to Make Predictions and Evaluate Neural Network Model in Python
26. -------------------- Part 2 - Convolutional Neural Networks --------------------
27. Welcome to Part 2 - Convolutional Neural Networks
28. CNN Intuition
29. What You'll Need for CNN
30. Understanding CNN Architecture: From Convolution to Fully Connected Layers
31. How Do Convolutional Neural Networks Work? Understanding CNN Architecture
32. How to Apply Convolution Filters in Neural Networks: Feature Detection Explained
33. Rectified Linear Units (ReLU) in Deep Learning: Optimizing CNN Performance
34. Understanding Spatial Invariance in CNNs: Max Pooling Explained for Beginners
35. How to Flatten Pooled Feature Maps in Convolutional Neural Networks (CNNs)
36. How Do Fully Connected Layers Work in Convolutional Neural Networks (CNNs)?
37. CNN Building Blocks: Feature Maps, ReLU, Pooling, and Fully Connected Layers
38. Understanding Softmax Activation and Cross-Entropy Loss in Deep Learning
39. Building a CNN
40. Get the code and dataset ready
41. Step 1 - Convolutional Neural Networks Explained: Image Classification Tutorial
42. Step 2 - Deep Learning Preprocessing: Scaling & Transforming Images for CNNs
43. Step 3 - Building CNN Architecture: Convolutional Layers & Max Pooling Explained
44. Step 4 - Train CNN for Image Classification: Optimize with Keras & TensorFlow
45. Step 5 - Deploying a CNN for Real-World Image Recognition
46. Develop an Image Recognition System Using Convolutional Neural Networks
47. ---------------------- Part 3 - Recurrent Neural Networks ----------------------
48. Welcome to Part 3 - Recurrent Neural Networks
49. RNN Intuition
50. What You'll Need for RNN
51. How Do Recurrent Neural Networks (RNNs) Work? Deep Learning Explained
52. What is a Recurrent Neural Network (RNN)? Deep Learning for Sequential Data
53. Understanding the Vanishing Gradient Problem in Recurrent Neural Networks (RNNs)
54. Understanding Long Short-Term Memory (LSTM) Architecture for Deep Learning
55. How LSTMs Work in Practice: Visualizing Neural Network Predictions
56. LSTM Variations: Peepholes, Combined Gates, and GRUs in Deep Learning
57. Building a RNN
58. Get the code and dataset ready
59. Step 1 - Building a Robust LSTM Neural Network for Stock Price Trend Prediction
60. Step 2 - Importing Training Data for LSTM Stock Price Prediction Model
61. Step 3 - Applying Min-Max Normalization for Time Series Data in Neural Networks
62. Step 4 - Building X_train and y_train Arrays for LSTM Time Series Forecasting
63. Step 5 - Preparing Time Series Data for LSTM Neural Network in Stock Forecasting
64. Step 6 - Create RNN Architecture: Sequential Layers vs Computational Graphs
65. Step 7 - Adding First LSTM Layer: Key Components for Stock Market Prediction
66. Step 8 - Implementing Dropout Regularization in LSTM Networks for Forecasting
67. Step 9 - Finalizing RNN Architecture: Dense Layer for Stock Price Forecasting
68. Step 10 - Compile RNN with Adam Optimizer for Stock Price Prediction in Python
69. Step 11 - Optimizing Epochs and Batch Size for LSTM Stock Price Forecasting
70. Step 12 - Visualizing LSTM Predictions: Real vs Forecasted Google Stock Prices
71. Step 13 - Preparing Historical Stock Data for LSTM Model: Scaling and Reshaping
72. Step 14 - Creating 3D Input Structure for LSTM Stock Price Prediction in Python
73. Step 15 - Visualizing LSTM Predictions: Plotting Real vs Predicted Stock Prices
74. Evaluating and Improving the RNN
75. Evaluating the RNN
76. Improving the RNN
77. ------------------------ Part 4 - Self Organizing Maps ------------------------
78. Welcome to Part 4 - Self Organizing Maps
79. SOMs Intuition
80. How Do Self-Organizing Maps Work? Understanding SOM in Deep Learning
81. Self-Organizing Maps (SOM): Unsupervised Deep Learning for Dimensionality Reduct
82. Why K-Means Clustering is Essential for Understanding Self-Organizing Maps
83. Self-Organizing Maps Tutorial: Dimensionality Reduction in Machine Learning
84. How Self-Organizing Maps (SOMs) Learn: Unsupervised Deep Learning Explained
85. How to Create a Self-Organizing Map (SOM) in DL: Step-by-Step Tutorial
86. Interpreting SOM Clusters: Unsupervised Learning Techniques for Data Analysis
87. Understanding K-Means Clustering: Intuitive Explanation with Visual Examples
88. K-Means Clustering: Avoiding the Random Initialization Trap in Machine Learning
89. How to Find the Optimal Number of Clusters in K-Means: WCSS and Elbow Method
90. Building a SOM
91. Get the code and dataset ready
92. Step 1 - Implementing Self-Organizing Maps (SOMs) for Fraud Detection in Python
93. Step 2 - SOM Weight Initialization and Training: Tutorial for Anomaly Detection
94. Step 3 - SOM Visualization Techniques: Colorbar & Markers for Outlier Detection
95. Step 4 - Catching Cheaters with SOMs: Mapping Winning Nodes to Customer Data
96. Mega Case Study
97. Get the code and dataset ready
98. Step 1 - Building a Hybrid Deep Learning Model for Credit Card Fraud Detection
99. Step 2 - Developing a Fraud Detection System Using Self-Organizing Maps
100. Step 3 - Building a Hybrid Model: From Unsupervised to Supervised Deep Learning
101. Step 4 - Implementing Fraud Detection with SOM: A Deep Learning Approach
102. ------------------------- Part 5 - Boltzmann Machines -------------------------
103. Welcome to Part 5 - Boltzmann Machines
104. Boltzmann Machine Intuition
105. Understanding Boltzmann Machines: Deep Learning Fundamentals for AI Enthusiasts
106. Boltzmann Machines vs. Neural Networks: Key Differences in Deep Learning
107. Deep Learning Fundamentals: Energy-Based Models & Their Role in Neural Networks
108. How to Edit Wikipedia: Adding Boltzmann Distribution in Deep Learning
109. How Restricted Boltzmann Machines Work: Deep Learning for Recommender Systems
110. How Energy-Based Models Work: Deep Dive into Contrastive Divergence Algorithm
111. Deep Belief Networks: Understanding RBM Stacking in Deep Learning Models
112. Deep Boltzmann Machines vs Deep Belief Networks: Key Differences Explained
113. Building a Boltzmann Machine
114. Get the code and dataset ready
115. Step 0 - Building a Movie Recommender System with RBMs: Data Preprocessing Guide
116. Same Data Preprocessing in Parts 5 and 6
117. Step 1 - Importing Movie Datasets for RBM-Based Recommender Systems in Python
118. Step 2 - Preparing Training and Test Sets for Restricted Boltzmann Machine
119. Step 3 - Preparing Data for RBM: Calculating Total Users and Movies in Python
120. Step 4 - Convert Training & Test Sets to RBM-Ready Arrays in Python
121. Step 5 - Converting NumPy Arrays to PyTorch Tensors for Deep Learning Models
122. Step 6 - RBM Data Preprocessing: Transforming Movie Ratings for Neural Networks
123. Step 7 - Implementing Restricted Boltzmann Machine Class Structure in PyTorch
124. Step 8 - RBM Hidden Layer Sampling: Bernoulli Distribution in PyTorch Tutorial
125. Step 9 - RBM Visible Node Sampling: Bernoulli Distribution in Deep Learning
126. Step 10 - RBM Training Function: Updating Weights and Biases with Gibbs Sampling
127. Step 11 - How to Set Up an RBM Model: Choosing NV, NH, and Batch Size Parameters
128. Step 12 - RBM Training Loop: Epoch Setup and Loss Function Implementation
129. Step 13 - RBM Training: Updating Weights and Biases with Contrastive Divergence
130. Step 14 - Optimizing RBM Models: From Training to Test Set Performance Analysis
131. Evaluating the Boltzmann Machine
132. ---------------------------- Part 6 - AutoEncoders ----------------------------
133. Welcome to Part 6 - AutoEncoders
134. AutoEncoders Intuition
135. Deep Learning Autoencoders: Types, Architecture, and Training Explained
136. Autoencoders in Machine Learning: Applications and Architecture Overview
137. Autoencoder Bias in Deep Learning: Improving Neural Network Performance
138. How to Train an Autoencoder: Step-by-Step Guide for Deep Learning Beginners
139. How to Use Overcomplete Hidden Layers in Autoencoders for Feature Extraction
140. Sparse Autoencoders in Deep Learning: Preventing Overfitting in Neural Networks
141. Denoising Autoencoders: Deep Learning Regularization Technique Explained
142. What are Contractive Autoencoders? Deep Learning Regularization Techniques
143. What are Stacked Autoencoders in Deep Learning? Architecture and Applications
144. Deep Autoencoders vs Stacked Autoencoders: Key Differences in Neural Networks
145. Building an AutoEncoder
146. Get the code and dataset ready
147. Same Data Preprocessing in Parts 5 and 6
148. Step 1 - Building a Movie Recommendation System with AutoEncoders: Data Import
149. Step 2 - Preparing Training and Test Sets for Autoencoder Recommendation System
150. Step 3 - Preparing Data for Recommendation Systems: User & Movie Count in Python
151. Homework Challenge - Coding Exercise
152. Step 4 - Prepare Data for Autoencoder: Creating User-Movie Rating Matrices
153. Step 5 - Convert Training and Test Sets to PyTorch Tensors for Deep Learning
154. Step 6 - Building Autoencoder Architecture: Class Creation for Neural Networks
155. Step 7 - Python Autoencoder Tutorial: Implementing Activation Functions & Layers
156. Step 8 - PyTorch Techniques for Efficient Autoencoder Training on Large Datasets
157. Step 9 - Implementing Stochastic Gradient Descent in Autoencoder Architecture
158. Step 10 - Machine Learning Metrics: Interpreting Loss in Autoencoder Training
159. Step 11 - How to Evaluate Recommender System Performance Using Test Set Loss
160. THANK YOU Video
161. ------------------- Annex - Get the Machine Learning Basics -------------------
162. Annex - Get the Machine Learning Basics
163. Regression & Classification Intuition
164. What You Need for Regression & Classification
165. Simple Linear Regression: Understanding Y = B0 + B1X in Machine Learning
166. Linear Regression Explained: Finding the Best Fitting Line for Data Analysis
167. Multiple Linear Regression - Understanding Dependent & Independent Variables
168. Understanding Logistic Regression: Intuition and Probability in Classification
169. Data Preprocessing
170. Data Preprocessing
171. How to Scale Features in Machine Learning: Normalization vs Standardization
172. Machine Learning Basics: Using Train-Test Split to Evaluate Model Performance
173. Machine Learning Workflow: Data Splitting, Feature Scaling, and Model Training
174. Data Preprocessing in Python
175. Step 1 - Data Preprocessing in Python: Essential Tools for ML Models
176. Step 2 - How to Handle Missing Data in Python: Data Preprocessing Techniques
177. Step 1 - Importing Essential Python Libraries for Data Preprocessing & Analysis
178. Step 1 - Creating a DataFrame from CSV: Python Data Preprocessing Basics
179. Step 2 - Pandas DataFrame Indexing: Building Feature Matrix X with iloc Method
180. Step 3 - Preprocessing Data: Extracting Features and Target Variables in Python
181. For Python learners, summary of Object-oriented programming: classes & objects
182. Step 1 - Handling Missing Data in Python: SimpleImputer for Data Preprocessing
183. Step 2 - Preprocessing Datasets: Fit and Transform to Handle Missing Values
184. Step 1 - Preprocessing Categorical Variables: One-Hot Encoding in Python
185. Step 2 - Using fit_transform Method for Efficient Data Preprocessing in Python
186. Step 3 - Preprocessing Categorical Data: One-Hot and Label Encoding Techniques
187. Step 1 - Machine Learning Data Prep: Splitting Dataset Before Feature Scaling
188. Step 2 - Split Data into Train & Test Sets with Scikit-learn's train_test_split
189. Step 3 - Preparing Data for ML: Splitting Datasets with Python and Scikit-learn
190. Step 1 - How to Apply Feature Scaling for Preprocessing Machine Learning Data
191. Step 2 - Feature Scaling in Machine Learning: When to Apply StandardScaler
192. Step 3 - Normalizing Data with Fit and Transform Methods in Scikit-learn
193. Step 4 - How to Apply Feature Scaling to Training & Test Sets in ML
194. Logistic Regression
195. Understanding the Logistic Regression Equation: A Step-by-Step Guide
196. How to Calculate Maximum Likelihood in Logistic Regression: Step-by-Step Guide
197. Step 1a - Machine Learning Classification: Logistic Regression in Python
198. Step 1b - Logistic Regression Analysis: Importing Libraries and Splitting Data
199. Step 2a - Data Preprocessing for Logistic Regression: Importing and Splitting
200. Step 2b - Data Preprocessing: Feature Scaling for Machine Learning in Python

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

1. Welcome
2. Introduction
3. Outline
4. Where to get the code, notebooks, and data
5. Google Colab
6. Intro to Google Colab, how to use a GPU or TPU for free
7. Tensorflow 2.0 in Google Colab
8. Uploading your own data to Google Colab
9. Where can I learn about Numpy, Scipy, Matplotlib, Pandas, and Scikit-Learn?
10. How to Succeed in This Course
11. Temporary 403 Errors
12. Machine Learning and Neurons
13. What is Machine Learning?
14. Code Preparation (Classification Theory)
15. Classification Notebook
16. Code Preparation (Regression Theory)
17. Regression Notebook
18. The Neuron
19. How does a model "learn"?
20. Making Predictions
21. Saving and Loading a Model
22. Why Keras?
23. Suggestion Box
24. Feedforward Artificial Neural Networks
25. Artificial Neural Networks Section Introduction
26. Beginners Rejoice: The Math in This Course is Optional
27. Forward Propagation
28. The Geometrical Picture
29. Activation Functions
30. Multiclass Classification
31. How to Represent Images
32. Color Mixing Clarification
33. Code Preparation (ANN)
34. ANN for Image Classification
35. ANN for Regression
36. Convolutional Neural Networks
37. What is Convolution? (part 1)
38. What is Convolution? (part 2)
39. What is Convolution? (part 3)
40. Convolution on Color Images
41. CNN Architecture
42. CNN Code Preparation
43. CNN for Fashion MNIST
44. CNN for CIFAR-10
45. Data Augmentation
46. Batch Normalization
47. Improving CIFAR-10 Results
48. Recurrent Neural Networks, Time Series, and Sequence Data
49. Sequence Data
50. Forecasting
51. Autoregressive Linear Model for Time Series Prediction
52. Proof that the Linear Model Works
53. Recurrent Neural Networks
54. RNN Code Preparation
55. RNN for Time Series Prediction
56. Paying Attention to Shapes
57. GRU and LSTM (pt 1)
58. GRU and LSTM (pt 2)
59. A More Challenging Sequence
60. Demo of the Long Distance Problem
61. RNN for Image Classification (Theory)
62. RNN for Image Classification (Code)
63. Stock Return Predictions using LSTMs (pt 1)
64. Stock Return Predictions using LSTMs (pt 2)
65. Stock Return Predictions using LSTMs (pt 3)
66. Other Ways to Forecast
67. Natural Language Processing (NLP)
68. Embeddings
69. Code Preparation (NLP)
70. Text Preprocessing
71. Text Classification with LSTMs
72. CNNs for Text
73. Text Classification with CNNs
74. Recommender Systems
75. Recommender Systems with Deep Learning Theory
76. Recommender Systems with Deep Learning Code
77. Transfer Learning for Computer Vision
78. Transfer Learning Theory
79. Some Pre-trained Models (VGG, ResNet, Inception, MobileNet)
80. Large Datasets and Data Generators
81. 2 Approaches to Transfer Learning
82. Transfer Learning Code (pt 1)
83. Transfer Learning Code (pt 2)
84. GANs (Generative Adversarial Networks)
85. GAN Theory
86. GAN Code
87. Deep Reinforcement Learning (Theory)
88. Deep Reinforcement Learning Section Introduction
89. Elements of a Reinforcement Learning Problem
90. States, Actions, Rewards, Policies
91. Markov Decision Processes (MDPs)
92. The Return
93. Value Functions and the Bellman Equation
94. What does it mean to “learn”?
95. Solving the Bellman Equation with Reinforcement Learning (pt 1)
96. Solving the Bellman Equation with Reinforcement Learning (pt 2)
97. Epsilon-Greedy
98. Q-Learning
99. Deep Q-Learning / DQN (pt 1)
100. Deep Q-Learning / DQN (pt 2)
101. How to Learn Reinforcement Learning
102. Stock Trading Project with Deep Reinforcement Learning
103. Reinforcement Learning Stock Trader Introduction
104. Data and Environment
105. Replay Buffer
106. Program Design and Layout
107. Code pt 1
108. Code pt 2
109. Code pt 3
110. Code pt 4
111. Reinforcement Learning Stock Trader Discussion
112. Help! Why is the code slower on my machine?
113. Advanced Tensorflow Usage
114. What is a Web Service? (Tensorflow Serving pt 1)
115. Tensorflow Serving pt 2
116. Tensorflow Lite (TFLite)
117. Why is Google the King of Distributed Computing?
118. Training with Distributed Strategies
119. Using the TPU
120. Low-Level Tensorflow
121. Differences Between Tensorflow 1.x and Tensorflow 2.x
122. Constants and Basic Computation
123. Variables and Gradient Tape
124. Build Your Own Custom Model
125. In-Depth: Loss Functions
126. Mean Squared Error
127. Binary Cross Entropy
128. Categorical Cross Entropy
129. In-Depth: Gradient Descent
130. Gradient Descent
131. Stochastic Gradient Descent
132. Momentum
133. Variable and Adaptive Learning Rates
134. Adam (pt 1)
135. Adam (pt 2)
136. Course Conclusion
137. How to get the Tensorflow Developer Certificate
138. What to Learn Next
139. Extras
140. How to Choose Hyperparameters
141. Get the Exercise Pack for This Course
142. Setting up your Environment (FAQ by Student Request)
143. Pre-Installation Check
144. How to install Numpy, Scipy, Matplotlib, Pandas, IPython, Theano, and TensorFlow
145. Anaconda Environment Setup
146. Installing NVIDIA GPU-Accelerated Deep Learning Libraries on your Home Computer
147. Extra Help With Python Coding for Beginners (FAQ by Student Request)
148. Get Your Hands Dirty, Practical Coding Experience, Data Links
149. How to use Github & Extra Coding Tips (Optional)
150. Beginner's Coding Tips
151. How to Code Yourself (part 1)
152. How to Code Yourself (part 2)
153. Proof that using Jupyter Notebook is the same as not using it
154. Is Theano Dead?
155. Effective Learning Strategies for Machine Learning (FAQ by Student Request)
156. How to Succeed in this Course (Long Version)
157. Is this for Beginners or Experts? Academic or Practical? Fast or slow-paced?
158. Machine Learning and AI Prerequisite Roadmap (pt 1)
159. Machine Learning and AI Prerequisite Roadmap (pt 2)
160. Common Beginner Questions: What if I'm "advanced"?
161. Appendix / FAQ Finale
162. What is the Appendix?
163. BONUS

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

1. Introduction
2. How to learn from this course
3. Using Udemy like a pro
4. Download all course materials
5. Downloading and using the code
6. My policy on code-sharing
7. Concepts in deep learning
8. What is an artificial neural network?
9. How models "learn"
10. The role of DL in science and knowledge
11. Running experiments to understand DL
12. Are artificial "neurons" like biological neurons?
13. About the Python tutorial
14. Should you watch the Python tutorial?
15. Math, numpy, PyTorch
16. PyTorch or TensorFlow?
17. Introduction to this section
18. Spectral theories in mathematics
19. Terms and datatypes in math and computers
20. Converting reality to numbers
21. Vector and matrix transpose
22. OMG it's the dot product!
23. Matrix multiplication
24. Softmax
25. Logarithms
26. Entropy and cross-entropy
27. Min/max and argmin/argmax
28. Mean and variance
29. Random sampling and sampling variability
30. Reproducible randomness via seeding
31. The t-test
32. Derivatives: intuition and polynomials
33. Derivatives find minima
34. Derivatives: product and chain rules
35. Gradient descent
36. Overview of gradient descent
37. What about local minima?
38. Gradient descent in 1D
39. CodeChallenge: unfortunate starting value
40. Gradient descent in 2D
41. CodeChallenge: 2D gradient ascent
42. Parametric experiments on g.d.
43. CodeChallenge: fixed vs. dynamic learning rate
44. Vanishing and exploding gradients
45. Tangent: Notebook revision history
46. ANNs (Artificial Neural Networks)
47. The perceptron and ANN architecture
48. A geometric view of ANNs
49. ANN math part 1 (forward prop)
50. ANN math part 2 (errors, loss, cost)
51. ANN math part 3 (backprop)
52. ANN for regression
53. CodeChallenge: manipulate regression slopes
54. ANN for classifying qwerties
55. Learning rates comparison
56. Multilayer ANN
57. Linear solutions to linear problems
58. Why multilayer linear models don't exist
59. Multi-output ANN (iris dataset)
60. CodeChallenge: more qwerties!
61. Comparing the number of hidden units
62. Depth vs. breadth: number of parameters
63. Defining models using sequential vs. class
64. Model depth vs. breadth
65. CodeChallenge: convert sequential to class
66. Diversity of ANN visual representations
67. Reflection: Are DL models understandable yet?
68. Overfitting and cross-validation
69. What is overfitting and is it as bad as they say?
70. Cross-validation
71. Generalization
72. Cross-validation -- manual separation
73. Cross-validation -- scikitlearn
74. Cross-validation -- DataLoader
75. Splitting data into train, devset, test
76. Cross-validation on regression
77. Regularization
78. Regularization: Concept and methods
79. train() and eval() modes
80. Dropout regularization
81. Dropout regularization in practice
82. Dropout example 2
83. Weight regularization (L1/L2): math
84. L2 regularization in practice
85. L1 regularization in practice
86. Training in mini-batches
87. Batch training in action
88. The importance of equal batch sizes
89. CodeChallenge: Effects of mini-batch size
90. Metaparameters (activations, optimizers)
91. What are "metaparameters"?
92. The "wine quality" dataset
93. CodeChallenge: Minibatch size in the wine dataset
94. Data normalization
95. The importance of data normalization
96. Batch normalization
97. Batch normalization in practice
98. CodeChallenge: Batch-normalize the qwerties
99. Activation functions
100. Activation functions in PyTorch
101. Activation functions comparison
102. CodeChallenge: Compare relu variants
103. CodeChallenge: Predict sugar
104. Loss functions
105. Loss functions in PyTorch
106. More practice with multioutput ANNs
107. Optimizers (minibatch, momentum)
108. SGD with momentum
109. Optimizers (RMSprop, Adam)
110. Optimizers comparison
111. CodeChallenge: Optimizers and... something
112. CodeChallenge: Adam with L2 regularization
113. Learning rate decay
114. How to pick the right metaparameters
115. FFNs (Feed-Forward Networks)
116. What are fully-connected and feedforward networks?
117. The MNIST dataset
118. FFN to classify digits
119. CodeChallenge: Binarized MNIST images
120. CodeChallenge: Data normalization
121. Distributions of weights pre- and post-learning
122. CodeChallenge: MNIST and breadth vs. depth
123. CodeChallenge: Optimizers and MNIST
124. Scrambled MNIST
125. Shifted MNIST
126. CodeChallenge: The mystery of the missing 7
127. Universal approximation theorem
128. More on data
129. Anatomy of a torch dataset and dataloader
130. Data size and network size
131. CodeChallenge: unbalanced data
132. What to do about unbalanced designs?
133. Data oversampling in MNIST
134. Data noise augmentation (with devset+test)
135. Data feature augmentation
136. Getting data into colab
137. Save and load trained models
138. Save the best-performing model
139. Where to find online datasets
140. Measuring model performance
141. Two perspectives of the world
142. Accuracy, precision, recall, F1
143. APRF in code
144. APRF example 1: wine quality
145. APRF example 2: MNIST
146. CodeChallenge: MNIST with unequal groups
147. Computation time
148. Better performance in test than train?
149. FFN milestone projects
150. Project 1: A gratuitously complex adding machine
151. Project 1: My solution
152. Project 2: Predicting heart disease
153. Project 2: My solution
154. Project 3: FFN for missing data interpolation
155. Project 3: My solution
156. Weight inits and investigations
157. Explanation of weight matrix sizes
158. A surprising demo of weight initializations
159. Theory: Why and how to initialize weights
160. CodeChallenge: Weight variance inits
161. Xavier and Kaiming initializations
162. CodeChallenge: Xavier vs. Kaiming
163. CodeChallenge: Identically random weights
164. Freezing weights during learning
165. Learning-related changes in weights
166. Use default inits or apply your own?
167. Autoencoders
168. What are autoencoders and what do they do?
169. Denoising MNIST
170. CodeChallenge: How many units?
171. AEs for occlusion
172. The latent code of MNIST
173. Autoencoder with tied weights
174. Running models on a GPU
175. What is a GPU and why use it?
176. Implementation
177. CodeChallenge: Run an experiment on the GPU
178. Convolution and transformations
179. Convolution: concepts
180. Feature maps and convolution kernels
181. Convolution in code
182. Convolution parameters (stride, padding)
183. The Conv2 class in PyTorch
184. CodeChallenge: Choose the parameters
185. Transpose convolution
186. Max/mean pooling
187. Pooling in PyTorch
188. To pool or to stride?
189. Image transforms
190. Creating and using custom DataLoaders
191. Understand and design CNNs
192. The canonical CNN architecture
193. CNN to classify MNIST digits
194. CNN on shifted MNIST
195. Classify Gaussian blurs
196. Examine feature map activations
197. CodeChallenge: Softcode internal parameters
198. CodeChallenge: How wide the FC?
199. Do autoencoders clean Gaussians?
200. CodeChallenge: AEs and occluded Gaussians