Numerical Optimization, Machine Learning, Deep Learning, Gradient Descent
Note: Course Free for limited time and limited users(500 limit) so Enroll ASAP. If not free it means you are late. Scroll Down and click Enroll Now button to get enrolled
Scroll Down and click Enroll Now Button to get enrolled into the Free Course
Apply Coupon Code: C8ED4BBD3F465EACBD2B
What you’ll learn
- Python Implementation of Gradient Descent Optimizer to Train Single Variable Linear Regression Model.
- Python Implementation of Gradient Descent Optimizer to Train Multi Variable Linear Regression Model.
- Python Implementation of Stochastic Gradient Descent (SGD) for Single Variable LR.
- Python Implementation of SGD for Multi-Variable LR.
- Python Implementation of Mini-Batch GD for Single and Multi-Variable LR.
- Generalization of Mini-Batch to Work as SGD and Batch GD.
- Generalization of Multi-Variable LR to Work for Single Variable LR.
- Numerical Optimization Problem Definition.
- Model Parameters Initialization.
- Calculating MSE Cost Function as Vector Norm.
- How to Calculate the Gradient?
- Model Parameters Update.
- Iterate Till Achieving the Optimum Parameter Values.
- Gradient Stop Condition.
- Model Performance Evaluation.
- How to Obtain Better Model Performance?
- Plotting of Learning Curves.
- Cost Convergence Check.
- Make Your Implementation as a Function.
- Multivariable Linear Regression Problem Definition.
- Going from Single Variable to Multivariable Linear Regression.
- Gradient Descent Optimizer Vectorize Implementation.
- Why We Use Vectorize Implementation.
- Generalization of the Implementation to Work for Single and Multivariable Linear Regression.
- Data Preparation for Vectorize Implementation.
- Dimensions Problem and How to Deal With it.
- Make Your Implementation of Vectorize Implementation as a Function.
- Try Different Combinations of Hyperparameters.
Show less
This course includes:
- 7 hours on-demand video
- 19 downloadable resources
- Access on mobile and TV
- Full lifetime access
- Certificate of completion
Course content
18 sections • 105 lectures • 7h 9m total lengthCollapse all sections
Course Overview
- Course Overview
Introduction to Single Variable Linear Regression Optimization using GD
- Introduction
Single Variable LR Optimization Problem Definition
- Problem Definition Part 1
- Problem Definition Part 2
- Problem Definition Part 3
- Problem Definition Part 4
- Problem Definition Part 5
Single Variable LR Optimization Implementation Steps
- About the Lab
- Regression Data
- Model Parameters Initialization
- Model Prediction
- Cost Calculation
- Gradient Calculation
- Model Parameters Update
- Iterate Till Achieving the Optimum Parameter Values
- Optimizer Output
- Gradient Stop Condition
- Gradient Stop Condition Output
- Model Performance Evaluation
- How to Obtain Better Model Performance?
- Plotting of Learning Curves
- Loss vs Epochs
- Loss vs Model Parameters
- Interpretation Loss vs Epochs
- Interpretation Loss vs Model Parameters
- Cost Convergence Check
Optional Section: Implement Your Optimizer as a Function
- Implement the Optimizer as a function (Recommended)
Single Variable LR Optimization Practical Work 1 Solution
- Step by Step Implementation
- Iterate Till Achieving the Optimum Parameter Values
- Gradient Stop Condition
- Model Performance Evaluation
- Different Hyperparameter Combinations
- Plotting Loss vs. Epochs
- Plot Loss vs Model Parameters
- Cost Convergence Check
- Make Your Implementation as a Function.
- Using Your Function to Explore Learning Rate Effect
Introduction to Multi Variable LR Optimization using GD
- Introduction to MultiVariable LR
The Main Idea of Multivariable LR Optimization Using GD
- Reminder of Single Variable LR Optimization
- Multivariable LR Optimization Problem Definition
- Multivariable LR Optimization Problem Solution Using Vectorize Implementation_1
- Multivariable LR Optimization Problem Solution Using Vectorize Implementation_2
- Vectorize Implementation_3 Gradient Vector Calculation
- Multivariable LR Optimization Problem Solution Using Vectorize Implementation_4
- Vectorize Implementation_5 Generalized Implementation for Single and Multivar LR
Consideration When Using NumPy Vectors
- NumPy Vectors Part 1
- NumPy Vectors Part 2
Implementation Steps
- Data Preparation
- Step by Step
- Putting All Steps Together
- Results, Model Evaluation, and Learning Curves
- Try Different Scenarios With Different Hyperparameters
Optional Section: Implement Multivariable LR Optimization Using GD as a Function
- Implement Multivariable LR Optimization Using GD as a Function (Recommended)
Multi Variable LR Optimization Practical Work 2 Solution
- Data Preparation
- Step by Step Implementation
- Putting All Steps Togeteher
- Results and Model Evaluation
- Learning Curves_1 Loss vs. Epochs
- Learning Curves_2 Loss vs. Model Parameters (Thetas)
- Different Scenarios With Different Hyperparameters
- Multivariable LR Optimization Implementation as a Function
Stochastic GD (SGD) for single variable LR Practical Work 3 Part 1
- Introduction
- The main idea_1_Epoch vs. iteration
- The main idea_2_Batch GD problems
- The main idea_3_Stochastic GD (SGD)
- Implementation steps 1 (Tips and Tricks)
- Implementation steps 2 (Data generation and applying batch GD)
- Implementation steps 3 (step by step)
- Implementation steps 4 (Iterate to finish one epoch)
- Implementation steps 5 (more epochs and stop condition tricks)
- Implementation steps 6 (results and discussion)
Stochastic GD (SGD) for single variable LR Practical Work 3 Part 1 Solution
- Data Generation
- Batch GD Scenario
- Implementation steps 1 (Data Shuffle)
- Implementation steps 2 (One iteration)
- Implementation steps 3 (Iterate to finish one epoch)
- Implementation steps 4 (More epochs)
- Learning curves and model evaluation
- SGD for single variable LR as a function
- SGD vs. batch GD using different hyperparameters
Stochastic GD (SGD) for multi variable LR Practical Work 3 Part 2
- The main idea
- Implementation steps and results
Stochastic GD (SGD) for multi variable LR Practical Work 3 Part 2 Solution
- Data Preparation
- Implementation steps 1 (step by step)
- Implementation steps 2 (single epoch)
- Implementation steps 3 (More epochs)
- Implementation steps 4 (Model evaluation and learning curves)
- SGD for Multi-variable LR implementation as a function and compare to batch GD
Mini-Batch GD for Single and Multi-Variable LR Practical Work 4
- Introduction
- The main idea 1 (Batch GD and SGD drawbacks)
- The main idea 2 (Mini-Batch GD)
- Implementation Notes 1
- Implementation Notes 2
- Implementation steps 1 (step by step)
- Implementation steps 2 (full implementation and results)
- SGD and Batch GD using Mini-Batch GD
- Using mini-batch multivariable LR for single variable LR data
Mini-Batch GD for Single and Multi-Variable LR Practical Work 4 Solution
- Implementation Steps 1 (step by step single iteration)
- Implementation Steps 2 (single epoch and data slicing to mini-batches)
- Implementation Steps 3 (More Epochs)
- Implementation Steps 4 (Results and learning curves)
- Mini-batch GD implementation as a function
- More analysis to the results
- SGD and Batch GD using Mini-Batch GD
- Using mini-batch multivariable LR for single variable LR data
Requirements
- Python.
- NumPy.
- Watch Day 1 and Day 2 in the course Master Numerical Optimization for Machine Learning and Deep Learning in 5 Days.
- The course available on our channel “Artificial Intelligence & Data Science شرح بالعربي”
Description
In this course you will learn:
1- How to implement batch (vanilla) gradient descent (GD) optimizer to obtain the optimal model parameters of the single and Multi variable linear regression (LR) models.
2- How to implement mini-batch and stochastic GD for single and multi-variable LR models.
You will do this by following the guided steps represented in the attached notebook.
In addition a video series describing each step.
You will also implement the cost function, stop conditions, as well as plotting the learning curves.
You will understand the power of applying vectorize implementation of the optimizer.
This implementation will help you to solidify the concept and gain the momentum of how the optimizers work during training phase.
By the end of this course you will obtain the balance between the theoretical and practical point of view of the optimizers that is used widely in both machine learning (ML) and deep learning (DL).
In this course we will focus on the main numerical optimization concepts and techniques used in ML and DL.
Although, we apply these techniques for single and multivariable LR, the concept is the same for other ML and DL models.
We use LR here for simplification and to focus on the optimizers rather than the models.
In the subsequent practical works we will scale this vision to implement more advanced optimizers such as:
– Momentum based GD.
– Nestrov accelerated gradient NAG.
– Adaptive gradient Adagrad.
– RmsProp.
– Adam.
– BFGS.
You will be provided by the following:
– Master numerical optimization for machine learning and deep learning in 5 days course material (slides).
– Notebooks of the guided steps you should follow.
– Notebooks of the practical works ideal solution (the implementation).
– Data files.
You should do the implementation by yourself and compare your code to the practical session solution provided in a separate notebook.
A video series explaining the solution is provided. However, do not see the solution unless you finish your own implementation.
Who this course is for:
- Learners who are interested to learn how the optimizer work to train the Machine Learning or Deep Learning models.
- Learners who wants to apply there theoretical knowledge.
- Learner who wants to have deeper understanding of numerical optimization algorithms by implementing it step by step.
- Learners who wants to have the balance between both theoretical and practical knowledge.
Show less
Note: The course is free for a limited time and limited to 500 users. Enroll as soon as possible. If it is no longer free, it means you are late, and it has already exceeded its limits.
🎫 After adding the course into Cart at Checkout page, Apply Coupon Code➛. C8ED4BBD3F465EACBD2B Note:- After applying coupon, if it says ”This coupon has exceeded its maximum possible redemptions…”, then it means you’re Late, and first 500 coupons already redeemed.
