Computer Vision & Deep Learning in Python: Novice to Expert

For all those who are interested in becoming experts in Deep Learning and Computer Vision using Python

Created by : Rated :4.1 40840 views

Last Updated: 2022-04-25 08:04:31 English Course Type: Self Learning

Computer Vison and Image Recognition Specific Deep Learning and Convolutional Neural Networks using Python for Beginners

Hello and welcome to my new course "Computer Vision & Deep Learning in Python: From Novice to Expert"

Making a computer classify an image using Deep Learning and Neural Networks is comparatively easier than it was before. Using all these ready made packages and libraries will few lines of code will make the process feel like a piece of cake.

Its just like driving a big fancy car with an automatic transmission. You just only have to know how to use the basic controls to drive it. But, if you are a true engineer, you will also be fascinated about the internal working of the engine. In an expert level, you should be able to build your own version of that car from the scratch using the available basic components. Even-though the performance may not match the commercial production line version, the experience knowledge you gain from it cannot be explained in words.

And only because of this we have our course divided into exactly two halves. In the first half we will learn the working concepts of image recognition using computer vision and deep learning and will try to implement the simple versions of popular algorithms and techniques using plain python code. In the next half we will use the popular packages and libraries to implement more complex deep learning image classification models.

Here is a quick list of sessions that are included in this course.

The first three sessions will be theory sessions in which we will have overview about the concepts of deep learning and neural networks. We will also discuss the basics about a digital image and its composition

Then we will prepare your computer by installing and configuring Anaconda, the free and open-source Python data science platform and the other dependencies to proceed with our exercises.

If you are new to python programming, don't worry. The next four sessions will be covering the basics of python program with simple examples.

And here comes the aforementioned first half with our own custom code and libraries.

In the coming two theory sessions we will be covering the basics of image classification and the list of datasets that we are planning to cover in this course.

Then we will do a step by step custom implementation of The k-nearest neighbours (KNN) algorithm. It is a simple, easy-to-implement supervised machine learning algorithm that can be used to solve both non-linear classification and regression problems. We will use our own created classes and methods without using any external library. The theory sessions involve learning the KNN basics. Then we will go ahead with downloading the dataset, loading, preprocessing and splitting the data. We will try to train the program and will do an image classification among the three set of animals. Dogs, cats and pandas prediction using our custom KNN implementation.

Now we will proceed with Linear Classification. Starting with the Concept and Theory, we will proceed further with building our own scoring function and also implementing it using plain python code. Later we will discuss about the loss function concepts and also the performance optimization concepts and the terminology associated with it.

Then will start with the most important optimization algorithm for deep learning which is the Gradient Decent. We will have separate elaborate sessions where we will learn the concept and also implementation using the custom code for Gradient Decent. Later we will proceed with the more advanced Stochastic Gradient Decent with its concepts in the first sessions, later with implementing it using the custom class and methods we created.

We will then look at regularization techniques that can also be used for enhancing the performance and also will implement it with our custom code.

In the coming sessions, we will have Perceptron, which is a fundamental unit of the neural network which takes weighted inputs, process it and is capable of performing binary classifications. We will discuss the working of the Perceptron Model. Will implement it using Python and also we will try to do some basic prediction exercises using the preceptron we created.

In deep learning, back-propagation is a widely used algorithm in training feed-forward neural networks for supervised learning. We will then have a discussion about the mechanism of backward propagation of errors. Then to implement this concept, we will create our own classes and later implementation projects for a simple binary calculation dataset and also the MNIST optical character recognition dataset.

And with all the knowledge from the pain of making custom implementations. We can now proceed with the second half of deep learning implementation using the libraries and packages that are used for developing commercial Computer Vision Deep Learning programs

We will be using Keras which is an open-source neural-network library written in Python. It is capable of running on top of TensorFlow, Theano and also other languages for creating deep learning applications

At first we will build a simple Neural Network implementation with Keras using the MNIST Optical Character Recognition Dataset. We will train and evaluate this neural network to obtain the accuracy and loss it got during the process.

In deep learning and Computer Vision, a convolutional neural network is a class of deep neural networks, most commonly applied to analysing visual imagery. At first we will have a discussion about the steps and layers in a convolutional neural network. Then we will proceed with creating classes and methods for a custom implementation of Convolutional neural network using the Keras Library which features different filters that we can use for images.

Then we will have a quick discussion about the CNN Design Best Practices and then will go ahead with ShallowNet. The basic and simple CNN architecture. We will create the common class for implementing ShallowNet and later will train and evaluate the ShallowNet model using the popular Animals as well as CIFAR 10 image datasets. Then we will see how we can serialize or save the trained model and then later load it and use it. Even-though a very shallow network, we will try to do prediction for an image we give using shallowNet for both the Animals and CIFAR 10 dataset

After that we will try famous CNN architecture called 'LeNet' for handwritten and machine-printed character recognition. For LeNet also, will create the common class and later will train, evaluate and save the LeNet model using the MNIST dataset. Later we will try to do prediction for a hand written digit image.

Then comes the mighty VGGNet architecture. We will create the common class and later will train, evaluate and save the VGGNet model using the CIFAR-10 dataset. After hours of training, later we will try to do prediction for photos of few common real-life objects falling in the CIFAR-10 categories.

While training deep networks, it is helpful to reduce the learning rate as the number of training epochs increases. We will learn a technique called as Learning Rate Scheduling in our next session and implement it in our python code.

Since we are spending hours to train a model, if we don't checkpoint our training models at the end of a job, there is a great chance that we'll have lost all of our hard earned results! We will see how we can efficiently do that in the coming sessions.

Enough with training using our little computer. Lets go ahead with popular Deep learning models already pre-trained for us which are included in Keras library. They are trained on Imagenet data which is a collection of image data containing 1000 categories of images.

The first pre-trained model that we are dealing with is the VGGNet-16, we will download the already trained model and then do the prediction. Later will go a bit deeper with VGGNet-19 pre-trained model and will do the image classification prediction.

The next pre-trained model that we are using is the ResNet, which can utilize a technique called skip connections, or shortcuts to jump over some layers. We will do the image classification prediction with this network too.

Finally, we will get the Inception and Xception models. Which are convolutional neural networks trained on more than a million images from the ImageNet database. They learn by using Depthwise Separable Convolutions. We will download the weights and do the image classification prediction with this network too.

Overall, this course will be the perfect recipe of custom and ready-made components that you can use for your career in Computer Vision using Deep Learning.

All the example code and sample images with dataset can be downloaded from the link included in the last session or resource section of this course.

We will also provide you with a course completion certificate once you are done with all the sessions and it will add great value to your career.

So best wishes and happy learning. See you soon in the class room.

Bibliography & Reference Credits:

* CS231M ãƒ» Stanford University, CS231N ãƒ» Stanford University

* pyimagesearch blog by Dr. Adrian Rosebrock, PhD.

* Deep Learning for Computer Vision : Dr. Adrian Rosebrock, PhD.

* Andrej Karpathy. CS231n: Convolutional Neural Networks for Visual Recognition.

* AndrejKarpathy.LinearClassification

* Machine Learning is Fun! Adam Geitgey

* Andrew Ng. Machine Learning

* Andrej Karpathy. Optimization

* Karen Simonyan and Andrew Zisserman. "Very Deep Convolutional Networks for Large-

Scale Image Recognition"

Intro Background Video Credits:

* Machine Learning: Living in the Age of AI

A medium configuration computer and the willingness to indulge in the world of Deep Learning

Beginners who are interested in becoming experts in Deep Learning and Computer Vision using Python

Section 1 : Course Introduction and Table of Contents 1 Lectures 00:10:12
Lecture 1 :
Course Introduction and Table of Contents Preview
Section 2 : Introduction to Deep Learning 1 Lectures 00:07:46
Lecture 1 :
Introduction to Deep Learning
Section 3 : Introduction to Neural Networks 1 Lectures 00:06:52
Lecture 1 :
Introduction to Neural Networks
Section 4 : Image Basics 2 Lectures 00:10:11
Lecture 1 :
Image Basics - Part 1
Lecture 2 :
Image Basics - Part 2
Section 5 : Preparing your computer - Installing Anaconda 1 Lectures 00:09:14
Lecture 1 :
Preparing your computer - Installing Anaconda
Section 6 : Preparing your computer - Installing Dependencies 1 Lectures 00:08:23
Lecture 1 :
Preparing your computer - Installing Dependencies
Section 7 : Python Basics 4 Lectures 00:34:36
Lecture 1 :
Python Basics - Assignment
Lecture 2 :
Python Basics - Flow Control
Lecture 3 :
Python Basics - Functions
Lecture 4 :
Python Basics - Data Structures
Section 8 : Load and Show Image 1 Lectures 00:07:08
Lecture 1 :
Load and Show Image
Section 9 : Image Classification Basics 2 Lectures 00:13:38
Lecture 1 :
Image Classification Basics - Part 1
Lecture 2 :
Image Classification Basics - Part 2
Section 10 : List of Popular Datasets Included 1 Lectures 00:05:32
Lecture 1 :
List of Popular Datasets Included
Section 11 : KNN Image Classifier - Downloading Animals Dataset 1 Lectures 00:04:26
Lecture 1 :
KNN Image Classifier - Downloading Animals Dataset
Section 12 : Creating Common Pre-processor 1 Lectures 00:10:53
Lecture 1 :
Creating Common Pre-processor
Section 13 : Creating Common Loader 2 Lectures 00:19:46
Lecture 1 :
Creating Common Loader - Part 1
Lecture 2 :
Creating Common Loader - Part 2
Section 14 : KNN Basics 2 Lectures 00:10:57
Lecture 1 :
KNN Basics - Part 1
Lecture 2 :
KNN Basics - Part 2
Section 15 : KNN Implementation - Load and Process 3 Lectures 00:21:52
Lecture 1 :
KNN Implementation - Load and Process - Part 1
Lecture 2 :
KNN Implementation - Load and Process - Part 2
Lecture 3 :
KNN Implementation - Load and Process - Part 3
Section 16 : KNN Implementation - Splitting the Dataset 1 Lectures 00:07:40
Lecture 1 :
KNN Implementation - Splitting the Dataset
Section 17 : KNN Implementation - Training and Evaluation 2 Lectures 00:12:15
Lecture 1 :
KNN Implementation - Training and Evaluation - Part 1
Lecture 2 :
KNN Implementation - Training and Evaluation - Part 2
Section 18 : KNN Prediction 2 Lectures 00:15:19
Lecture 1 :
KNN Prediction - Part 1
Lecture 2 :
KNN Prediction - Part 2
Section 19 : Introduction to Linear Classification 2 Lectures 00:14:23
Lecture 1 :
Introduction to Linear Classification - Part 1
Lecture 2 :
Introduction to Linear Classification - Part 2
Section 20 : Scoring Function Basics 2 Lectures 00:10:45
Lecture 1 :
Scoring Function Basics - Part 1
Lecture 2 :
Scoring Function Basics - Part 2
Section 21 : Scoring Function - Implementation 2 Lectures 00:15:09
Lecture 1 :
Scoring Function - Implementation - Part 1
Lecture 2 :
Scoring Function - Implementation - Part 2
Section 22 : Loss Function Basics 1 Lectures 00:09:02
Lecture 1 :
Loss Function Basics
Section 23 : Optimization Concept Terminology and Challenges 2 Lectures 00:13:23
Lecture 1 :
Optimization Concept Terminology and Challenges - Part 1
Lecture 2 :
Optimization Concept Terminology and Challenges - Part 2
Section 24 : Gradient Descent Implementation 5 Lectures 00:49:49
Lecture 1 :
Gradient Descent Implementation - Part 1
Lecture 2 :
Gradient Descent Implementation - Part 2
Lecture 3 :
Gradient Descent Implementation - Part 3
Lecture 4 :
Gradient Descent Implementation - Part 4
Lecture 5 :
Gradient Descent Implementation - Part 5
Section 25 : Stochastic Gradient Descent Implementation 2 Lectures 00:17:09
Lecture 1 :
Stochastic Gradient Descent Implementation - Part 1
Lecture 2 :
Stochastic Gradient Descent Implementation - Part 2
Section 26 : Introduction to Regularization 1 Lectures 00:04:43
Lecture 1 :
Introduction to Regularization
Section 27 : Implementing Regularization 1 Lectures 00:11:10
Lecture 1 :
Implementing Regularization
Section 28 : Introduction to Perceptrons 2 Lectures 00:16:08
Lecture 1 :
Introduction to Perceptrons - Part 1
Lecture 2 :
Introduction to Perceptrons - Part 2
Section 29 : Perceptron Implementation: Creating Class 3 Lectures 00:26:31
Lecture 1 :
Perceptron Implementation: Creating Class - Part 1
Lecture 2 :
Perceptron Implementation: Creating Class - Part 2
Lecture 3 :
Perceptron Implementation: Creating Class - Part 3
Section 30 : Perceptron Implementation: Creating BitWise Evaluation Program 2 Lectures 00:16:38
Lecture 1 :
Perceptron Implementation: Creating BitWise Evaluation Program - Part 1
Lecture 2 :
Perceptron Implementation: Creating BitWise Evaluation Program - Part 2
Section 31 : Introduction to Back Propagation 2 Lectures 00:10:52
Lecture 1 :
Introduction to Back Propagation - Part 1
Lecture 2 :
Introduction to Back Propagation - Part 2
Section 32 : Back Propagation Implementation - Creating Class 7 Lectures 01:00:01
Lecture 1 :
Back Propagation Implementation - Creating Class - Part 1
Lecture 2 :
Back Propagation Implementation - Creating Class - Part 2
Lecture 3 :
Back Propagation Implementation - Creating Class - Part 3
Lecture 4 :
Back Propagation Implementation - Creating Class - Part 4
Lecture 5 :
Back Propagation Implementation - Creating Class - Part 5
Lecture 6 :
Back Propagation Implementation - Creating Class - Part 6
Lecture 7 :
Back Propagation Implementation - Creating Class - Part 7
Section 33 : Back Propagation - Create XOR Evaluation Program 2 Lectures 00:18:26
Lecture 1 :
Back Propagation - Create XOR Evaluation Program - Part 1
Lecture 2 :
Back Propagation - Create XOR Evaluation Program - Part 2
Section 34 : Back Propagation - Create MNIST Evaluation Program 3 Lectures 00:24:00
Lecture 1 :
Back Propagation - Create MNIST Evaluation Program - Part 1
Lecture 2 :
Back Propagation - Create MNIST Evaluation Program - Part 2
Lecture 3 :
Back Propagation - Create MNIST Evaluation Program - Part 3
Section 35 : Keras Based MNIST Evaluation Program 4 Lectures 00:34:41
Lecture 1 :
Keras Based MNIST Evaluation Program - Part 1
Lecture 2 :
Keras Based MNIST Evaluation Program - Part 2
Lecture 3 :
Keras Based MNIST Evaluation Program - Part 3
Lecture 4 :
Keras Based MNIST Evaluation Program - Part 4
Section 36 : Introduction to Convolutional Neural Networks 1 Lectures 00:11:17
Lecture 1 :
Introduction to Convolutional Neural Networks
Section 37 : Custom Convolution using Python 4 Lectures 00:30:16
Lecture 1 :
Custom Convolution using Python - Part 1
Lecture 2 :
Custom Convolution using Python - Part 2
Lecture 3 :
Custom Convolution using Python - Part 3
Lecture 4 :
Custom Convolution using Python - Part 4
Section 38 : CNN Design Best Practices and ShallowNet Introduction 1 Lectures 00:05:08
Lecture 1 :
CNN Design Best Practices and ShallowNet Introduction
Section 39 : Create ShallowNet Class 2 Lectures 00:13:50
Lecture 1 :
Create ShallowNet Class - Part 1
Lecture 2 :
Create ShallowNet Class - Part 2
Section 40 : ShallowNet using Animals Dataset 2 Lectures 00:19:48
Lecture 1 :
ShallowNet using Animals Dataset - Part 1
Lecture 2 :
ShallowNet using Animals Dataset - Part 2
Section 41 : ShallowNet using CIFAR10 Dataset 1 Lectures 00:12:47
Lecture 1 :
ShallowNet using CIFAR10 Dataset
Section 42 : ShallowNet CIFAR10 Save and Load Model 1 Lectures 00:07:18
Lecture 1 :
ShallowNet CIFAR10 Save and Load Model
Section 43 : ShallowNet CIFAR10 Predict 1 Lectures 00:12:00
Lecture 1 :
ShallowNet CIFAR10 Predict
Section 44 : ShallowNet Animals Save, Load and Predict 1 Lectures 00:05:19
Lecture 1 :
ShallowNet Animals Save, Load and Predict
Section 45 : LeNet Overview 1 Lectures 00:07:43
Lecture 1 :
LeNet Overview
Section 46 : Create LeNet Class 1 Lectures 00:08:52
Lecture 1 :
Create LeNet Class
Section 47 : Lenet MNIST Train and Save 1 Lectures 00:11:13
Lecture 1 :
Lenet MNIST Train and Save
Section 48 : Lenet MNIST Prediction 1 Lectures 00:06:12
Lecture 1 :
Lenet MNIST Prediction
Section 49 : Introduction to VGGNet Architecture 1 Lectures 00:07:25
Lecture 1 :
Introduction to VGGNet Architecture
Section 50 : Creating VGGNet Class 1 Lectures 00:09:58
Lecture 1 :
Creating VGGNet Class
Section 51 : VGGNet CIFAR 10 Model Save 1 Lectures 00:07:45
Lecture 1 :
VGGNet CIFAR 10 Model Save
Section 52 : VGGNet CIFAR 10 Predict 1 Lectures 00:04:24
Lecture 1 :
VGGNet CIFAR 10 Predict
Section 53 : Learning Rate Scheduler 2 Lectures 00:11:17
Lecture 1 :
Learning Rate Scheduler - Part 1
Lecture 2 :
Learning Rate Scheduler - Part 2
Section 54 : Improvement Checkpoint 2 Lectures 00:15:59
Lecture 1 :
Improvement Checkpoint - Part 1
Lecture 2 :
Improvement Checkpoint - Part 2
Section 55 : Pretrained VGGNet 16 2 Lectures 00:16:06
Lecture 1 :
Pretrained VGGNet 16 - Part 1
Lecture 2 :
Pretrained VGGNet 16 - Part 2
Section 56 : Pretrained VGGNet 19 1 Lectures 00:04:19
Lecture 1 :
Pretrained VGGNet 19
Section 57 : Pretrained ResNet 1 Lectures 00:04:51
Lecture 1 :
Pretrained ResNet
Section 58 : Pretrained Inception 1 Lectures 00:05:55
Lecture 1 :
Pretrained Inception
Section 59 : Pretrained Xception 1 Lectures 00:06:34
Lecture 1 :
Pretrained Xception
Section 60 : SOURCE CODE AND FILES ATTACHED 1 Lectures
Lecture 1 :
Source Code Download Link Attached
Download Source Code, Datasets, Samples images from https://drive.google.com/open?id=10Ei9YgCFwlvv5pLHIBmWGJ59R3EyIDk1

How do i access the course after purchase?
It's simple. When you sign up, you'll immediately have unlimited viewing of thousands of expert courses, paths to guide your learning, tools to measure your skills and hands-on resources like exercise files. There’s no limit on what you can learn and you can cancel at any time.
Are these video based online self-learning courses?
Yes. All of the courses comes with online video based lectures created by certified instructors. Instructors have crafted these courses with a blend of high quality interactive videos, lectures, quizzes & real world projects to give you an indepth knowledge about the topic.
Can i play & pause the course as per my convenience?
Yes absolutely & thats one of the advantage of self-paced courses. You can anytime pause or resume the course & come back & forth from one lecture to another lecture, play the videos mulitple times & so on.
How do i contact the instructor for any doubts or questions?
Most of these courses have general questions & answers already covered within the course lectures. However, if you need any further help from the instructor, you can use the inbuilt Chat with Instructor option to send a message to an instructor & they will reply you within 24 hours. You can ask as many questions as you want.
Do i need a pc to access the course or can i do it on mobile & tablet as well?
Brilliant question? Isn't it? You can access the courses on any device like PC, Mobile, Tablet & even on a smart tv. For mobile & a tablet you can download the Learnfly android or an iOS app. If mobile app is not available in your country, you can access the course directly by visting our website, its fully mobile friendly.
Do i get any certificate for the courses?
Yes. Once you complete any course on our platform along with provided assessments by the instructor, you will be eligble to get certificate of course completion.
For how long can i access my course on the platform?
You require an active subscription to access courses on our platform. If your subscription is active, you can access any course on our platform with no restrictions.
Is there any free trial?
Currently, we do not offer any free trial.
Can i cancel anytime?
Yes, you can cancel your subscription at any time. Your subscription will auto-renew until you cancel, but why would you want to?

Abhilash Nelson,

282762 Course Views

19 Courses

I am a pioneering, talented and security-oriented Android/iOS Mobile and PHP/Python Web Developer Application Developer offering more than eight years’ overall IT experience which involves designing, implementing, integrating, testing and supporting impact-full web and mobile applications. I am a Post Graduate Masters Degree holder in Computer Science and Engineering. My experience with PHP/Python Programming is an added advantage for server-based Android and iOS Client Applications. I am currently serving full-time as a Senior Solution Architect managing my client's projects from start to finish to ensure high-quality, innovative and functional design.