Hi everyone,

this is Zulaikha from Edureka, and I welcome you to this session on Artificial Intelligence full course. In this video, I'll be covering all the domains and the concepts involved under the umbrella

of artificial intelligence, and I will also be showing

you a couple of use cases and practical implementations

by using Python. So there's a lot to cover in this session, and let me quickly run you

through today's agenda. So we're gonna begin the session by understanding the history

of artificial intelligence and how it cam into existence. We'll follow this by looking at why we're talking about

artificial intelligence now, why has it gotten so famous right now.

Then we'll look at what exactly

is artificial intelligence. We'll discuss the applications

of artificial intelligence, after which we'll discuss the basics of AI where in we'll understand the different types of

artificial intelligence. We'll follow this by understanding the different programming languages that can be used to study AI. And we'll understand why

we're gonna choose Python. Alright, I'll introduce you to Python. And then we'll move on and

discuss machine learning. Here we'll discuss the different

types of machine learning, the different algorithms

involved in machine learning, which include classification algorithms, regression algorithms, clustering, and association algorithms. To make you understand

machine learning better, we'll run a couple of demos wherein we'll see how

machine learning algorithms are used to solve real world problems. After that, we'll discuss the limitations of machine learning and why deep learning is needed. I'll introduce you to the

deep learning concept, what are neurons, perceptrons, multiple layer perceptrons and so on.

We'll discuss the different

types of neural networks, and we'll also look at what

exactly back propagation is. Apart from this, we'll be running a demo to understand deep learning in more depth. And finally we'll move

onto the next module, which is natural language processing. On the natural language processing, we'll try to understand

what is text mining, the difference between text mining in NLP, what are the different

terminologies in NLP, and we'll end the session by looking at the practical implementation

of NLP using Python, alright.

So guys, there's a lot to

cover in today's session. Also, if you want to stay updated about the recent technologies, and would like to learn more

about the training technology, make sure you subscribe

to our YouTube channel to never miss out on such sessions. So let's move ahead and take

a look at our first topic which is history of

artificial intelligence. So guys, the concept of

artificial intelligence goes back to the classical ages. Under Greek mythology, the concept of machines and mechanical men were well thought of. So, an example of this is Talos. I don't know how many of

you have heard of this.

Talos was a giant animated bronze warrior who was programmed to

guard the island of Crete. Now these are just ideas. Nobody knows if this was

actually implemented, but machine learning and AI

were thought of long ago. Now let's get back to the 19th century. Now 1950 was speculated to be one of the most important years for the introduction of

artificial intelligence. In 1950, Alan Turing published a paper in which he speculated

about the possibility of creating machines that think. So he created what is

known as the Turing test. This test is basically used to determine whether or not a computer

can think intelligently like a human being. He noted that thinking

is difficult to define and devised his famous Turing test. So, basically, if a machine

can carry out a conversation that was indistinguishable from a conversation with a human being, it was reasonable to say

that the machine is thinking, meaning that the machine

will pass the Turing test.

Now, unfortunately, up to this date, we haven't found a machine

that has fully cleared the Turing test. So, the Turing test was actually

the first serious proposal in the philosophy of

artificial intelligence. Followed by this was the era of 1951. This was also known as the game AI. So in 1951, by using the

Ferranti Mark 1 machine of the University of Manchester, a computer scientist known

as Christopher Strachey wrote a checkers program. And at the same time, a program was written for chess as well. Now, these programs were

later improved and redone, but this was the first attempt at creating programs that could play chess or that would compete with

humans in playing chess.

This is followed by the year 1956. Now, this is probably

the most important year in the invention of AI. Because in 1956, for the firs time, the term artificial

intelligence was coined. Alright. So the term artificial intelligence was coined by John McCarthy at the Dartmouth Conference in 1956. Coming to the year 1959, the first AI laboratory was established. This period marked the

research era for AI. So the first AI lab where

research was performed is the MIT lab, which is still running til date. In 1960, the first robot was introduced to the General Motors assembly line. In 1961, the first chatbot was invented. Now we have Siri, we have Alexa. But in 1961, there was a chatbot known as Eliza, which was introduced. This is followed by the

famous IBM Deep Blue. In 1997, the news broke down that IBM's Deep Blue

beats the world champion, Garry Kasparov, in the game of chess. So this was kind of the

first accomplishment of AI.

It was able to beat the

world champion at chess. So in 2005, when the DARPA

Grand Challenge was held, a robotic car named Stanley, which was built by Stanford's racing team, won the DARPA Grand Challenge. That was another big accomplish of AI. In 2011, IBM's question

answering system, Watson, defeated the two greatest

Jeopardy champions, Brad Rutter and Ken Jennings. So guys, this was how AI evolved. It started off as a

hypothetical situation. Right now it's the most

important technology in today's world. If you look around every where, everything around us is run

through AI deep learning or machine learning. So since the emergence of AI in the 1950s, we have actually seen

an exponential growth and its potential. So AI covers domains

such as machine learning, deep learning, neural networks, natural language processing, knowledge based, expert systems and so on. It is also made its way

into computer vision and image processing.

Now the question here

is if AI has been here for over half a century, why has it suddenly

gain so much importance? Why are we talking about

artificial intelligence now? Let me tell you the main

reasons for the demand of AI. The first reason is what we have more computation power now. So, artificial intelligence requires a lot of computing power. Recently, many advances have been made and complex deep learning

models are deployed. And one of the greatest technology that made this possible are GPUs. Since we have more

computational power now, it is possible for us to implement AI in our daily aspects. Second most important reason is that we have a lot of data at present. We're generating data

at an immeasurable pace. We are generating data

through social media, through IoT devices. Every possible way, there's a lot of data. So we need to find a method or a solution that can help us process this much data, and help us derive useful insight, so that we can grow business

with the help of data.

Alright, so, that process is basically artificial intelligence. So, in order to have a useful AI agent to make smart decisions like telling which item to recommend next when you shop online, or how to classify an

object from an image. AI are trained on large data sets, and big data enables us to

do this more efficiently. Next reason is now we

have better algorithms. Right now we have very

effective algorithms which are based on the

idea of neural networks.

Neural networks is nothing but the concept behind deep learning. Since we have better algorithms which can do better computations and quicker computations

with more accuracy, the demand for AI has increased. Another reason is that

universities, governments, startup, and tech giants

are all investing in AI. Okay, so companies like Google, Amazon, Facebook, Microsoft, all of these companies

have heavily invested in artificial intelligence because they believe

that AI is the future. So AI is rapidly growing

both as a field of study and also as an economy. So, actually, this is the right time for you to understand what

is AI and how it works. So let's move on and understand what exactly artificial intelligence is. The term artificial intelligence was first coined in the

year 1956 by John McCarthy at the Dartmouth Conference. I already mentioned this before. It was the birth of AI in the 1956. Now, how did he define

artificial intelligence? John McCarthy defined AI as

the science and engineering of making intelligent machines. In other words, artificial intelligence is the theory and development

of computer systems able to perform task that normally require human intelligence, such as visual perception,

speech recognition, decision making, and

translation between languages.

So guys, in a sense, AI is a

technique of getting machines to work and behave like humans. In the rest past, artificial intelligence has been able to accomplish this by creating machines and robots that have been used in

wide range of fields, including healthcare, robotics, marketing, business analytics, and many more. With this in mind, let's discuss a couple of

real world application of AI, so that you understand how

important artificial intelligence is in today's world. Now, one of the most famous applications of artificial intelligence is the Google predictive search engine. When you begin typing a search term and Google makes recommendations

for you to choose from, that is artificial intelligence in action. So predictive searches are based on data that Google collects about you, such as your browser

history, your location, your age, and other personal details. So by using artificial intelligence, Google attempts to guess what

you might be trying to find. Now behind this, there's a lot of natural

language processing, deep learning, and

machine learning involved. We'll be discussing all of those concepts in the further slides.

It's not very simple to

create a search engine, but the logic behind Google search engine is artificial intelligence. Moving on, in the finance sector, JP Morgan Chase's Contract

Intelligence Platform uses machine learning,

artificial intelligence, and image recognition software to analyze legal documents. Now let me tell you

that manually reviewing around 12,000 agreements

took over 36,000 hours. That's a lot of time. But as soon as this task

was replaced by AI machine, it was able to do this

in a matter of seconds. So that's the difference

between artificial intelligence and manual or human work. Even though AI cannot think

and reason like humans, but their computational

power is very strong compared to humans, because the machine learning algorithm, deep learning concepts, and

natural language processing, AI has reach a stage

wherein it can compute the most complex of complex problems in a matter of seconds.

Coming to healthcare, IBM

is one of the pioneers that has developed AI software, specifically for medicine. Let me tell you that more than

230 healthcare organizations use IBM AI technology, which is basically IBM Watson. In 2016, IBM Watson technology

was able to cross reference 20 million oncology records quickly and correctly diagnose a rare leukemia condition in a patient. So, it basically went

through 20 million records, which it probably did in a

matter of second or minutes, max to max. And then it correctly diagnosed a patient with a rare leukemia. Knowing that machines are now used in medical fields as well, it shows how important AI has become. It has reached every domains of our lives. Let me give you another example. The Google's AI Eye Doctor is another initiative,

which is taken by Google, where they're working with

an Indian eye care chain to develop artificial intelligence system which can examine retinal scans and identify a condition called diabetic retinopathy

which can cause blindness.

Now in social media

platforms like Facebook, artificial intelligence is

used for face verification wherein you make use of machine learning and deep learning concept in order to detect facial

features and tag your friends. All the auto tagging feature

that you see in Facebook, behind that there's machine learning, deep learning, neural networks. There's only AI behind it. So we're actually unaware that we use AI very regularly in our life. All the social media platforms like Instagram, Facebook, Twitter, they heavily rely on

artificial intelligence.

Another such example is Twitter's AI which is being used to identify

any sort of hate speech and terroristic languages in tweets. So again, it makes use of machine leaning, deep learning, natural language processing in order to filter out any offensive or any reportable content. Now recently, the company discovered around 300,000 terroristic link accounts and 95% of these were found by non-human artificially intelligent machines. Coming to virtual assistants, we have virtual assistants

like Siri and Alexa right now. Let me tell you about

another newly released Google's virtual assistant

called the Google Duplex, which has astonished millions

of people around the world.

Not only can it respond to calls and book appointments for you, it also adds a human touch. So it adds human filters and all of that. It makes it sound very realistic. It's actually very hard

to distinguish between human and the AI speaking over the phone. Another famous application

is AI is self-driving cars. So, artificial intelligence

implements computer vision, image detection, deep learning, in order to build cars that can automatically detect

any objects or any obstacles and drive around without

human intervention. So these are fully

automated self-driving cars. Also, Elon Musk talks a lot

about how AI is implemented in Tesla's self-driving cars. He quoted that Tesla will

have fully self-driving cars ready by the end of the year, and robo taxi version

that can ferry passengers without anyone behind the wheel.

So if you look at it, AI is actually used by the tech giants. A lot of tech giant companies

like Google, Tesla, Facebook, all of these data-driven companies. In fact, Netflix also makes use of AI,. So, coming to Netflix. So with the help of

artificial intelligence and machine learning, Netflix has developed a

personalized movie recommendation for each of its users. So if each of you opened up Netflix and if you look at the type of movies that are recommended to

you, they are different. This is because Netflix studies each user's personal details, and tries to understand what

each user is interested in and what sort of movie

patterns each user has, and then it recommends movies to them. So Netflix uses the watching

history of other users with similar taste to recommend what you may be most

interested in watching next, so that you can stay engaged and continue your monthly subscription.

Also, there's a known fact

that over 75% of what you watch is recommended by Netflix. So their recommendation

engine is brilliant. And the logic behind their

recommendation engine is machine learning and

artificial intelligence. Apart from Netflix, Gmail also

uses AI on a everyday basis. If you open up your inbox right now, you will notice that there

are separate sections. For example, we have primary section, social section, and all of that. Gmail has a separate section

called the spam mails also. So, what Gmail does is it makes use of concepts of artificial intelligence and machine learning algorithms to classify emails as spam and non-spam. Many times certain words or phrases are frequently used in spam emails. If notice your spam emails, they have words like

lottery, earn, full refund.

All of this denotes that the email is more likely to be a spam one. So such words and

correlations are understood by using machine learning and

natural language processing and a few other aspects of

artificial intelligence. So, guys, these were

the common applications of artificial intelligence. Now let's discuss the

different types of AI. So, AI is divided into three

different evolutionary stages, or you can say that there are three stages of artificial intelligence. Of course, we have artificial

narrow intelligence followed by artificial

general intelligence, and that is followed by

artificial super intelligence. Artificial narrow intelligence, which is also known as weak AI, it involves applying

artificial intelligence only to specific task.

So, many currently existing systems that claim to use artificial intelligence are actually operating as weak AI focused on a narrowly

defined specific problem Let me give you an example of artificial narrow intelligence. Alexa is a very good example of weak AI. It operates within unlimited

pre-defined range of functions. There's no genuine intelligence or there is no self awareness, despite being a sophisticated

example of weak AI. The Google search engine,

Sophia the humanoid, self-driving cars, and

even the famous AlphaGo fall under the category of weak AI. So guys, right now we're at the stage of artificial narrow

intelligence or weak AI. We actually haven't reached

artificial general intelligence or artificial super intelligence, but let's look at what

exactly it would be like if we reach artificial

general intelligence. Now artificial general intelligence which is also known as strong AI, it involves machines

that posses the ability to perform any intelligent

task that a human being can. Now this is actually something that a lot of people don't realize. Machines don't posses

human-like abilities.

They have a very strong processing unit that can perform high-level computations, but they're not yet

capable of doing the simple and the most reasonable

things that a human being can. If you tell a machine to process

like a million documents, it'll probably do that in

a matter of 10 seconds, or a minute, or even 10 minutes. But if you ask a machine to

walk up to your living room and switch on the TV, a machine will take forever to learn that, because machines don't have

the reasonable way of thinking.

They have a very strong processing unit, but they're not yet capable of thinking and reasoning

like a human being. So that's exactly why we're still stuck on artificial narrow intelligence. So far we haven't developed any machine that can fully be called strong AI, even though there are

examples of AlphaGo Zero which defeated AlphaGo in the game of Go.

AlphaGo Zero basically learned

in a span of four months. It learned on its own without

any human intervention. But even then, it was not classified as a fully strong artificial intelligence, because it cannot reason

like a human being. Moving onto artificial super intelligence. Now this is a term referring to the time when the capabilities of a computer will surpass that of a human being. In all actuality, I'll take a while for us to achieve artificial super intelligence.

Presently, it's seen as

a hypothetical situation as depicted in movies and

any science fiction books wherein machines have

taken over the world, movies like Terminator and all of that depict artificial super intelligence. These don't exist yet, which we should be thankful for, but there are a lot of people who speculate that

artificial super intelligence will take over the world by the year 2040. So guys, these were the different types or different stages of

artificial intelligence. To summarize everything,

like I said before, narrow intelligence is the

only thing that exist for now. We have only weak AI or weak

artificial intelligence. All the major AI technologies that you see are artificial narrow intelligence.

We don't have any machines

which are capable of thinking like human beings or

reasoning like a human being. Now let's move on and discuss the different programming language for AI. So there are actually N number of language that can be used for

artificial intelligence. I'm gonna mention a few of them. So, first, we have Python. Python is probably the

most famous language for artificial intelligence. It's also known as the most

effective language for AI, because a lot of developers

prefer to use Python. And a lot of scientists

are also comfortable with the Python language. This is partly because the syntaxes which belong to Python are very simple and they can be learned very easily.

It's considered to be one of the most easiest language to learn. And also many other AI algorithms and machine learning algorithms can be easily implemented in Python, because there are a lot of libraries which are predefined functions

for these algorithms. So all you have to do is you

have to call that function. You don't actually have

to call your algorithm. So, Python is considered the best choice for artificial intelligence. With Python stands R, which is a statistical

programming language. Now R is one of the

most effective language and environment for analyzing

and manipulating the data for statistical purpose. It is a statistical programming language. So using R we can easily produce well designed publication quality plots, including mathematical symbol

and formula, wherever needed. If you ask me, I think

R is also one of the easiest programming language to learn. The syntax is very similar

to English language, and it also has N number of libraries that support statistics, data science, AI, machine learning, and so on. It also has predefined functions for machine learning algorithms, natural language processing, and so on. So R is also a very good choice if you want to get started

with programming languages for machine learning or AI.

Apart from this, we have Java. Now Java can also be

considered as a good choice for AI development. Artificial intelligence has a lot to do with search algorithms, artificial neural networks,

and genetic programming, and Java provides many benefits. It's easy to use. Debugging is very easy, package services. There is simplified work

with large scale projects. There's a good user interaction, and graphical representation of data. It has something known as

the standard widget toolkit, which can be used for making

graphs and interfaces. So, graphic virtualization is actually a very important part of AI, or data science, or machine

learning for that matter. Let me list out a few more languages. We also have something known as Lisp. Now shockingly, a lot

of people have not heard of this language. This is actually the oldest

and the most suited language for the development of

artificial intelligence. It is considered to be a language which is very suited for the development of artificial intelligence.

Now let me tell you that this language was invented by John McCarthy who's also known as the father

of artificial intelligence. He was the person who coined the term artificial intelligence. It has the capability of

processing symbolic information. It has excellent prototyping capabilities. It is easy, and it creates dynamic

objects with a lot of ease. There's automatic garbage

collection in all of that. But over the years,

because of advancements, many of these features have migrated into many other languages. And that's why a lot of

people don't go for Lisp. There are a lot of new languages which have more effective features or which have better packages you can see. Another language I like

to talk about is Prolog. Prolog is frequently

used in knowledge base and expert systems. The features provided by Prolog include pattern matching,

freebase data structuring, automatic back tracking and so on. All of these features provide a very powerful and flexible

programming framework. Prolog is actually widely

used in medical projects and also for designing expert AI systems.

Apart from this, we also have C++, we have SaaS, we have JavaScript which can also be used for AI. We have MATLAB, we have Julia. All of these languages

are actually considered pretty good languages for

artificial intelligence. But for now, if you ask me which programming

language should I go for, I would say Python. Python has all the possible packages, and it is very easy to

understand and easy to learn. So let's look at a couple

of features of Python. We can see why we should go for Python. First of all, Python was created in the year 1989. It is actually a very

easy programming language. That's one of the reasons why a lot of people prefer Python.

It's very easy to understand. It's very easy to grasp this language. So Python is an interpreted,

object-oriented, high-level programming language, and it can be very easily implemented. Now let me tell you a

few features of Python. It's very simple and easy to learn. Like I mentioned, it is one of the easiest

programming language, and it also free and open source. Apart from that, it is

a high-level language. You don't have to worry about anything like memory allocation. It is portable, meaning that you can

use it on any platform like Linux, Windows,

Macintosh, Solaris, and so on. It support different programming paradigms like object-oriented and

procedure oriented programming, and it is extensible, meaning that it can invoke

C and C++ libraries.

Apart from this, let

me tell you that Python is actually gaining unbelievable

huge momentum in AI. The language is used to develop

data science algorithms, machine learning algorithms,

and IoT projects. The other advantages to Python also, the fact that you don't have to code much when it comes to Python

for AI or machine learning. This is because there

are ready-made packages. There are predefined packages that have all the function

and algorithm stored. For example, there is

something known as PiBrain, which can be used for machine learning, NumPy which can be used

for scientific computation, Pandas and so on. There are N number of libraries in Python. So guys, I'm now going to

go into depth of Python. I'm now going to explain Python to you, since this session is about

artificial intelligence.

So, those of you who don't

know much about Python or who are new to Python, I will leave a couple of

links in the description box. You all can get started with programming and any other concepts or any other doubts that you have on Python. We have a lot of content

around programming with Python or Python for machine learning and so on.

Now let's move on and talk about one of the most important aspects of artificial intelligence, which is machine learning. Now a lot of people always

ask me this question. Is machine learning and

artificial intelligence the same thing? Well, both of them are not the same thing. The difference between

AI and machine learning is that machine learning is

used in artificial intelligence. Machine learning is a method through which you can feed

a lot of data to a machine and make it learn. Now AI is a vast of field. Under AI, we have machine

learning, we have NLP, we have expert systems,

we have image recognition, object detection, and so on.

We have deep learning also. So, AI is sort of a process

or it's a methodology in which you make machines mimic the behavior of human beings. Machine learning is a way in which you feed a lot

of data to a machine, so that it can make it's own decisions. Let's get into depth

about machine learning. So first, we'll understand

the need for machine learning or why machine learning

came into existence.

Now the need for machine learning begins since the technical

revolution itself. So, guys, since technology

became the center of everything, we've been generating an

immeasurable amount of data. As per research, we generate around 2.5 quintillion bytes of

data every single data every single day. And it is estimated

that by this year, 2020, 1.7 mb of data will be

created every second for every person on earth. So as I'm speaking to you right now, I'm generating a lot of data. Now your watching this video on YouTube also accounts for data generation. So there's data everywhere.

So with the availability of so much data, it is finally possible to

build predictive models that can study and analyze complex data to find useful insights and

deliver more accurate results. So, top tier companies

like Netflix and Amazon build such machine learning models by using tons of data in order to identify any

profitable opportunity and avoid any unwanted risk. So guys, one thing you

all need to know is that the most important thing

for artificial intelligence is data. For artificial intelligence or whether it's machine

learning or deep learning, it's always data. And now that we have a lot of data, we can find a way to analyze, process, and draw useful insights from this data in order to help us grow businesses or to find solutions to some problems.

Data is the solution. We just need to know

how to handle the data. And the way to handle data is through machine

learning, deep learning, and artificial intelligence. A few reasons why machine

learning is so important is, number one, due to

increase in data generation. So due to excessive production of data, we need to find a method that can be used to structure, analyze, and

draw useful insights from data, this is where machine learning comes in. It is used to solve

problems and find solutions through the most complex

task faced by organizations. Apart form this, we also needed

to improve decision making. So by making use of various algorithms, machine learning can be used to make better business decisions. For example, machine learning

is used to focus sales. It is used to predict any

downfalls n the stock market or identify any sort

of risk and anomalies.

Other reasons include that

machine learning helps us uncover patterns and trends in data. So finding hidden patterns and extracting key insights fro data is the most important

part of machine learning. So by building predictive models and using statistical techniques, machine learning allows you

to dig beneath the surface and explode the data at a minute scale. Understanding data and

extracting patterns manually takes a lot of time. It'll take several days for us to extract any useful

information from data. But if you use machine

learning algorithms, you can perform similar

computations in less than a second. Another reason is we need

to solve complex problems. So from detecting the genes linked to the deadly ALS disease, to building self-driving cars, machine learning can be used to solve the most complex problems.

At present, we also

found a way to spot stars which are 2,400 light

years away from our planet. Okay, all of this is possible through AI, machine learning, deep

learning, and these techniques. So to sum it up, machine learning is very

important at present because we're facing a

lot of issues with data. We're generating a lot of data, and we have to handle this data in such a way that in benefits us. So that's why machine learning comes in. Moving on, what exactly

is machine learning? So let me give you a short

history of machine learning. So machine learning was

first coined by Arthur Samuel in the year 1959, which is just three years from when artificial intelligence was coined. So, looking back, that year was probably the most significant in terms

of technological advancement, because most of the technologies today are based on the concept

of machine learning.

Most of the AI technologies itself are based on the concept of machine learning and deep learning. Don't get confused about machine learning and deep learning. We'll discuss about deep

learning in the further slides, where we'll also see the difference between AI, machine

learning, and deep learning. So coming back to what

exactly machine learning is, if we browse through the internet, you'll find a lot of definitions about what exactly machine learning is. One of the definitions I found was a computer program is said

to learn from experience E with respect to some class of task T and performance measure P if

its performance at task in T, as measured by P, improves

with experience E.

That's very confusing, so let

me just narrow it down to you. In simple terms, machine

learning is a subset of artificial intelligence which provides machines the ability to learn automatically and

improve with experience without being explicitly

programmed to do so. In the sense, it is the practice of getting machines to solve problems by gaining the ability to think. But now you might be thinking how can a machine think or make decisions. Now machines are very similar to humans. Okay, if you feed a machine

a good amount of data, it will learn how to interpret, process, and analyze this data by using

machine learning algorithms, and it will help you solve world problems. So what happens here is a lot of data is fed to the machine. The machine will train on this data and it'll build a predictive model with the help of machine

learning algorithms in order to predict some outcome or in order to find some

solution to a problem. So it involves data. You're gonna train the machine and build a model by using

machine learning algorithms in order to predict some outcome or to find a solution to a problem.

So that is a simple way of understanding what exactly machine learning is. I'll be going into more

depth about machine learning, so don't worry if you have

understood anything as of now. Now let's discuss a couple terms which are frequently

used in machine learning. So, the first definition that

we come across very often is an algorithm. So, basically, a machine

learning algorithm is a set of rules and

statistical techniques that is used to learn patterns from data and draw significant information from it.

Okay. So, guys, the logic behind

a machine learning model is basically the machine

learning algorithm. Okay, an example of a

machine learning algorithm is linear regression, or decision

tree, or a random forest. All of these are machine

learning algorithms. We'll define the logic behind a machine learning model. Now what is a machine learning model? A model is actually the main component of a machine learning process. Okay, so a model is trained by using the machine learning algorithm. The difference between an

algorithm and a model is that an algorithm maps all the decisions that a model is supposed to take based on the given input in order to get the correct output. So the model will use the machine learning algorithm in order to draw useful

insights from the input and give you an outcome

that is very precise.

That's the machine learning model. The next definition we

have is predictor variable. Now a predictor variable

is any feature of the data that can be used to predict the output. Okay, let me give you an example to make you understand what

a predictor variable is. Let's say you're trying to

predict the height of a person, depending on his weight. So here your predictor

variable becomes your weight, because you're using

the weight of a person to predict the person's height. So your predictor variable

becomes your weight. The next definition is response variable. Now in the same example, height would be the response variable. Response variable is also known as the target variable or

the output variable.

This is the variable that

you're trying to predict by using the predictor variables. So a response variable is the feature or the output variable

that needs to be predicted by using the predictor variables. Next, we have something

known as training data. Now training and testing

data are terminologies that you'll come across very often in a machine learning process. So training data is basically

the data that I used to create the machine learning model. So, basically in a

machine learning process, when you feed data into the machine, it'll be divided into two parts. So splitting the data into two parts is also known as data splicing. So you'll take your input data, you'll divide it into two sections. One you'll call the training data, and the other you'll

call the testing data. So then you have something

known as the testing data. The training data is basically used to create the machine learning model. The training data helps

the model to identify key trends and patterns which are essential to predict the output. Now the testing data is,

after the model is trained, it must be tested in order

to evaluate how accurately it can predict an outcome.

Now this is done by

using the testing data. So, basically, the training

data is used to train the model. The testing data is used to test the efficiency of the model. Now let's move on and get our next topic, which is machine learning process. So what is the machine learning process? Now the machine learning process involves building a predictive model that can be used to find a solution for a problem statement. Now in order to solve any

problem in machine learning, there are a couple of steps

that you need to follow.

Let's look at the steps. The first step is you define

the objective of your problem. And the second step is data gathering, which is followed by preparing your data, data exploration, building a model, model evaluation, and

finally making predictions. Now, in order to understand

the machine learning process, let's assume that you've

been given a problem that needs to be solved

by using machine learning.

So the problem that you need to solve is we need to predict the occurrence of rain in your local area by

using machine learning. So, basically, you need to predict the possibility of rain by

studying the weather conditions. So what we did here is we basically looked at step number one, which is define the

objective of the problem. Now here you need to

answer questions such as what are we trying to predict. Is that output going to

be a continuous variable, or is it going to be a discreet variable? These are the kinds of questions

that you need to answer in the first page, which is defining the objective

of the problem, right? So yeah, exactly what

are the target feature. So here you need to understand which is your target variable and what are the different

predictor variables that you need in order

to predict this outcome.

So here our target

variable will be basically a variable that can tell us whether it's going to rain or not. Input data is we'll

need data such as maybe the temperature on a particular day or the humidity level, the

precipitation, and so on. So you need to define the

objective at this stage. So basically, you have to

form an idea of the problem at this storage. Another question that

you need to ask yourself is what kind of problem are you solving. Is this a binary classification problem, or is this a clustering problem, or is this a regression problem? Now, a lo of you might not be familiar with the terms classification clustering and regression in terms

of machine learning.

Don't worry, I'll explain

all of these terms in the upcoming slides. All you need to understand at step one is you need to define how you're

going to solve the problem. You need to understand what sort of data you need to solve the problem, how you're going to approach the problem, what are you trying to predict, what variables you'll need in

order to predict the outcome, and so on. Let's move on and look at step number two, which is data gather. Now in this stage, you must

be asking questions such as, what kind of data is needed

to solve this problem? And is this data available? And if it is available, from

where can I get this data and how can I get the data? Data gathering is one of

the most time-consuming steps in machine learning process. If you have to go manually

and collect the data, it's going to take a lot of time. But lucky for us, there are

a lot of resources online, which were wide data sets. All you need to do is web scraping where you just have to go

ahead and download data.

One of the websites I can

tell you all about is Cargill. So if you're a beginner

in machine learning, don't worry about data

gathering and all of that. All you have to do is go

to websites such as cargill and just download the data set. So coming back to the problem

that we are discussing, which is predicting the weather, the data needed for weather forecasting includes measures like humidity level, the temperature, the

pressure, the locality, whether or not you live in a hill station, such data has to be collected

or stored for analysis. So all the data is collected during the data gathering stage. This step is followed by data preparation, or also known as data cleaning.

So if you're going around collecting data, it's almost never in the right format. And eve if you are taking data from online resources from any website, even then, the data will require

cleaning and preparation. The data is never in the right format. You have to do some sort of preparation and some sort of cleaning in order to make the

data ready for analysis. So what you'll encounter

while cleaning data is you'll encounter a

lot of inconsistencies in the data set, like you'll encounter som missing values, redundant variables, duplicate

values, and all of that.

So removing such inconsistencies

is very important, because they might lead to any wrongful computations and predictions. Okay, so at this stage

you can scan the data set for any inconsistencies, and you can fix them then and there. Now let me give you a small

fact about data cleaning. So there was a survey that

was ran last year or so. I'm not sure. And a lot of data scientists were asked which step was the most

difficult or the most annoying and time-consuming of all. And 80% of the data scientist said it was data cleaning. Data cleaning takes up 80% of their time. So it's not very easy to

get rid of missing values and corrupted data. And even if you get rid of missing values, sometimes your data

set might get affected. It might get biased

because maybe one variable has too many missing values, and this will affect your outcome. So you'll have to fix such issue, we'll have to deal with

all of this missing data and corrupted data. So data cleaning is actually

one of the hardest steps in machine learning process. Okay, now let's move on

and look at our next step, which is exploratory data analysis.

So here what you do is basically become a detective in the stage. So this stage, which is EDA

or exploratory data analysis, is like the brainstorming

stage of machine learning. Data exploration involves

understanding the patterns and the trends in your data. So at this stage, all the

useful insights are drawn and any correlations between

the various variables are understood. What do I mean by trends and

patterns and correlations? Now let's consider our example which is we have to predict the rainfall on a particular day.

So we know that there is a

strong possibility of rain if the temperature has fallen law. So we know that our output will depend on variables such as temperature,

humidity, and so on. Now to what level it

depends on these variables, we'll have to find out that. We'll have to find out the patterns, and we'll find out the correlations between such variables. So such patterns and trends

have to be understood and mapped at this stage. So this is what exploratory

data analysis is about. It's the most important

part of machine learning.

This is where you'll understand what exactly your data is and how you can form the

solution to your problem. The next step in a

machine learning process is building a machine learning module. So all the insights and the patterns that you derive during

the data exploration are used to build a

machine learning model. So this stage always begins

by splitting the data set into two parts, which is

training data and testing data.

I've already discussed with you that the data that you used

in a machine learning process is always split into two parts. We have the training data

and we have the testing data. Now when you're building a model, you always use the training data. So you always make use

of the training data in order to build the model. Now a lot of you might be

asking what is training data. Is it different from the input data that you're feeding with the machine or is it different from the testing data? Now training data is the same input data that you're feeding to the machine. The only difference is that you're splitting the data set into two. You're randomly picking 80% of your data and you're assigning for training purpose. And the rest 20%, probably, you'll assign it for testing purpose.

So guys, always remember

another thing that the training data is always much more than your testing data, obviously because you need

to train your machine. And the more data you feed the machine during the training phase, the better it will be

during the testing phase. Obviously, it'll predict better outcomes if it is being trained on more data. Correct? So the model is basically using the machine learning algorithm

that predicts the output by using the data fed to it. Now in the case of predicting rainfall, the output will be a categorical variable, because we'll be predicting whether it's going to rain or not.

Okay, so let's say we have an

output variable called rain. The two possible values

that this variable can take is yes it's going to rain

and no it won't rain. Correct, so that is out come. Our outcome is a classification

or a categorical variable. So for such cases where your outcome is a categorical variable, you'll be using classification algorithms. Again, example of a

classification algorithm is logistic regression or you can also support vector machines, you can use K nearest neighbor, and you can also use

naive Bayes, and so on.

Now don't worry about these terms, I'll be discussing all

these algorithms with you. But just remember that

while you're building a machine learning model, you'll make use of the training data. You'll train the model by

using the training data and the machine learning algorithm. Now like I said, choosing the

machine learning algorithm, depends on the problem statement that you're trying to solve because of N number of

machine learning algorithms. We'll have to choose the algorithm that is the most suitable

for your problem statement. So step number six is model evaluation and optimization. Now after you've done building a model by using the training data set, it is finally time to

put the model road test. The testing data set is used to check the efficiency of the model and how accurately it

can predict the outcome.

So once the accuracy is calculated, any further improvements in the model can be implemented during this stage. The various methods that can help you improve the performance of the model, like you can use parameter tuning and cross validation methods in order to improve the

performance of the model. Now the main things you need to remember during model evaluation and optimization is that model evaluation is nothing but you're testing how well your

model can predict the outcome. So at this stage, you will be

using the testing data set. In the previous stage,

which is building a model, you'll be using the training data set. But in the model evaluation stage, you'll be using the testing data set. Now once you've tested your model, you need to calculate the accuracy. You need to calculate how accurately your model is predicting the outcome. After that, if you find that you need to improve your model in

some way or the other, because the accuracy is not very good, then you'll use methods

such as parameter tuning.

Don't worry about these terms, I'll discuss all of this with you, but I'm just trying to make sure that you're understanding the concept behind each of the phases

and machine learning. It's very important you

understand each step. Okay, now let's move on and look at the last stage of machine

learning, which is predictions. Now, once a model is evaluated and once you've improved it, it is finally used to make predictions. The final output can either

be a categorical variable or a continuous variable.

Now all of this depends

on your problem statement. Don't get confused about

continuous variables, categorical variables. I'll be discussing all of this. Now in our case, because we're predicting the occurrence of rainfall, the output will be categorical variable. It's obvious because we're predicting whether it's going to rain or not. The result, we understand that this is a classification problem because we have a categorical variable. So that was the entire

machine learning process. Now it's time to learn

about the different ways in which machines can learn. So let's move ahead and look at the types of machine learning. Now this is one of the most interesting concepts in machine learning, the three different ways

in which machines learn.

There is something known

as supervised learning, unsupervised learning, and

reinforcement learning. So we'll go through this one by one. We'll understand what

supervised learning is first, and then we'll look at

the other two types. So defined supervised learning, it is basically a

technique in which we teach or train the machine by using the data, which is well labeled. Now, in order to understand

supervised learning, let's consider a small example. So, as kids, we all needed

guidance to solve math problems. A lot of us had trouble

solving math problems. So our teachers always help

us understand what addition is an dhow it is done.

Similarly, you can think

of supervised learning as a type of machine learning that involves a guide. The label data set is a teacher that will train you to understand

the patterns in the data. So the label data set is nothing

but the training data set. I'll explain more about this in a while. So, to understand

supervised learning better, let's look at the figure on the screen. Right here we're feeding the machine image of Tom and Jerry, and the goal is for

the machine to identify and classify the images into two classes.

One will contain images of Tom and the the other will

contain images of Jerry. Now the main thing that you need to note in supervised learning

is a training data set. The training data set is

going to be very well labeled. Now what do I mean when I say that training data set is labeled. Basically, what we're doing

is we're telling the machine this how Tom looks and

this is how Jerry looks. By doing this, you're training the machine by using label data. So the main thing that you're

doing is you're labeling every input data that

you're feeding to the model. So, basically, you're entire

training data set is labeled. Whenever you're giving an image of Tom, there's gonna be a label

there saying this is Tom. And when you're giving an image of Jerry, you're saying that this

is how Jerry looks. So, basically, you're guiding the machine and you're telling that,

"Listen, this is how Tom looks, "this is how Jerry looks, "and now you need to classify them "into two different classes." That's how supervised learning works.

Apart from that, it's

the same old process. After getting the input data, you're gonna perform data cleaning. Then there's exploratory data analysis, followed by creating the model by using the machine learning algorithm, and then this is followed

by model evaluation, and finally, your predictions. Now, one more thing to note here is that the output that you get by

using supervised learning is also labeled output. So, basically, you'll

get two different classes of name Tom and one of name Jerry, and you'll get them labeled. That is how supervised learning works. The most important thing

in supervised learning is that you're training the model by using labeled data set.

Now let's move on and look

at unsupervised learning. We look at the same example and understand how unsupervised learning works. So what exactly is unsupervised learning? Now this involves training

by using unlabeled data and allowing the model to

act on that information without any guidance. Alright. Like the name suggest itself, there is no supervision here. It's unsupervised learning. So think of unsupervised

learning as a smart kid that learns without any guidance. Okay, in this type of machine learning, the model is not fed with any label data, as in the model has no clue that this is the image of Tom and this is Jerry. It figures out patterns and the difference between

Tom and Jerry on its own by taking in tons and tons of data.

Now how do you think the

machine identifies this as Tom, and then finally gives us the output like yes this is Tom, this is Jerry. For example, it identifies

prominent features of Tom, such as pointy ears,

bigger in size, and so on, to understand that this

image is of type one. Similarly, it finds out features in Jerry, and knows that this image is of type two, meaning that the first image is different from the second image.

So what the unsupervised

learning algorithm or the model does is it'll

form two different clusters. It'll form one cluster

which are very similar, and the other cluster

which is very different from the first cluster. That's how unsupervised learning works. So the important things

that you need to know in unsupervised learning is that you're gonna feed

the machine unlabeled data. The machine has to understand the patterns and discover the output on its own. And finally, the machine

will form clusters based on feature similarity. Now let's move on and locate the last type of machine learning, which is reinforcement learning. Reinforcement learning is quite different when compared to supervised

and unsupervised learning. What exactly is reinforcement learning? It is a part of machine

learning where an agent is put in an environment, and he learns to behave

in this environment by performing certain actions, and observing the rewards which

is gets from those actions.

To understand what

reinforcement learning is, imagine that you were dropped

off at an isolate island. What would you do? Now panic. Yes, of course, initially,

we'll all panic. But as time passes by, you will learn how to live on the island. You will explode the environment, you will understand

the climate conditions, the type of food that grows there, the dangers of the island so on. This is exactly how

reinforcement learning works. It basically involves an agent, which is you stuck on the island, that is put in an unknown

environment, which is the island, where he must learn by

observing and performing actions that result in rewards. So reinforcement learning is mainly used in advanced machine learning areas such as self-driving cars and AlphaGo. I'm sure a lot of you

have heard of AlphaGo. So, the logic behind AlphaGo is nothing but reinforcement

learning and deep learning.

And in reinforcement learning, there is not really any input

data given to the agent. All he has to do is he has to explore everything from scratch it's like a newborn baby with

no information about anything. He has to go around

exploring the environment, and getting rewards, and

performing some actions which results in either rewards or in some sort of punishment. Okay. So that sums up the types

of machine learning. Before we move ahead, I'd like to discuss the difference between the three types

of machine learning, just to make the concept clear to you all.

So let's start by looking

at the definitions of each. In supervised learning, the machine will learn

by using the label data. In unsupervised learning,

they'll be unlabeled data, and the machine has to learn

without any supervision. In reinforcement learning,

there'll be an agent which interacts with the environment by producing actions and

discover errors or rewards based on his actions. Now what are the type of problems that can be solved by using

supervised, unsupervised, and reinforcement learning. When it comes to supervised learning, the two main types of

problems that are solved is regression problems and

classification problems. When it comes to unsupervised learning, it is association and clustering problems. When it comes to reinforcement learning, it's reward-based problems. I'll be discussing

regression, classification, clustering, and all of this

in the upcoming slides, so don't worry if you

don't understand this. Now the type of data which is

used in supervised learning is labeled data. In unsupervised learning, it unlabeled. And in reinforcement learning, we have no predefined data set. The agent has to do

everything from scratch. Now the type of training involved in each of these learnings.

In supervised learning, there

is external supervision, as in there is the labeled data set which acts as a guide

for the machine to learn. In unsupervised learning,

there's no supervision. Again, in reinforcement learning, there's no supervision at all. Now what is the approach to solve problems by using supervised, unsupervised, and reinforcement learning? In supervised learning, it is simple. You have to mal the labeled

input to the known output. The machine knows what

the output looks like. So you're just labeling

the input to the output. In unsupervised learning, you're going to understand the patterns and discover the output. Here you have no clue

about what the input is. It's not labeled. You just have to understand the patterns and you'll have to form clusters

and discover the output. In reinforcement learning,

there is no clue at all. You'll have to follow the

trial and error method. You'll have to go around your environment. You'll have to explore the environment, and you'll have to try some actions.

And only once you perform those actions, you'll know that whether

this is a reward-based action or whether this is a

punishment-based action. So, reinforcement

learning is totally based on the concept of trial and error. Okay. A popular algorithm on the

supervised learning include linear regression, logistic regressions, support vector machines

K nearest neighbor, naive Bayes, and so on. Under unsupervised learning, we have the famous K-means

clustering method, C-means and all of that. Under reinforcement learning, we have the famous learning

Q-learning algorithm. I'll be discussing these

algorithms in the upcoming slides. So let's move on and

look at the next topic, which is the types of problems solved using machine learning. Now this is what we were

talking about earlier when I said regression, classification, and clustering problems. Okay, so let's discuss what

exactly I mean by that.

In machine learning,

all the problems can be classified into three types. Every problem that is

approached in machine learning can be put interest one

of these three categories. Okay, so the first type

is known as a regression, then we have classification

and clustering. So, first, let's look at

regression type of problems. So in this type problem, the output is always

a continuous quantity. For example, if you want to predict the speed of a car, given the distance, it is a regression problem. Now a lot of you might not be very aware of what exactly a continuous quantity is. A continuous quantity is

any quantity that can have an infinite range of values. For example, The weight of a person, it is a continuous quantity, because our weight can be 50, 50.1, 50.001, 5.0021, 50.0321 and so on. It can have an infinite

range of values, correct? So the type of problem

that you have to predict a continuous quantity to make

use of regression algorithms.

So, regression problems can be solved by using supervised learning algorithms like linear regression. Next, we have classification. Now in this type of problem, the output is always a categorical value. Now when I say categorical value, it can be value such as the gender of a person

is a categorical value. Now classifying emails

into two two classes like spam and non-spam is

a classification problem that can be solved by using supervised learning

classification algorithms, like support vector machines, naive Bayes, logistic regression, K

nearest neighbor, and so on.

So, again, the main aim in classification is to compute the category of the data. Coming to clustering problems. This type of problem involves assigned input into two or more clusters based on feature similarity. Thus when I read this sentence, you should understand that

this is unsupervised learning, because you don't have

enough data about your input, and the only option that

you have is to form clusters Categories are formed

only when you know that your data is of two type. Your input data is labeled

and it's of two types, so it's gonna be a classification problem.

But when a clustering problem happens, when you don't have much

information about your input, all you have to do is

you have to find patterns and you have to understand that data points which are similar are clustered into one group, and data points which are

different from the first group are clustered into another group. That's what clustering is. An example is in Netflix what happens is Netflix clusters their

users into similar groups based on their interest,

based on their age, geography, and so on.

This can be done by using

unsupervised learning algorithms like K-means. Okay. So guys, there were the

three categories of problems that can be solved by

using machine learning. So, basically, what I'm trying to say is all the problems will fall

into one of these categories. So any problem that you give

to a machine learning model, it'll fall into one of these categories. Okay. Now to make things a

little more interesting, I have collected real world data sets from online resources. And what we're gonna do is we're

going to try and understand if this is a regression problem, or a clustering problem, or

a classification problem. Okay. Now the problem statement in here is to study the house sales data set, and build a machine learning model that predicts the house pricing index.

Now the most important

thing you need to understand when you read a problem statement is you need to understand

what is your target variable, what are the possible predictor

variable that you'll need. The first thing you should

look at is your targe variable. If you want to understand

if this a classification, regression, or clustering problem, look at your target variable

or your output variable that you're supposed to predict.

Here you're supposed to predict

the house pricing index. Our house pricing index is obviously a continuous quantity. So as soon as you understand that, you'll know that this

is a regression problem. So for this, you can make use of the linear regression algorithm, and you can predict the

house pricing index. Linear regression is the

regression algorithm. It is a supervised learning algorithm. We'll discuss more about

it in the further slides. Let's look at our next problem statement. Here you have to study

a bank credit data set, and make a decision about whether to approve the loan of an applicant based on his profile. Now what is your output

variable over here? Your output variable is

to predict whether you can approve the loan of a applicant or not. So, obviously, your output

is going to be categorical. It's either going to be yes or no. Yes is basically approved loan.

No is reject loan. So here, you understand that this is a classification problem. Okay. So you can make use of

algorithms like KNN algorithm or you can make use of

support vector machines in order to do this. So, support vector machine and KNN which is K nearest neighbor algorithms are basically supervised

learning algorithm. We'll talk more about that

in the upcoming slides. Moving on to our next problem statement. Here the problem statement is to cluster a set of movies as either good or average based on the social media outreach. Now if you look properly, your clue is in the question itself. The first line it says is

to cluster a set of movies as either good or average. Now guys, whenever you

have a problem statement that is asking you to group the data set into different groups or to form different, different clusters, it's obviously a clustering problem. Right here you can make use of the K-means clustering algorithm, and you can form two clusters. One will contain the popular movies and the other will contain

the non-popular movies.

These alright small

examples of how you can use machine learning to

solve clustering problem, the regression, and

classification problems. The key is you need to identify

the type of problem first. Now let's move on and

discuss the different types of machine learning algorithms. So we're gonna start by

discussing the different supervised learning algorithms. So to give you a quick overview, we'll be discussing the linear regression, logistic regression, and decision tree, random forest, naive Bayes classifier, support vector machines,

and K nearest neighbor. We'll be discussing

these seven algorithms. So without any further delay, let's look at linear regression first. Now what exactly is a

linear regression algorithm? So guys, linear regression is basically a supervised learning algorithm that is used to predict a

continuous dependent variable y based on the values of

independent variable x.

Okay. The important thing to note here is that the dependent variable y, the variable that you're

trying to predict, is always going to be

a continuous variable. But the independent variable x, which is basically the

predictor variables, these are the variables

that you'll be using to predict your output variable, which is nothing but

your dependent variable. So your independent variables

or your predictive variables can either be continuous or discreet. Okay, there is not such

a restriction over here. Okay, they can be either

continuous variables or they can be discreet variables. Now, again, I'll tell you

what a continuous variable is, in case you've forgotten. It is a vary that has infinite

number of possibilities. So I'll give you an example

of a person's weight.

It can be 160 pounds, or

they can weigh 160.11 pounds, or 160.1134 pounds and so on. So the number of possibilities

for weight is limitless, and this is exactly what

a continuous variable is. Now in order to understand

linear regression, let's assume that you want to predict the price of a stock over a period of time. Okay. For such a problem, you can

make use of linear regression by starting the relationship between the dependent variable, which is the stock price, and the independent

variable, which is the time. You're trying to predict the stock price over a period of time. So basically, you're gonna

check how the price of a stock varies over a period of time.

So your stock price is going to be your dependent variable

or your output variable, and the time is going to

be your predictor variable or your independent variable. Let's not confuse it anymore. Your dependent variable

is your output variable. Okay, your independent

variable is your input variable or your predictor variable. So in our case, the

stock price is obviously a continuous quantity, because the stock price can have an infinite number of values. Now the first step in linear regression is always to draw out a relationship between your dependent and

your independent variable by using the best fitting linear length.

We make an assumption that your dependent and independent variable is linearly related to each other. We call it linear regression because both the variables vary linearly, which means that by

plotting the relationship between these two variables, we'll get more of a straight

line, instead of a curve. Let's discuss the math

behind linear regression. So, this equation over here, it denotes the relationship between your independent variable x, which is here, and your dependent variable y. This is the variable

you're trying to predict.

Hopefully, we all know that the equation for a linear line in math

is y equals mx plus c. I hope all of you remember math. So the equation for a linear line in math is y equals to mx plus c. Similarly, the linear regression equation is represented along the same line. Okay, y equals to mx plus c. There's just a little bit of changes, which I'll tell you what they are.

Let's understand this equation properly. So y basically stands for

your dependent variable that you're going to predict. B naught is the y intercept. Now y intercept is nothing

but this point here. Now in this graph, you're basically showing the relationship between

your dependent variable y and your independent variable x. Now this is the linear relationship between these two variables. Okay, now your y intercept is basically the point on the line which starts at the y-axis.

This is y interceptor, which is represented by B naught. Now B one or beta is

the slope of this line now the slope can either

be negative or positive, depending on the relationship

between the dependent and independent variable. The next variable that we have is x. X here represents the independent variable that is used to predict our

resulting output variable. Basically, x is used to

predict the value of y. Okay. E here denotes the error

in the computation. For example, this is the actual line, and these dots here represent

the predicted values. Now the distance between these two is denoted by the error

in the computation.

So this is the entire equation. It's quite simple, right? Linear regression will basically draw a relationship between your

input and your input variable. That's how simple linear regression was. Now to better understand

linear regression, I'll be running a demo in Python. So guys, before I get started

with our practical demo, I'm assuming that most of you have a good understanding of Python, because explaining Python is going to be out of the scope of today's session. But if some of you are not familiar with the Python language, I'll leave a couple of links

in the description box. Those will be related

to Python programming. You can go through those

links, understand Python, and then maybe try to understand the demo. But I'd be explaining the logic

part of the demo in depth. So the main thing that

we're going to do here is try and understand linear regression. So it's okay if you do not

understand Python for now. I'll try to explain as much as I can. But if you still want to

understand this in a better way, I'll leave a couple of

links in the description box you can go to those videos.

Let me just zoom in for you. I hope all of you can see the screen. Now in this linear regression demo, what we're going to do is we're going to form a linear relationship between the maximum temperature and minimum temperature

on a particular date. We're just going to do

weather forecasting here. So our task is to predict

the maximum temperature, taking input feature

as minimum temperature. So I'm just going to try

and make you understand linear regression through this demo. Okay, we'll see how it

actually works practically. Before I get started with the demo, let me tell you something

about the data set. Our data set is stored

in this path basically.

The name of the data set is weather.csv. Okay, now, this contains

data on whether conditions recorded on each day at various weather

stations around the world. Okay, the information

include precipitation, snowfall, temperatures, wind speeds, and whether the day

included any thunderstorm or other poor weather conditions. So our first step in

any demo for that matter will be to import all the

libraries that are needed. So we're gonna begin our demo by importing all the required libraries. After that, we're going

to read in our data. Our data will be stored in this variable called data set, and we're going to use a read.csv function since our data set is in the CSV format. After that, I'll be showing you how the data set looks.

We'll also look at the data set in depth. Now let me just show you the output first. Let's run this demo and see first. We're getting a couple of plots which I'll talk about in a while. So we can ignore this warning. It has nothing to do with… So, first of all, we're printing

the shape of our data set. So, when we print the

shape of our data set, This is the output that we get. So, basically, this

shows that we have around 12,000 rows and 31

columns in our data set. The 31 columns basically represent the predictor variables. So you can say that we

have 31 predictor variables in order to protect the weather conditions on a particular date.

So guys, the main aim

in this problem segment is weather forecast. We're going to predict the weather by using a set of predictor variables. So these are the different types of predictor variables that we have. Okay, we have something

known as maximum temperature. So this is what our data set looks like. Now what I'm doing in

this block of code is… What we're doing is we're

plotting our data points on a 2D graph in order to

understand our data set and see if we can manually

find any relationship between the variables.

Here we've taken minimum temperature and maximum temperature

for doing our analysis. So let's just look at this plot. Before that, let me just comment

all of these other plots, so that you see on either

graph that I'm talking about. So, when you look at this graph, this is basically the graph

between your minimum temperature and your maximum temperature. Maximum temperature are dependent variable that you're going to predict. This is y. And your minim temperature is your x. It's basically your independent variable. So if you look at this graph, you can see that there is a sort of linear relationship between the two, except there are a little bit

of outliers here and there.

There are a few data points

which are a little bit random. But apart from that, there is

a pretty linear relationship between your minimum temperature and your maximum temperature. So by this graphic, you can understand that you can easily solve this problem using linear regression, because our data is very linear. I can see a clear straight line over here. This is our first graph. Next, what I'm doing is I'm just checking the average and maximum

temperature that we have. I'm just looking at the

average of our output variable. Okay. So guys, what we're doing here right now is just exploratory data analysis. We're trying to understand our data. We're trying to see the relationship between our input variable

and our output variable. We're trying to see

the mean or the average of the output variable. All of this is necessary

to understand our data set. So, this is what our average

maximum temperature looks like.

So if we try to understand

where exactly this is, so our average maximum temperature is somewhere between 28

and I would say between 30. 28 and 32, somewhere there. So you can say that

average maximum temperature lies between 25 and 35. And so that is our average

maximum temperature. Now that you know a little

bit about the data set, you know that there is a

very good linear relationship between your input variable

and your output variable. Now what you're going

to do is you're going to perform something known as data splicing. Let me just comment that for you. This section is nothing but data splicing.

So for those of you who

are paying attention, know that data splicing is nothing but splitting your data set into

training and testing data. Now before we do that, I mentioned earlier that we'll

be only using two variables, because we're trying to understand

the relationship between the minimum temperature

and maximum temperature. I'm doing this because

I want you to understand linear regression in the

simplest way possible. So guys, in order to make

understand linear regression, I have just derived only two

variables from a data set. Even though when we check

the structure of a data set, we had around 31 features, meaning that we had 31 variables which include my predictor

variable and my target variable. So, basically, we had

30 predictor variables and we had one target variable, which is your maximum temperature. So, what I'm doing here

is I'm only considering these two variables, because I want to show you exactly how linear regression works.

So, here what I'm doing is I'm basically extracting only these two variables from our data set, storing it in x and y. After that, I'm performing data splicing. So here, I'm basically splitting the data into training and testing data, and remember one point that I am assigning 20% of the data to our testing data set, and the remaining 80% is

assigned for training. That's how training works. We assign maximum data set for training. We do this because we want

the machine learning model or the machine learning algorithm

to train better on data. We wanted to take as

much data as possible, so that it can predict

the outcome properly. So, to repeat it again for you, so here we're just splitting the data into training and testing data set. So, one more thing to note here is that we're splitting 80% of

the data from training, and we're assigning the 20%

of the data to test data. The test size variable,

this variable that you see, is what is used to specify the proportion of the test set. Now after splitting the data

into training and testing set, finally, the time is

to train our algorithm.

For that, we need to import

the linear regression class. We need to instantiate it and call the fit method

along with the training data. This is our linear regression class, and we're just creating an instance of the linear regression class. So guys, a good thing about Python is that you have pre-defined

classes for your algorithms, and you don't have call your algorithms. Instead, all you have to do, is you call this class

linear regression class, and you have to create an instance of it. Here I'm basically creating

something known as a regressor. And all you have to do is you

have to call the fit method along with your training data. So this is my training

data, x train and y train contains my training data, and I'm calling our linear

regression instance, which is regressor,

along with this data set. So here, basically,

we're building the model.

We're doing nothing

but building the model. Now, one of the major things that linear regression model does is it finds the best value for

the intercept and the slope, which results in a line

that best fits the data. I've discussed what

intercept and slope is. So if you want to see the

intercept and the slope calculated by our linear regression model, we just have to run this line of code. And let's looks at the output for that. So, our intercept is around 10.66 and our coefficient, these are also known as beta coefficients, coefficient are nothing but

what we discussed, beta naught. These are beta values. Now this will just help you understand the significance of your input variables. Now what this coefficient value means is, see, the coefficient value is around 0.92. This means that for every one unit changed of your minimum temperature, the change in the maximum

temperature is around 0.92. This will just show you how significant your input variable is.

So, for every one unit change

in your minimum temperature, the change in the maximum temperature will be around 0.92. I hope you've understood this part. Now that we've trained our algorithm, it's trying to make some predictions. To do so, what we'll use is

we'll use our test data set, and we'll see how accurately our algorithm predicts the percentage score. Now to make predictions, we have this line of code. Predict is basically a

predefined function in Python. And all you're going to

do is you're going to pass your testing data set to this.

Now what you'll do is you'll compare the actual output values, which is basically stored in your y test. And you'll compare these

to the predicted values, which is in y prediction. And you'll store these

comparisons in our data frame called df. And all I'm doing here is

I'm printing the data frame. So if you look at the output,

this is what it looks like.

These are your actual values and these are the values

that you predicted by building that model. So, if your actual value is 28, you predicted around 33, here your actual value is 31, meaning that your maximum

temperature is 31. And you predicted a

maximum temperature of 30. Now, these values are

actually pretty close. I feel like the accuracy

is pretty good over here. Now in some cases, you see

a lot of variance, like 23. Here it's 15. Right here it's 22. Here it's 11. But such cases are very often. And the best way to improve

your accuracy I would say is by training a model with more data. Alright. You can also view this

comparison in the form of a plot. Let's see how that looks. So, basically, this is a bar graph that shows our actual values

and our predicted values. Blue is represented by your actual values, and orange is represented

by your predicted values. At places you can see that we've predicted pretty well, like the predictions are pretty close to the actual values. In some cases, the predictions

are varying a little bit. So in a few places, it

is actually varying, but all of this depends on

your input data as well.

When we saw the input data, also we saw a lot of variation. We saw a couple of outliers. So, all that also might

effect your output. But then this is how you

build machine learning models. Initially, you're never going to get a really good accuracy. What you should do is you have to improve your training process. That's the best way

you can predict better, either you use a lot of data, train your model with a lot of data, or you use other methods

like parameter tuning, or basically you try and find

another predictor variable that'll help you more in

predicting your output.

To me, this looks pretty good. Now let me show you another plot. What we're doing is we're

drawing a straight line plot. Okay, let's see how it looks. So guys, this straight line represents a linear relationship. Now let's say you get a new data point. Okay, let's say the

value of x is around 20. So by using this line, you can predict that four a

minimum temperature of 20, your maximum temperature

would be around 25 or something like that. So, we basically drew

a linear relationship between our input and

output variable over here. And the final step is to evaluate the performance of the algorithm.

This step is particularly

important to compare how well different algorithms perform on a particular data set. Now for regression algorithms, three evaluation metrics are used. We have something known

as mean absolute error, mean squared error, and

root mean square error. Now mean absolute error is nothing but the absolute value of the errors. Your mean squared error is a

mean of the squared errors. That's all. It's basically you read

this and you understand what the error means. A root mean squared

error is the square root of the mean of the squared errors. Okay. So these are pretty simple to understand your mean absolute error,

your mean squared errors, your root mean squared error. Now, luckily, we don't

have to perform these calculations manually. We don't have to code each

of these calculations. The cycle on library comes

with prebuilt functions that can be used to find out these values.

Okay. So, when you run this code, you will get these values for each of the errors. You'll get around 3.19 as

the mean absolute error. Your mean squared error is around 17.63. Your root mean squared

error is around 4.19. Now these error values basically show that our model accuracy is not very precise, but it's still able to

make a lot of predictions. We can draw a good linear relationship. Now in order to improve

the efficiency at all, there are a lot of methods like this, parameter tuning and all of that, or basically you can train your

model with a lot more data. Apart from that, you can use

other predictor variables, or maybe you can study

the relationship between other predictor variables and your maximum temperature variable. There area lot of ways to improve the efficiency of the model. But for now, I just wanted

to make you understand how linear regression works, and I hope all of you have

a good idea about this. I hope all of you have

a good understanding of how linear regression works.

This is a small demo about it. If any of you still have any doubts, regarding linear regression, please leave that in the comment section. We'll try and solve all your errors. So, if you look at this equation, we calculated everything here. we drew a relationship between y and x, which is basically x was

our minimum temperature, y was our maximum temperature. We also calculated the

slope and the intercept.

And we also calculated

the error in the end. We calculated mean squared error we calculated the root mean squared error. We also calculate the mean absolute error. So that was everything

about linear regression. This was a simple linear regression model. Now let's move on and look

at our next algorithm, which is a logistic regression. Now, in order to understand

why we use logistic regression, let's consider a small scenarios. Let's say that your little sister is trying to get into grad school and you want to predict

whether she'll get admitted in her dream school or not.

Okay, so based on her

CGPA and the past data, you can use logistic regression to foresee the outcome. So logistic regression

will allow you to analyze the set of variables and

predict a categorical outcome. Since here we need to

predict whether she will get into a school or not, which is a classification problem, logistic regression will be used. Now I know the first

question in your head is, why are we not using linear

regression in this case? The reason is that linear regression is used to predict a continuous quantity, rather than a categorical one.

Here we're going to predict whether or not your sister is

going to get into grad school. So that is clearly a categorical outcome. So when the result in outcome can take only classes of values, like two classes of values, it is sensible to have a

model that predicts the value as either zero or one, or in a probability form that

ranges between zero and one. Okay. So linear regression does

not have this ability. If you use linear regression to model a binary outcome, the resulting model will

not predict y values in the range of zero and one, because linear regression works on continuous dependent variables, and not on categorical variables. That's why we make use

of logistic regression. So understand that linear

regression was used to predict continuous quantities, and logistic regression is used to predict categorical quantities. Okay, now one major

confusion that everybody has is people keep asking me why is logistic regression

called logistic regression when it is used for classification. The reason it is named logistic regression is because its primary technique is very similar to logistic regression.

There's no other reason behind the naming. It belongs to the general linear models. It belongs to the same

class as linear regression, but that is not the other reason behind the name logistic regression. Logistic regression is mainly used for classification purpose, because here you'll have to

predict a dependent variable which is categorical in nature. So this is mainly used for classification. So, to define logistic regression for you, logistic regression is

a method used to predict a dependent variable y, given an independent variable x, such that the dependent

variable is categorical, meaning that your output

is a categorical variable. So, obviously, this is

classification algorithm. So guys, again, to clear your confusion, when I say categorical variable, I mean that it can hold

values like one or zero, yes or no, true or false, and so on.

So, basically, in logistic regression, the outcome is always categorical. Now, how does logistic regression work? So guys, before I tell you

how logistic regression works, take a look at this graph. Now I told you that the outcome in a logistic regression is categorical. Your outcome will either be zero or one, or it'll be a probability that

ranges between zero and one. So, that's why we have this S curve. Now some of you might think

that why do we have an S curve. We can obviously have a straight line. We have something known

as a sigmoid curve, because we can have values

ranging between zero and one, which will basically show the probability. So, maybe your output will be 0.7, which is a probability value. If it is 0.7, it means that your

outcome is basically one. So that's why we have this

sigmoid curve like this. Okay.

Now I'll explain more about this in depth in a while. Now, in order to understand

how logistic regression works, first, let's take a look at the linear regression equation. This was the logistic regression equation that we discussed. Y here stands for the dependent variable that needs to be predicted beta naught is nothing by the y intercept. Beta one is nothing but the slope. And X here represents

the independent variable that is used to predict y. That E denotes the error

on the computation. So, given the fact that x

is the independent variable and y is the dependent variable, how can we represent a

relationship between x an y so that y ranges only

between zero and one? Here this value basically denotes probably of y equal to one, given some value of x. So here, because this

Pr, denotes probability and this value basically

denotes that the probability of y equal to one, given some value of x, this is what we need to find out.

Now, if you wanted to

calculate the probability using the linear regression model, then the probability

will look something like P of X equal to beta naught plus beta one into X. P of X will be equal to beta

naught plus beta one into X, where P of X nothing but your probability of

getting y equal to one, given some value of x. So the logistic regression equation is derived from the same equation, except we need to make a few alterations, because the output is only categorical. So, logistic regression does

not necessarily calculate the outcome as zero or one. I mentioned this before. Instead, it calculates the

probability of a variable falling in the class zero or class one. So that's how we can conclude that the resulting variable must be positive, and it should lie between zero and one, which means that it must be less than one. So to meet these conditions, we have to do two things. First, we can take the

exponent of the equation, because taking an exponential of any value will make sure that you

get a positive number. Correct? Secondly, you have to make sure that your output is less than one.

So, a number divided by itself plus one will always be less than one. So that's how we get this formula First, we take the

exponent of the equation, beta naught plus beta one plus x and then we divide it

by that number plus one. So this is how we get this formula. Now the next step is to calculate something known as a logic function. Now the logic function is nothing, but it is a link function that is represented as an S curve or as a sigmoid curve that ranges between

the value zero and one. It basically calculates the probability of the output variable. So if you look at this

equation, it's quite simple. What we have done here

is we just cross multiply and take each of our beta naught plus beta one into x as common. The RHS denotes the linear equation for the independent variables. The LHS represents the odd ratio.

So if you compute this entire thing, you'll get this final value, which is basically your

logistic regression equation. Your RHS here denotes the linear equation for independent variables, and your LHS represents the odd ratio which is also known as the logic function. So I told you that logic function is basically a function

that represents an S curve that bring zero and one. this will make sure that our value ranges between zero and one. So in logistic regression, on increasing this X by one measure, it changes the logic by

a factor of beta naught. It's the same thing as I showed

you in logistic regression.

So guys, that's how you derive the logistic regression equation. So if you have any doubts

regarding these equations, please leave them in the comment section, and I'll get back to you,

and I'll clear that out. So to sum it up, logistic

regression is used for classification. The output variable will always

be a categorical variable. We also saw how you derive the

logistic regression equation. And one more important thing is that the relationship between the variables and a logistic regression is denoted as an S curve which is also

knows as a sigmoid curve, and also the outcome does not necessarily have to be

calculated as zero or one. It can be calculate as a probability that the output lies in

class one or class zero. So your output can be a probability ranging between zero and one. That's why we have a sigmoid curve.

So I hope all of you are clear

with logistic regression. Now I won't be showing

you the demo right away. I'll explain a couple of more

classification algorithms. Then I'll show you a practical demo where we'll use multiple

classification algorithms to solve the same problem. Again, we'll also calculate the accuracy and se which classification

algorithm is doing the best. Now the next algorithm

I'm gonna talk about is decision tree.

Decision tree is one of

my favorite algorithms, because it's very simple to understand how a decision tree works. So guys, before this, we

discussed linear regression, which was a regression algorithm. Then we discussed logistic regression, which is a classification algorithm. Remember, don't get confused just because it has the name logistic regression. Okay, it is a classification algorithm. Now we're discussing decision tree, which is again a classification algorithm. Okay. So what exactly is a decision tree? Now a decision tree is, again, a supervised machine learning algorithm which looks like an inverted tree wherein each node represents

a predictor variable, and the link between the

node represents a decision, and each leaf node represents an outcome. Now I know that's a little confusing, so let me make you understand

what a decision tree is with the help of an example. Let's say that you hosted a huge party, and you want to know

how many of your gusts are non-vegetarians. So to solve this problem, you can create a simple decision tree. Now if you look at this figure over here, I've created a decision

tree that classifies a guest as either vegetarian or non-vegetarian.

Our last outcome here is non-veg or veg. So here you understand that this is a classification algorithm, because here you're predicting

a categorical value. Each node over here represents

a predictor variable. So eat chicken is one variable, eat mutton is one variable, seafood is another variable. So each node represents

a predictor variable that will help you conclude whether or not a guest is a non-vegetarian. Now as you traverse down the tree, you'll make decisions that each node until you reach the dead end.

Okay, that's how it works. So, let's say we got a new data point. Now we'll pass it through

the decision tree. The first variable is did the guest eat the chicken? If yes, then he's a non-vegetarian. If no, then you'll pass

it to the next variable, which is did the guest eat mutton? If yes, then he's a non-vegetarian. If no, then you'll pass

it to the next variable, which is seafood. If he ate seafood, then

he is a non-vegetarian. If no, then he's a vegetarian. this is how a decision tree works. It's a very simple algorithm that you can easily understand. It has drawn out letters, which

is very easy to understand. Now let's understand the

structure of a decision tree. I just showed you an example of how the decision tree works. Now let me take the same example and tell you the structure

for decision tree.

So, first of all, we have

something known as the root node. Okay. The root node is the starting point of a decision tree. Here you'll perform the first split and split it into two other nodes or three other nodes, depending

on your problem statement. So the top most node is

known as your root node. Now guys, about the root node, the root node is assigned to a variable that is very significant, meaning that that

variable is very important in predicting the output. Okay, so you assign a variable that you think is the most

significant at the root node.

After that, we have something

known as internal nodes. So each internal node

represents a decision point that eventually leads to the output. Internal nodes will have

other predictor variables. Each of these are nothing

predictor variables. I just made it into a question otherwise these are just

predictor variables. Those are internal nodes. Terminal nodes, also

known as the leaf node, represent the final class

of the output variable, because these are basically your outcomes, non-veg and vegetarian. Branches are nothing but

connections between nodes. Okay, these connections are links between each node is known as a branch, and they're represented by arrows. So each branch will have

some response to it, either yes or no, true or

false, one or zero, and so on.

Okay. So, guys, this is the

structure of a decision tree. It's pretty understandable. Now let's move on and we'll understand how the

decision tree algorithm works. Now there are many ways

to build a decision tree, but I'll be focusing on something known as the ID3 algorithm. Okay, this is something

known as the ID3 algorithm. That is one of the ways

in which you can build the decision tree. ID3 stands for Iterative

Dichotomiser 3 algorithm, which is one of the most

effective algorithms used to build a decision tree.

It uses the concepts of

entropy and information gain in order to build a decision tree. Now you don't have to know what exactly the ID3 algorithm is. It's just a concept behind

building a decision tree. Now the ID3 algorithm has

around six defined steps in order to build a decision tree. So the first step is you will

select the best attribute. Now what do you mean

by the best attribute? So, attribute is nothing but the predictor variable over here. So you'll select the

best predictor variable. Let's call it A. After that, you'll assign this A as a decision variable for the root node.

Basically, you'll assign

this predictor variable A at the root node. Next, what you'll do

is for each value of A, you'll build a descendant of the node. Now these three steps, let's look at it with the previous example. Now here the best

attribute is eat chicken. Okay, this is my best

attribute variable over here. So I selected that attribute. And what is the next step? Step two was assigned that

as a decision variable. So I assigned eat chick

as the decision variable at the root node. Now you might be wondering how do I know which is the best attribute. I'll explain all of that in a while. So what we did is we assigned

this other root node.

After that, step number three

says for each value of A, build a descendant of the node. So for each value of this variable, build a descendant node. So this variable can take

two values, yes and no. So for each of these values, I build a descendant node. Step number four, assign

classification labels to the leaf node. To your leaf node, I have assigned classification one as

non-veg, and the other is veg. That is step number four. Step number five is if data

is correctly classified, then you stop at that. However, if it is not, then you keep iterating over the tree, and keep changing the position of the predictor variables in the tree, or you change the root node also in order to get the correct output. So now let me answer this question. What is the best attribute? What do you mean by the best attribute or the best predictor variable? Now the best attribute is the one that separates the data

into different classes, most effectively, or it is basically a feature that best splits the data set.

Now the next question in your

head must be how do I decide which variable or which

feature best splits the data. To do this, there are

two important measures. There's something known

as information gain and there's something known as entropy. Now guys, in order to understand information gain and entropy, we look at a simple problem statement. This data represents the speed of a car based on certain parameters. So our problem statement

here is to study the data set and create a decision tree that classifies the speed of the car

as either slow or fast. So our predictor variables

here are road type, obstruction, and speed limit, and or response variable, or

our output variable is speed. So we'll be building a decision

tree using these variables in order to predict the speed of car. Now like I mentioned earlier, we must first begin by deciding a variable that best splits the data set and assign that particular

variable to the root node and repeat the same thing

for other nodes as well.

So step one, like we discussed earlier, is to select the best attribute A. Now, how do you know which

variable best separates the data? The variable with the

highest information gain best derives the data into

the desired output classes. First of all, we'll

calculate two measures. We'll calculate the entropy

and the information gain. Now this is where it ell

you what exactly entropy is, and what exactly information gain is.

Now entropy is basically used to measure the impurity or the uncertainty

present in the data. It is used to decide how a

decision tree can split the data. Information gain, on the other hand, is the most significant measure which is used to build a decision tree. It indicates how much

information a particular variable gives us a bout the final outcome. So information gain is important, because it is used to choose a variable that best splits the data at each node for a decision tree. Now the variable with the

highest information gain will be used to split the

data at the root node.

Now in our data set, there

are are four observations. So what we're gonna do is

we'll start by calculating the entropy and information gain for each of the predictor variable. So we're gonna start by

calculating the information gain and entropy for the road type variable. In our data set, you can see that there are four observations. There are four observations

in the road type column, which corresponds to the four

labels in the speed column. So we're gonna begin by

calculating the information gain of the parent node. The parent node is nothing but

the speed of the care node. This is our output variable, correct? It'll be used to show

whether the speed of the car is slow or fast. So to find out the information gain of the speed of the car variable, we'll go through a couple of steps. Now we know that there

are four observations in this parent node. First, we have slow. Then again we have slow, fast, and fast.

Now, out of these four

observations, we have two classes. So two observations

belong to the class slow, and two observations

belong to the class fast. So that's how you calculate

P slow and P fast. P slow is nothing by the fraction of slow outcomes in the parent node, and P fast is the

fraction of fast outcomes in the parent node. And the formula to calculate P slow is the number of slow

outcomes in the parent node divided by the total number of outcomes. So the number of slow outcomes

in the parent node is two, and the total number of outcomes is four. We have four observations in total. So that's how we get P of slow as 0.5. Similarly, for P of fast, you'll calculate the number of fast outcomes divided by the total number of outcomes. So again, two by four, you'll get 0.5. The next thing you'll

do is you'll calculate the entropy of this node. So to calculate the entropy,

this is the formula. All you have to do is you

have to substitute the, you'll have to substitute

the value in this formula.

So P of slow we're substituting as 0.5. Similarly, P of fast as 0.5. Now when you substitute the value, you'll get a answer of one. So the entropy of your parent node is one. So after calculating the

entropy of the parent node, we'll calculate the information

gain of the child node. Now guys, remember that

if the information gain of the road type variable is

great than the information gain of all the other predictor variables, only then the root node

can be split by using the road type variable. So, to calculate the information

gain of road type variable, we first need to split the root node by sing the road type variable. We're just doing this in order to check if the road type variable is giving us maximum

information about a data. Okay, so if you notice that

road type has two outcomes, it has two values, either steep or flat. Now go back to our data set. So here what you can notice is whenever the road type is steep, so first what we'll do is we'll check the value of speed that we get when the road type is steep.

So, first, observation. You see that whenever

the road type is steep, you're getting a speed of slow. Similarly, in the second observation, when the road type is steep, you'll get a value of slow again. If the road type is flat, you'll

get an observation of fast. And again, if it is steep,

there is a value of fast. So for three steep values, we have slow, slow, and fast. And when the road type is flat, we'll get an output of fast.

That's exactly what I've

done in this decision tree. So whenever the road type is steep, you'll get slow, slow or fast. And whenever the road type is flat, you'll get fast. Now the entropy of the

right-hand side is zero. Entropy is nothing but the uncertainty. There's no uncertainty over here. Because as soon as you see

that the road type is flat, your output is fast. So there's no uncertainty. But when the road type is steep, you can have any one of

the following outcomes, either your speed will be slow or it can be fast. So you'll start by calculating the entropy of both RHS and LHS of the decision tree.

So the entropy for the right

side child node will be zero, because there's no uncertainty here. Immediately, if you see

that the road type is flat, your speed of the car will be fast. Okay, so there's no uncertainty here, and therefore your entropy becomes zero. Now entropy for the left-hand side is we'll again have to calculate the fraction of P slow and

the fraction of P fast. So out of three observations, in two observations we have slow.

That's why we have two by three over here. Similarly for P fast, we have one P fast divided by the total number of

observation which are three. So out of these three, we

have two slows and one fast. When you calculate P slow and P fast, you'll get these two values. And then when you substitute

the entropy in this formula, you'll get the entropy as 0.9

for the road type variable. I hope you all are understanding this. I'll go through this again. So, basically, here we are calculating the information gain and

entropy for road type variable. Whenever you consider road type variable, there are two values, steep and flat. And whenever the value

for road type is steep, you'll get anyone of these three outcomes, either you'll get slow, slow, or fast. And when the road type is flat, your outcome will be fast. Now because there is no uncertainty whenever the road type is flat, you'll always get an outcome of fast. This means that the entropy here is zero, or the uncertainty value here is zero.

But here, there is a lot of uncertainty. So whenever your road type is steep, your output can either be

slow or it can be fast. So, finally, you get the Python as 0.9. So in order to calculate

the information gain of the road type variable. You need to calculate

the weighted average. I'll tell you why. In order to calculate

the information gain, you need to know the

entropy of the parent, which we calculate as one, minus the weighted

average into the entropy of the children. Okay. So for this formula, you need to calculate all of these values.

So, first of all, you need

to calculate the entropy of the weighted average. Now the total number of

outcomes in the parent node we saw were four. The total number of outcomes in the left child node were three. And the total number of

outcomes in the right child node was one. Correct? In order to verify this with you, the total number of outcomes

in the parent node are four. One, two, three, and four. Coming to the child node,

which is the road type, the total number of outcomes

on the right-hand side of the child node is one. And the total number of outcomes on the left-hand side of

the child node is three. That's exactly what

I've written over here. Alright, I hope you all

understood these three values. After that, all you have to do is you have to substitute these

values in this formula.

So when you do that, you'll get the entropy of the children

with weighted average will be around 0.675. Now just substitute the

value in this formula. So if you calculate the information gain of the road type variable, you'll get a value of 0.325. Now by using the same method, you're going to calculate

the information gain for each of the predictor variable, for road type, for obstruction,

and for speed limit. Now when you follow the same method and you calculate the information gain, you'll get these values. Now what does this

information gain for road type equal to 0.325 denote? Now the value 0.325 for

road type denotes that we're getting very little information gain from this road type variable. And for obstruction, we literally have information gain of zero. Similarly, information gained

for speed limit is one.

This is the highest value

we've got for information gain. This means that we'll have to

use the speed limit variable at our root node in order

to split the data set. So guys, don't get

confused whichever variable gives you the maximum information gain. That variable has to be

chosen at the root node. So that's why we have the

root node as speed limit. So if you've maintained the speed limit, then you're going to go slow. But if you haven't

maintained the speed limit, then the speed of your

car is going to be fast. Your entropy is literally zero, and your information is one, meaning that you can use this

variable at your root node in order to split the data set, because speed limit gives you

the maximum information gain. So guys, I hope this use

case is clear to all of you. To sum everything up, I'll just repeat the entire

thing to you all once more. So basically, here you were

given a problem statement in order to create a decision tree that classifies the speed of

a car as either slow or fast.

So you were given three

predictor variables and this was your output variable. Information gained in entropy

are basically two measures that are used to decide which variable will be assigned to the root

node of a decision tree. Okay. So guys, as soon as you

look at the data set, if you compare these two columns, that is speed limit and speed, you'll get an output easily. Meaning that if you're

maintaining speed limit, you're going to go slow. But if you aren't maintaining speed limit, you're going to a fast. So here itself we can

understand the speed limit has no uncertainty. So every time you've

maintained your speed limit, you will be going slow, and every time your

outside or speed limit, you will be going fast. It's as simple as that. So how did you start? So you started by calculating the entropy of the parent node.

You calculated the entropy

of the parent node, which came down to one. Okay. After that, you calculated

the information gain of each of the child nodes. In order to calculate the information gain of the child node, you stat by calculating the entropy of the right-hand side

and the left-hand side of the decision tree. Okay. Then you calculate the entropy along with the weighted average. You substitute these values in

the information gain formula, and you get the information gain for each of the predictor variables.

So after you get the information gain of each of the predictor variables, you check which variable gives you the maximum information gain, and you assign that

variable to your root node. It's as simple as that. So guys, that was all

about decision trees. Now let's look at our next

classification algorithm which is random forest. Now first of all, what is a random forest? Random forest basically

builds multiple decision trees and glues them together

to get a more accurate and stable prediction. Now if already have decision trees and random forest is nothing but a collection of decision tree, why do we have to use a random forest when we already have decision tree? There are three main reasons

why random forest is used. Now even though decision

trees are convenient and easily implemented, they are not as accurate as random forest. Decision trees work very effectively with the training data, backup they're not flexible when it comes to classifying anew sample. Now this happens because of

something known as overfitting.

Now overfitting is a problem that is seen with decision trees. It's something that commonly occurs when we use decision trees. Now overfitting occurs

when a model studies a training data to such an extent that it negatively influences the performance of the

model on a new data. Now this means that the disturbance in the training data is recorded, and it is learned as concept by the model. If there's any disturbance or any thought of noise

in the training data or any error in the training data, that is also studied by the model. The problem here is that these concepts do not apply to the testing data, and it negatively impacts

the model's ability to classify new data.

So to sum it up, overfitting occurs whenever your model learns the training data, along with all the disturbance

in the training data. So it basically memorized

the training data. And whenever a new data

will be given to your model, it will not predict the

outcome very accurately. now this is a problem

seen in decision trees. Okay. But in random forest, there's

something known as bagging. Now the basic idea behind bagging is to reduce the variations

and the predictions by combining the result

of multiple decision trees on different samples of the data set.

So your data set will be

divided into different samples, and you'll be building a decision tree on each of these samples. This way, each decision

tree will be studying one subset of your data. So this way over fitting will get reduced because one decision tree is not studying the entire data set. Now let's focus on random forest. Now in order to understand random forest, we look at a small example.

We can consider this data set. In this data, we have

four predictor variables. We have blood flow, blocked arteries, chest pain, and weight. Now these variables are used to predict whether or not a person

has a heart disease. So we're going to use this data set to create a random forest that predicts if a person has a heart disease or not. Now the first step in

creating a random forest is that you create a bootstrap data set. Now in bootstrapping, all you have to do is you have to randomly select samples from your original data set. Okay. And a point to note is that

you can select the same sample more than once. So if you look at the original data set, we have a abnormal, normal,

normal, and abnormal. Look at the blood flow section.

Now here I've randomly selected samples, normal, abnormal, and I've selected one sample twice. You can do this in a bootstrap data set. Now all I did here is I created a bootstrap data set. Boot strapping is nothing

but an estimation method used to make predictions on a data by re-sampling the data. This is a bootstrap data set. Now even though this seems very simple, in real world problems, you'll never get such small data set. Okay, so bootstrapping is actually a little

more complex than this. Usually in real world problems, you'll have a huge data set, and bootstrapping that

data set is actually a pretty complex problem.

I'm here because I'm making you understand how random forest works, so that's why I've

considered a small data set. Now you're going to use

the bootstrap data set that you created, and you're going to build

decision trees from it. Now one more thing to

note in random forest is you will not be using

your entire data set. Okay, so you'll only be

using few other variables at each node. So, for example, we'll

only consider two variables at each step. So if you begin at the root node here, we will randomly select two variables as candidates for the root node. Okay, let's say that

we selected blood flow and blocked arteries. Out of these two variables we

have to select the variable that best separates the sample. Okay. So for the sake of this example, let's say that blocked arteries is the most significant predictor, and that's why we'll

assign it to the root node.

Now our next step is to

repeat the same process for each of these upcoming branch nodes. Here we'll again select

two variables at random as candidates for each

of these branch nodes, and then choose a variable that best separates the samples, right? So let me just repeat this entire process. So you know that you start

creating a decision tree by selecting the root node. In random forest, you'll randomly select a couple of variables for each node, and then you'll calculate which variable best splits the data at that node. So for each node, we'll randomly select two or three variables. And out of those two, three variables, we'll see which variable

best separates the data. Okay, so at each node, we'll because calculating

information gain an entropy. Basically, that's what I mean. At every node, you'll

calculate information gain and entropy of two or three variables, and you'll see which variable has the highest information gain, and you'll keep descending downwards.

That's how you create a decision tree. So we just created our

first decision tree. Now what you do is you'll

go back to step one, and you'll repeat the entire process. So each decision tree will

predict the output class based on the predictor variables that you've assigned

to each decision tree. Now let's say for this decision tree, you've assigned blood flow. Here we have blocked

arteries at the root node. Here we might have blood flow

at the root node and so on. So your output will depend

on which predictor variable is at the root node. So each decision tree will

predict the output class based on the predictor variable that you assigned in that tree. Now what you do is you'll

go back to step one, you'll create a new bootstrap data set, and then again you'll

build a new decision tree.

And for that decision tree, you'll consider only

a subset of variables, and you'll choose the

best predictor variable by calculating the information gain. So you will keep repeating this process. So you just keep repeating

step two and step one. Okay. And you'll keep creating

multiple decision trees. Okay. So having a variety of decision

trees in a random forest is what makes it more effective than an individual decision tree. So instead of having an

individual decision tree, which is created using all the features, you can build a random forest that uses multiple decision trees wherein each decision

tree has a random set of predictor variables. Now step number four is

predicting the outcome of a new data point. So now that you've

created a random forest, let's see how it can be used to predict whether a new patient

has a heart disease or not.

Okay, now this diagram

basically has a data about the new patient. Okay, this is the data

about the new patient. He doesn't have blocked arteries. He has chest pain, and his

weight is around 185 kgs. Now all you have to do is

you have to run this data down each of the decision

trees that you made. So, the first decision tree shows that yes, this person has heart disease. Similarly, you'll run the

information of this new patient through every decision

tree that you created. Then depending on how many

votes you get for yes and no, you'll classify that patient as either having heart disease or not. All you have to do is you have to run the information of the new patient through all the decision

trees that you created in the previous step, and the final output is

based on the number of votes each of the class is getting.

Okay, let's say that three decision trees said that yes the patient

has heart disease, and one decision tree said

that no it doesn't have. So this means you will obviously classify the patient as having a heart disease because three of them voted for yes. It's based on majority. So guys, I hope the concept

behind random forest is understandable. Now the next step is you will evaluate the efficiency of the model.

Now earlier when we created

the bootstrap data set we left out one entry sample. This is the entry sample we left out, because we repeated one sample twice. If you'll remember in

the bootstrap data set, here we repeated an entry twice, and we missed out on one of the entries. We missed out on one of the entries. So what we're gonna do is… So for evaluating the model, we'll be using the data

entry that we missed out on.

Now in a real world problem, about 1/3 of the original

data set is not included in the bootstrap dataset. Because there's a huge amount of data in a real world problem, so 1/3 of the original data set is not included in the bootstrap data set. So guys, the sample data set which is not there in

your bootstrap data set is known as out-of-bag data set, because basically this is

our out-of-bag data set. Now the out-of-bag data set is used to check the

accuracy of the model. Because the model was not created by using the out-of-bag data set, it will give us a good understanding of whether the model is effective or not. Now the out-of-bag data set is nothing but your testing data set. Remember, in machine

learning, there's training and testing data set. So your out-of-bag data set is nothing but your testing data set. This is used to evaluate the

efficiency of your model. So eventually, you can

measure the accuracy of a random forest by the proportion of out-of-bag samples that

are correctly classified, because the out-of-bag data set is used to evaluate the

efficiency of your model.

So you can calculate the accuracy by understanding how many samples or was this out-of-bag data set correctly able to classify it. So guys, that was an explanation about how random forest works. To give you an overview, let me just run you through

all the steps that we took. So basically, this was our data set, and all we have to do

is we have to predict whether a patient has

heart disease or not. So, our first step was to

create a bootstrap data set. A bootstrap data set is

nothing but randomly selected observations from your original data set, and you can also have duplicate values in your bootstrap data set. Okay. The next step is you're going

to create a decision tree by considering a random

set of predictor variables for each decision tree. Okay. So, the third step is

you'll go back to step one, create a bootstrap data set.

Again, create a decision tree. So this iteration is

performed hundreds of times until you are multiple decision trees. Now that you've created a random forest, you'll use this random forest

to predict the outcome. So if you're given a new data point and you have to classify it into one of the two classes, we'll just run this new information through all the decision trees. And you'll just take the majority of the output that you're

getting from the decision trees as your outcome. Now in order to evaluate

the efficiency of the model, you'll use the out of

the bag sample data set.

Now the out-of-bag sample

is basically the sample that was not included in

your bootstrap data set, but this sample is coming from your original data set, guys. This is not something

that you randomly create. This data set was there

in your original data set, but it was just not mentioned in your bootstrap data set. So you'll use your out-of-bag sample in order to calculate the accuracy of your random forest.

So the proportion of out-of-bag samples that are correctly classified

will give you the accuracy of your model. So that is all for random forest. So guys, I'll discuss other classification algorithms with you, and only then I'll show you a demo on the classification algorithms. Now our next algorithm is

something known as naive Bayes. Naive Bayes is, again, a supervised classification algorithm, which is based on the Bayes Theorem. Now the Bayes Theorem basically follows a probabilistic approach. The main idea behind naive Bayes is that the predictor variables in

a machine learning model are independent of each other, meaning that the outcome of a model depends on a set of independent variables that have nothing to do with each other. Now a lot of you might

ask why is naive Bayes called naive.

Now usually, when I tell

anybody why naive Bayes, they keep asking me why is

naive Bayes called naive. So in real world problems

predictor variables aren't always independent of each other. There is always some correlation between the independent variables. Now because naive Bayes

considers each predictor variable to be independent of any

other variable in the model, it is called naive. This is an assumption

that naive Bayes states. Now let's understand the math behind the naive Bayes algorithm. So like I mentioned, the

principle behind naive Bayes is the Bayes Theorem, which is also known as the Bayes Rule. The Bayes Theorem is used to calculate the conditional probability, which is nothing but the

probability of an event occurring based on information about

the events in the past. This is the mathematical

equation for the Bayes Theorem. Now, in this equation, the LHS is nothing but the conditional probability

of event A occurring, given the event B. P of A is nothing but

probability of event A occurring P of B is probability of event B. And PB of A is nothing but

the conditional probability of event B occurring, given the event A.

Now let's try to understand

how naive Bayes works. Now consider this data set of around thousand 500 observations. Okay, here we have the

following output classes. We have either cat, parrot, or turtle. These are our output classes, and the predictor variables are swim, wings, green color, and sharp teeth. Okay. So, basically, your type

is your output variable, and swim, wings, green, and sharp teeth are your predictor variables. Your output variables has three classes, cat, parrot, and turtle. Okay. Now I've summarized this table

I've shown on the screen. The first thing you can see

is the class of type cats shows that out of 500 cats, 450 can swim, meaning that 90% of them can. And zero number of cats have wings, and zero number of cats

are green in color, and 500 out of 500 cats have sharp teeth. Okay. Now, coming to parrot, it

says 50 out of 500 parrots have true value for swim. Now guys, obviously,

this does not hold true in real world. I don't think there are

any parrots who can swim, but I've just created this data set so that we can understand naive Bayes.

So, meaning that 10% of parrots

have true value for swim. Now all 500 parrots have wings, and 400 out of 500 parrots

are green in color, and zero parrots have sharp teeth. Coming to the turtle class, all 500 turtles can swim. Zero number of turtles have wings. And out of 500, hundred

turtles are green in color, meaning that 20% of the

turtles are green in color. And 50 out of 500

turtles have sharp teeth. So that's what we understand

from this data set. Now the problem here is we are given our observation over here, given some value for swim,

wings, green, and sharp teeth.

What we need to do is we need to predict whether the animal is a

cat, parrot, or a turtle, based on these values. So the goal here to predict

whether it is a cat, parrot, or a turtle based on all these defined parameters. Okay. Based on the value of swim,

wings, green, and sharp teeth, we'll understand whether

the animal is a cat, or is it a parrot, or is it a turtle. So, if you look at the observation, the variables swim and

green have a value of true, and the outcome can be

anyone of the types. It can either be a cat,

it can be a parrot, or it can be a turtle. So in order to check

if the animal is a cat, all you have to do is

you have to calculate the conditional probability at each step.

So here what we're doing is we need to calculate the probability that this is a cat, given that it can swim

and it is green in color. First, we'll calculate the

probability that it can swim, given that it's a cat. And two, the probability that it is green and the probability of it being green, given that it is a cat, and then we'll multiply it with the probability of it being a cat divided by the probability

of swim and green. Okay. So, guys, I know you all can

calculate the probability. It's quite simple.

So once you calculate

the probability here, you'll get a direct value of zero. Okay, you'll get a value of zero, meaning that this animal

is definitely not a cat. Similarly, if you do this for parrots, you calculate a conditional probability, you'll get a value of 0.0264 divided by probability

of swim comma green. We don't know this probability. Similarly, if you check

this for the turtle, you'll get a probability of 0.066 divided by P swim comma green. Okay. Now for these calculations,

the denominator is the same. The value of the denominator is the same, and the value of and the probability of it being a turtle is greater

than that of a parrot. So that's how we can correctly predict that the animal is actually a turtle. So guys, this is how naive Bayes works. You basically calculate the conditional probability at each step. Whatever classification needs to be done, that has to be calculated

through probability. There's a lot of statistic that comes into naive Bayes. And if you all want to

learn more about statistics and probability, I'll leave a link in the description.

You all can watch that video as well. There I've explain exactly what conditional probability is, and the Bayes Theorem is

also explained very well. So you all can check out that video also. And apart from this, if

you all have any doubts regarding any of the algorithms, please leave them in the comment section. Okay, I'll solve your doubts. And apart from that, I'll

also leave a couple of links for each of the algorithms

in the description box. Because if you want more

in-depth understanding of each of the algorithms, you can check out that content. Since this is a full course video, I have to cover all the topics, and it is hard for me

to make you understand in-depth of each topic. So I'll leave a couple of

links in the description box. You can watch those videos as well. Make sure you checkout the probability and statistics video. So now let's move on and

locate our next algorithm, which is the K nearest neighbor algorithm. Now KNN, which basically

stands for K nearest neighbor, is, again, a supervised

classification algorithm that classifies a new data

point into the target class or the output class,

depending on the features of its neighboring data points.

That's why it's called K nearest neighbor. So let's try to understand

KNN with a small analogy. Okay, let's say that we want a machine to distinguish between the

images of cats and dogs. So to do this, we must input our data set of cat and dog images, and we have to train our

model to detect the animal based on certain features. For example, features such as pointy ears can be used to identify cats. Similarly, we can identify dogs based on their long ears. So after starting the data set during the training phase, when a new image is given to the model, the KNN algorithm will classify it into either cats or dogs, depending on the similarity

in their features. Okay, let's say that a

new image has pointy ears, it will classify that image as cat, because it is similar to the cat images, because it's similar to its neighbors.

In this manner, the KNN

algorithm classifies the data point based

on how similar they are to their neighboring data points. So this is a small example. We'll discuss more about

it in the further slides. Now let me tell you a couple of features of KNN algorithm. So, first of all, we know that it is a supervised learning algorithm. It uses labeled input data set to predict the output of the data points. Then it is also one of the simplest machine learning algorithms, and it can be easily implemented for a varied set of problems. Another feature is that

it is non-parametric, meaning that it does not

take in any assumptions. For example, naive Bayes

is a parametric model, because it assumes that all

the independent variables are in no way related to each other. It has assumptions about the model. K nearest neighbor has

no such assumptions. That's why it's considered

a non-parametric model. Another feature is that

it is a lazy algorithm. Now, lazy algorithm

basically is any algorithm that memorizes the training set, instead of learning a

discriminative function from the training data.

Now, even though KNN is mainly

a classification algorithm, it can also be used for regression cases. So KNN is actually both a classification and a regression algorithm. But mostly, you'll see that it'll be used on the four classification problems. The most important feature about a K nearest neighbor is that it's based on feature similarity with its neighboring data points. You'll understand this in the example that I'm gonna tell you. Now, in this image, we

have two classes of data.

We have class A which is squares and class B which are triangles. Now the problem statement is to assign the new input data point to one of the two classes by using the KNN algorithm. So the first step in the KNN algorithm is to define the value of K. But what is the K in the

KNN algorithm stand for? Now the K stands for the

number of nearest neighbors, and that's why it's got the

name K nearest neighbors. Now, in this image, I've

defined the value of K as three.

This means that the algorithm will consider the three neighbors that are closest to the new data point in order to decide the

class of the new data point. So the closest between the data point is calculated by using measure such as Euclidean distance

and Manhattan distance, which I'll be explaining in a while. So our K is equal to three. The neighbors include two

squares and one triangle. So, if I were to classify

the new data point based on K equal to three, then it should be assigned

to class A, correct? It should be assigned to squares. But what if the K value is set to seven. Here I'm basically telling my algorithm to look for the seven nearest neighbors and classify the new data point into the class it is most similar to. So our K equal to seven.

The neighbors include three

squares and four triangles. So if I were to classify

the new data point based on K equal to seven, then it would be assigned to class B, since majority of its

neighbors are from class B. Now this is where a

lot of us get confused. So how do we know which K

values is the most suitable for K nearest neighbor. Now there are a couple methods used to calculate the K value. One of them is known as the elbow method. We'll be discussing the elbow method in the upcoming slides. So for now let me just show you the measures that are involved behind KNN.

Okay, there's very simple math behind the K nearest neighbor algorithm. So I'll be discussing the

Euclidean distance with you. Now in this figure, we have

to measure the distance between P one and P two by

using Euclidean distance. I'm sure a lot of you already know what Euclidean distance is. It is something that we learned

in eighth or 10th grade. I'm not sure. So all you're doing is

you're extracting X one. So the formula is

basically x two minus x one the whole square plus y two minus y one the whole square, and the root of that is

the Euclidean distance.

It's as simple as that. So Euclidean distance is used as a measure to check the

closeness of data points. So basically, KNN uses

the Euclidean distance to check the closeness of a new data point with its neighbors. So guys, it's as simple as that. KNN makes use of simple measures in order to solve very complex problems. Okay, and this is one of the reasons why KNN is such a commonly used algorithm. Coming to support vector machine. Now, this is our last algorithm under classification algorithms. Now guys, don't get paranoid

because of the name. Support vector machine actually is one of the simplest algorithms

in supervised learning. Okay, it is basically

used to classify data into different classes. It's a classification algorithm. Now unlike most algorithms, SVM makes use of something

known as a hyperplane which acts like a decision boundary between the separate classes. Okay. Now SVM can be used to generate multiple separating hyperplane, such that the data is

divided into segments, and each segment contains

only one kind of data. So, a few features of SVM include that it is a supervised learning algorithm, meaning that it's going to

study a labeled training data.

Another feature is that it is again a regression and a

classification algorithm. Even though SVM is mainly

used for classification, there is something known as

the support vector regressor. That is useful regression problems. Now, SVM can also be used

to classify non-linear data by using kernel tricks. Non-linear data is basically data that cannot be separated by using a single linear line. I'll be talking more about this in the upcoming slides.

Now let's move on and

discuss how SVM works. Now again, in order to make you understand how support vector machine works, you look at a small scenario. For a second, pretend that you own a farm and you have a problem. You need to set up a fence to protect your rabbits

from a pack of wolves. Okay, now, you need to decide where you want to build your fence. So one way to solve

the problem is by using support vector machines. So if I do that and if I try

to draw a decision boundary between the rabbits and the wolves, it looks something like this. Now you can clearly build

a fence along this line.

So in simple terms, this is exactly how your support vector machines work. It draws a decision boundary, which is nothing but a hyperplane between any two classes

in order to separate them or classify them. Now I know that you're

thinking how do you know where to draw a hyperplane. The basic principle behind SVM is to draw a hyperplane that best separates the two classes. In our case, the two classes are the rabbits and the wolves. Now before we move any further, let's discuss the different terminologies that are there in support vector machine. So that is basically a hyperplane. It is a decision boundary

that best separates the two classes. Now, support vectors, what

exactly are support vectors. So when you start with the

support vector machine, you start by drawing a random hyperplane. And then you check the distance between the hyperplane

and the closest data point from each of the class. These closest data

points to the hyperplane are known as support vectors.

Now these two data points are the closest to your hyperplane. So these are known as support vectors, and that's where the name comes from, support vector machines. Now the hyperplane is drawn based on these support vectors. And optimum hyperplane will be the one which has a maximum distance from each of the support vectors, meaning that the distance

between the hyperplane and the support vectors has to be maximum. So, to sum it up, SVM

is used to classify data by using a hyperplane, such that the distance

between the hyperplane and the support vector is maximum. Now this distance is

nothing but the margin. Now let's try to solve a problem. Let's say that I input a new data point and I want to draw a hyperplane such that it best separates

these two classes.

So what do I do? I start out by drawing a hyperplane, and then I check the distance

between the hyperplane and the support vectors. So, basically here, I'm trying to check if the margin is maximum

for this hyperplane. But what if I drew the

hyperplane like this? The margin for this hyperplane

is clearly being more than the previous one. So this is my optimal hyperplane. This is exactly how you understand which hyperplane needs to be chosen, because you can draw multiple hyperplanes. Now, the best hyperplane is the one that has a maximum module. So, this is my optimal hyperplane. Now so far it was quite easy. Our data was linearly separable, which means that you

could draw a straight line to separate the two classes. But what will you do if

the data looks like this? You possibly cannot draw

a hyperplane like this. You possibly cannot draw

a hyperplane like this. It doesn't separate the two classes. We can clearly see rabbits and wolves in both of the classes.

Now this is exactly where non-linear SVM comes into the picture. Okay, this is what the

kernel trick is all about. Now, kernel is basically

something that can be used to transform data into another dimension that has a clear dividing

margin between classes of data. So, basically the kernel function offers the user the option of transforming non-linear spaces into linear ones. Until this point, if you notice that we were plotting our data

on two dimensional space. We had x and y-axis. A simple trick is transforming

the two variables, x and y, into a new feature space, which involves a new variable z. So, basically, what we're doing is we're visualizing the data on a three dimensional space. So when you transform the

2D space into a 3D space, you can clearly see a dividing margin between the two classes of data.

You can clearly draw a line in the middle that separates these two data sets. So guys, this sums up

the whole idea behind support vector machines. Support vector machines are

very easy to understand. Now, this was all for our supervised learning algorithms. Now, before I move on to

unsupervised learning algorithms, I'll be running a demo. We'll be running a demo in order to understand all

the classification algorithms that we studied so far. Earlier in the session, we ran a demo for the regression algorithms. Now we'll run for the

classification algorithms. So, enough of theory. Let's open up Python, and let's start looking at how these classification algorithms work. Now, here what we'll be doing is we'll implement multiple

classification algorithms by using the scikit-learn. Okay, it's one of the most popular machine learning tool for Python.

Now we'll be using a simple data set for the task of training a

classifier to distinguish between the different types of fruits. The purpose of this demo is to implement multiple classification algorithms for the same set of problem. So as usual, you start by importing all your libraries in Python. Again, guys, if you don't know Python, check the description box, I'll leave a link there. You can go through that video as well. Next, what we're doing is

we're reading the fruit data in the form of table. You stored it in a variable called fruits. Now if you wanna see the

first few rows of the data, let's print the first few

observations in our data set. So, this is our data set. These are the fruit labels. So we have around four

fruits in our data set. We have apple, we have mandarin, orange, and lemon.

Okay. Now, fruit label denotes

nothing but the label of apple, which is one. Mandarin has two. Similarly, orange is labeled as three. And lemon is labeled as four. Then a fruit subtype is basically the family of fruit it belongs to. Mass is the mass of the fruit, width, height, and color score. These are all our predictor variables. We have to identify the type of fruit, depending on these predictor variables. So, first, we saw a couple

of observations over here. Next, if you want to see

the shape of your data set, this is what it looks like. There are around 59 observations with seven predictor variables, which is one, two, three,

four, five, six, and seven. We have seven variables in total. Sorry, not predictor variables. This seven denotes both your predictor and your target variable. Next, I'm just showing you

the four fruits that we have in our data set, which is apple, mandarin,

orange, and lemon.

Next, I'm just grouping

fruits by their names. Okay. So we have 19 apples in our data set. We have 16 lemons. We have only five mandarins, and we have 19 oranges. Even though the number of

mandarin samples is low, we'll have to work with it, because right now I'm

just trying to make you understand the classification algorithms. The main aim for me

behind doing these demos is so that you understand how classification algorithms work. Now what you can do is

you can also plot a graph in order to see the frequency

of each of these fruits. Okay, I'll show you what

the plot looks like. The number of apples

and oranges is the same.

We have I think around

19 apples and oranges. And similarly, this is

the count for lemons. Okay. So this is a small visualization. Guys, visualization is

actually very important when it comes to machine learning, because you can see most of the relations and correlations by plotting graphs. You can't see those correlations by just running code and all of that. Only when you plot different

variables on your graph, you'll understand how they are related.

One of the main task in machine learning is to visualize data. It ensures that you understand the correlation between data. Next, what we're gonna do is we'll graph something known as a box plot. Okay, a box plot basically

helps you understand the distribution of your data. Let me run the box plot, and I'll show you what exactly I mean. So this is our box plot. So, box plot will basically give you a clearer idea of the distribution of your input variables. It is mainly used in

exploratory data analysis, and it represents the

distribution of the data and its variability. Now, the box plot contains upper quartile and lower quartile. So the box plot basically

spanned your interquartile range or something known as IQR. IQR is nothing but your third quartile subtracted from your first quartile.

Now again, this involves

statistics and probability. So I'll be leaving a link

in the description box. You can go through that video. I've explained statistics

probability, IQR, range, and all of that in there. So, one of the main reasons

why box plots are used is to detect any sort

of outliers in the data. Since the box plot spans the IQR, it detects the data point that lie outside the average range. So if you see in the colored space, most of the data is

distributed around the IQR, whereas here the data are

not that well distributed. Height also is not very well distributed, but color space is

pretty well distributed. This is what the box plot shows you. So guys, this involves a lot of math. ALl of these, each and every

function in machine learning involves a lot of math. So you know it's necessary

to have a good understanding of statistics, probability,

and all of that. Now, next, what we'll do

is we'll plot a histogram.

Histogram will basically show you the frequency of occurrence. Let me just plot this, and

then we'll try and understand. So here you can understand

a few correlations. Okay, some pairs of these

attributes are correlated. For example, mass and width, they're somehow correlated

along the same ranges. So this suggests a high correlation and a predictable relationship. Like if you look at the

graphs, they're quite similar. So for each of the predictor variables, I've drawn a histogram. For each of that input data,

we've drawn a histogram.

Now guys, again, like i said, plotting graphs is very important because you understand

a lot of correlations that you cannot understand by just looking at your data, or just running operations on your data. Repeat, or just running code on your data. Okay. Now, next, what we're

doing here is we're just dividing the data set into

target and predictor variables. So, basically, I've created

an array of feature names which has your predictor variables.

It has mass, width, height, color space. And you have assigned that as X, since this is your input, and y is your output

which is your fruit label. That'll show whether it is an apple, orange, lemon, and so on. Now, the next step that

we'll perform over here is pretty evident. Again, this is data splicing. So data splicing, by now, I'm sure all of you know what it is. It is splitting your data into

training and testing data. So that's what we've done over here. Next, we're importing something

known as the MinMaxScaler. Scaling or normalizing your data is very important in machine learning. Now, I'm seeing this because your raw data can be very biased. So it's very important

to normalize your data. Now when I say normalize your data, so if you look at the value of mass and if you look at the

value of height and color, you see that mass is ranging

in hundreds and double digits, whereas height is in single digit, and color score is not

even in single digits. So, if some of your variables

have a very high range, you know they have a very high scale, like they're in two

digits or three digits, whereas other variables are

single digits and lesser, then your output is

going to be very biased.

It's obvious that it's

gonna be very biased. That's why you have to scale your data in such a way that all of these values will have a similar range. So that's exactly what

the scaler function does. Okay. Now since we have already divided our data into training and testing data, our next step is to build the model. So, first, we're gonna be using the logistic regression algorithm. I've already discussed logistic

regression with you all. It's a classification algorithm, which is basically used

to predict the outcome of a categorical variable. So we already have the logistic

regression class in Python. All you have to do is you have to give an instance for this function, which is logreg over here.

And I'm fitting this instance

with a training data set, meaning that I'm running the algorithm with the training data set. Once you do that, you can calculate the accuracy by using this function. So here I'm calculate the accuracy on the training data set and on the testing data set. Okay, so let's look at the output of this. Now guys, ignore this future warning. Warnings are ignored in Python. Now, accuracy of the logistic

regression classifier on the training data set is around 70%.

It was pretty good on

the training data set. But when it comes to classifying

on the test data set, it's only 40%, which is not that good for a classifier. Now again, this can depend

on the problem statement, for which problem statement is logistic regression more suitable. Next, we'll do the same thing

using the decision tree. So again, we just call the

decision tree function, and we'll fit it with

the training data set, and we'll calculate the accuracy of the decision tree on the training, and the testing data set. So if you do that for a decision tree on the training data set, you get 100% accuracy. But on the testing data set, you have around 87% of accuracy. This is something that I

discussed with you all earlier, that this is decision trees are very good with training data set, because of a process known as overfitting. But when it comes to classifying the outcome on the testing data set, the accuracy reduces. Now, this is very good compared

to logistic regression. For this problem statement, decision trees works better that logistic regression.

Coming to KNN classifier. Again, all you have to do is you have to call the K neighbor

classifier, this function. And you have to fit this

with the training data set. If you calculate the accuracy

for a KNN classifier, we get a good accuracy actually. On the training data set, we get an accuracy of 95%. And on the testing data set, it's 100%. That is really good,

because our testing data set actually achieved more of an accuracy than on a training data set.

Now all of this depends on the value of K that you've chosen for KNN. Now, I mentioned that

you use the elbow method to choose the K value in

the K nearest neighbor. I'll be discussing the elbow

method in the next section. So, don't worry if you

haven't understood that yet. Now, we're also using a

naive Bayes classifier. Here we're using a Gaussian

naive Bayes classifier. Gaussian is basically a type

of naive Bayes classifier. I'm not going to go into depth of this, because it'll just extend our

session too much more longer. Okay. And if you want to know more about this, I'll leave a link in the description box. You can read all about the

caution naive Bayes classifier. Now, the math behind this is the same.

It uses naive Bayes, it uses

the Bayes Theorem itself. Now again, we're gonna call this class, and then we're going to run our data, training data on it. So using the naive Bayes classifier, we're getting an accuracy of 0.86 on the training data set. And on the testing data set,

we're getting 67% accuracy. Okay. Now let's do the same thing

with support vector machines. Importing the support vector classifier. And we are fitting the training

data into the algorithm. We're getting an accuracy of around 61% on the training data set and

33% on the testing data set. Now guys, this accuracy and all depends also on the problem statement. It depends on the type of data that support vector machines get. Usually, SVM is very

good on large data sets. Now since we have a very

small data set over here, it's sort of obvious by

the accuracy, so less. So guys, these were a couple

of classification algorithms that I showed you here.

Now, because our KNN classifier classified our data set more accurately we'll look at the predictions

that the KNN classifier mean. Okay Now we're storing all our predicted values in the predict variable. now in order to show you the accuracy of the KNN model, we're going to us something

known as the confusion matrix. So, a confusion matrix is a table that is often used to describe the performance of a classification model. So, confusion matrix actually represents a tabular representation of actual versus predicted values. So when you draw a confusion matrix on the actual versus predicted values for the KNN classifier, this is what the confusion

matrix looks like. Now, we have four rows over here. If you see, we have four rows. The first row represents apples, second, mandarin, third represents lemons, and fourth, oranges. So this four value corresponds

to zero comma zero, meaning that it was

correctly able to classify all the four apples.

Okay. This one value represents one comma one, meaning that our classifier

correctly classified this as mandarins. This matrix is drawn on actual values versus predicted values. Now, if you look at the summary

of the confusion matrix, we'll get something known

as precision recall, f1-score and support. Precision is basically the ratio of the correctly predicted

positive observations to the total predicted

positive observations. So the correctly predicted

positive observations are four, and there are total of four apples in the testing data set. So that's where I get a precision of one. Okay. Recall on the other hand is the ratio of correctly

predicted positive observations to all the observations in the class. Again, we've correctly

classified four apples, and there are a total of four apples. F1-score is nothing but

the weighted average of your precision and your recall. Okay, and your support basically denotes the number of data points that were correctly classified. So, in our KNN algorithm,

since we got 100% accuracy, all our data points were

correctly classified. So, 15 out of 15 were correctly classified because we have 100% accuracy. So that's how you read a confusion matrix.

Okay, you have four important measures, precision, recall, f1-score, and support. F1-score is just the ratio

or the weighted average of your precision and your recall. So precision is basically

the correctly predicted positive observations

to the total predicted positive observations. Recall is a ratio of the predicted positive observations to

all your observations. So guys, that was it for the demo of classification algorithms, we discuss regression algorithms and we discussed

classification algorithms. Now it's time to talk about unsupervised learning algorithms. Under unsupervised learning algorithms may try to solve clustering problems. And the most important

clustering algorithm there is, known as K-means clustering. So we're going to discuss

the K-means algorithm, and also show you a demo

where we'll be executing the clustering algorithm, and you're seeing how it

implemented to solve a problem. Now, the main aim of the K-means algorithm is to group similar elements

or data points in to a cluster. So it is basically the process by which objects are classified interest a predefined number of groups, so that they are much

dissimilar as possible from one group to another group, but as much similar as

possible within each group.

Now what I mean is let's

say you're trying to cluster this population into

four different groups, such that each group has people within a specified range of age. Let's say group one is of people

between the age 18 and 22. Similarly, group two is between 23 and 35. Group three is 36 and 39

or something like that. So let's say you're trying to cluster people into different

groups based on their age. So for such problems, you can make use of the K-means clustering algorithm. One of the major applications

of the clustering algorithm is seen in targeted marketing.

I don't know how many of you are aware of targeted marketing. Targeted marketing is all about

marketing a specific product to a specific audience. Let's say you're trying

to sell fancy clothes or a fancy set of bags and all of that. And the perfect audience for such product would be teenagers. It would be people around

the age of 16 to 21 or 18. So that is what target

marketing is all about. Your product is marketed

to a specific audience that might be interested in it. That is what targeted marketing is. So K means clustering is use

majorly in targeted marketing. A lot of eCommerce websites

like Amazon, Flipkart, eBay. All of these make use

of clustering algorithms in order to target the right audience. Now let's see how the

K-means clustering works.

Now the K in K-means denotes

the number of clusters. Let's say I give you a data

set containing 20 points, and you want to cluster this

data set into four clusters. That means your K will be equal to four. So K basically stands for

the number of clusters in your data set, or the number of clusters

you want to form. You start by defining the number K. Now for each of these clusters, you're going to choose a centroid. So for every cluster, there are four cluster in our data set. For each of these clusters, you'll randomly select

one of the data points as a centroid. Now what you'll do is you'll start computing the distance from that centroid to every other point in that cluster. As you keep computing the centroid and the distance between the centroid and other data points in that cluster, your centroid keep shifting, because you're trying to get

to the average of that cluster. Whenever you're trying to get

to the average of the cluster, the centroid keeps shifting, because the centroid keeps

converging and it keeps shifting.

Let's try to understand how K-means works. Let's say that this data

set, this is given to us. Let's say if you're given

random points like these and you're asked to us

K-means algorithm on this. So your first step will be to decide the number of

clusters you want to create. So let's say I wanna create

three different clusters. So my K value will be equal to three. The next step will be to provide centroids of all the clusters. What you'll do is initially

you'll randomly pick three data points as your centroids for your three different clusters. So basically, this red denotes

the centroid for one cluster. Blue denotes a centroid

for another cluster.

And this green dot denotes the centroid for another cluster. Now what happens in K-means, the algorithm will calculate the Euclidean distance of

the points from each centroid and assign the points

to the closest cluster. Now since we had three centroids here, now what you're gonna do is you're going to calculate the distance from each and every data point to all the centroids, and you're going to check which data point is closest to which centroid.

So let's say your data point A is closest to the blue centroid. So you're going to assign the data point A to the blue cluster. So based on the distance between the centroid and the cluster, you're going to form

three different clusters. Now again, you're going

to calculate the centroid and you're going to form a new cluster which is from better clusters, because you're recomputing

all those centroids. Basically, your centroids represent the mean of each of your cluster. So you need to make sure that your mean is actually

the centroid of each cluster. So you'll keep recomputing this centroids until the position of your

centroid does not change. That means that your

centroid is actually the main or the average of that particular cluster. So that's how K-means works.

It's very simple. All you have to do is you have to start by defining the K value. After that, you have to randomly pick the number of case centroids. Then you're going to

calculate the average distance of each of the data

points from the centroids, and you're going to assign a data point to the centroid it is closest to. That's how K-means works. It's a very simple process. All you have to do is us

have to keep iterating, and you have to recompute

the centroid value until the centroid value does not change, until you get a constant centroid value. Now guys, again, in K-means, you make use of distance

measures like Euclidean. I've already discussed what

Euclidean is all about. So, to summarize how K-means works, you start by picking

the number of clusters. Then you pick a centroid. After that, you calculate the distance of the objects to the centroid. Then you group the data

points into specific clusters based on their distance. You have to keep computing the centroid until each data point is

assigned to the closest cluster, so that's how K-means works.

Now let's look at the elbow method. The elbow method is basically

used in order to find out the most optimum k value

for a particular problem. So the elbow method is

quite simple actually. You start off by computing

the sum of squared errors for some values of K. Now sum of squared error is basically the sum of the squared distance between each member of the

cluster and its centroid. So you basically calculate

the sum of squared errors for different values of K. For example, you can consider K value as two, four, six, eight, 10, 12. Consider all these values, compute the sum of squared

errors for each of these values.

Now if you plot your K value against your sum of squared errors, you will see that the error

decreases as K gets larger. This is because the number

of clusters increase. If the number of clusters increases, it means that the distortion gets smaller. The distortion keeps decreasing as the number of clusters increase. That's because the more clusters you have, the closer each centroid

will be with its data points.

So as you keep increasing

the number of clusters, your distortion will also decrease. So the idea of the elbow

method is to choose the K at which the distortion

decreases abruptly. So if you look at this

graph at K equal to four, the distortion is abruptly decreasing. So this is how you find the value of K. When your distortion drops abruptly, that is the most optimal K value you should be choosing for

your problem statement. So let me repeat the idea

behind the elbow method. You're just going to graph the

number of clusters you have versus the squared sum of errors. This graph will basically

give you the distortion. Now the distortion

obviously going to decrease if you increase the number of clusters, and there is gonna be

one point in this graph wherein the distortion

decreases very abruptly.

Now for that point, you need

to find out the value of K, and that'll be your most optimal K value. That's how you choose your K-means K value and your KNN K value as well. So guys, this is how the elbow method is. It's very simple and it

can be easily implemented. Now we're gonna look at a small demo which involves K-means. This is actually a very interesting demo. Now guys, one interesting application of clustering is in color

compression with images. For example, imagine you have an image with millions of colors in it. In most images, a large number

of colors will be unused, and many of the pixels in the image will have similar or

even identical colors. Now having too many colors in your image makes it very hard for image

processing an image analysis.

So this is one area where

K-means is applied very often. It's applied in image

segmentation, image analysis, image compression, and so on. So what we're gonna do in this demo is we are going to use an image from the scikit-learn data set. Okay, it is a prebuilt image, and you will require to install

the pillow package for this.

We're going to use an image form the scikit-learn data set module. So we'll begin by importing

the libraries as usual, and we'll be loading our image as china. The image is china.jpg, and we'll be loading this

in a variable called china. So if you wanna look at

the shape of our image, you can run this command. So we're gonna get a

three-dimensional value.

So we're getting 427

comma 640 comma three. Now this is basically a

three dimensional array of size, height, width, and RGB. It contains red, blue,

green contributions, as integers from zero to 255. So, your pixel values

range between zero and 255, and I think zero stands for your black, and 255 represents white if I'm not wrong. And basically, that's what

this array shape denotes. Now one way we can view this set of pixels is as a cloud of points in a

three dimensional color space. So what we'll do is we

will reshape the data and rescale the color, so that they lie between zero and one. So the output of this will be

a two dimensional array now. So basically, we can

visualize these pixels in this color space. Now what we're gonna do is we're gonna try and plot our pixels. We have a really huge data set which contains around 16

million possible colors. So this denotes a very,

very large data set. So, let me show you what it looks like.

We have red against green

and red against blue. These are our RGB value, and we can have around 16 million possible combination of colors. The data set is way too

large or us to compute. So what we'll do is we will

reduce these 16 million colors to just 16 colors. We can do that by using

K-means clustering, because we can cluster similar

colors into similar groups. So this is exactly where

we'll be importing K-means. Now, one thing to note here is because we're dealing with

a very large data set, we will use the MinibatchKMeans. This operates on subsets of the data to compute the results more

quickly and more accurately, just like the K-means algorithm, because I told you this

data set is really huge. Even though this is a single image, the number of pixel combinations

can come up to 16 million, which is a lot. Now each pixel is

considered as a data point when you've taken image

into consideration. When you have data points and data values, that's different. When you're starting an image

for image classification or image segmentation, each and every pixel is considered.

So, basically, you're building matrices of all of these pixel values. So having 16 million pixels

is a very huge data set. So, for that reason, we'll

be using the MinibatchKMeans. It's very similar to K-means. The only difference is that it'll operate on subsets of the data. Because the data set is too

huge, it'll operate on subsets. So, basically, we're making use of K-means in order to cluster these 16 million color combinations into just 16 colors.

So basically, we're gonna form 16 clusters in this data set. Now, the result is the

recoloring of the original pixel where every pixel is assigned the color of its closest cluster center. Let's say that there

are a couple of colors which are very close to green. So we're going to cluster

all of these similar colors into one cluster. We'll keep doing this

until we get 16 clusters. So, obviously, to do this, we'll be using the clustering method, K-means. Let me show you what

the output looks like. So, basically, this was the original image from the scikit data set, and this is the 16-color segmented image. Basically, we have only 16 colors here. Here we can have around 16 million colors. Here there are only 16 colors. If you can't also, you can

only see particular colors. Now obviously there's a lot

of distortion over here, but this is how you study an image. Remove all the extra contrast

that is there in an image. You try to reduce the pixel to a smaller set of data as possible. The more varied pixels you have, the harder it is going to be for you to study the image for analysis.

Now, obviously, there are some details which are lost in this. But overall, the image

is still recognizable. So here, basically, we've compressed this with a compression factor

of around one million, because each cluster will have around one million data points in it, or pixel values in it, or pixels in it. Now this is an interesting

application of K-means. There are actually better ways you can compress information on image. So, basically, I showed you this example because I want you to understand the power of K-means algorithm.

You can cluster a data

set that is this huge into just 16 colors. Initially, there were 16 million, and now you can cluster it to 16 colors. So guys, K-means plays a very huge role in computer vision image processing, object detection, and so on. It's a very important algorithm when it comes to detecting objects. So in self-driving cars and all can make use of such algorithms. So guys, that was all

about unsupervised learning and supervised learning.

Now it's the last type

of machine learning, which is reinforcement learning. Now this is actually a very interesting part

of machine learning, and it is quite difference from

supervised and unsupervised. So we'll be discussing all the concepts that are involved in

reinforcement learning. And also reinforcement learning is a little more advanced. When I say advanced, I

mean that it's been used in applications such as self-driving cars and is also a part of a lot of deep learning applications, such as AlphaGo and so on. So, reinforcement learning has a different concept to it itself.

So we'll be discussing

all the concepts under it. So just to brush up your information about reinforcement learning, reinforcement learning is

a part of machine learning where an agent is put in

an unknown environment, and he learns how to

behave in this environment by performing certain actions

and observing the rewards which it gets from these actions. Reinforcement learning is all about taking an appropriate action in

order to maximize the reward in a particular situation. Now let's understand

reinforcement learning with an analogy. Let's consider a scenario wherein a baby is learning how to walk. This scenario can go about

in two different ways. The first is baby starts walking and it makes it to the candy. And since the candy is the end goal, the baby is very happy and it's positive. Meaning, the baby is happy and it received a positive reward. Now, the second way this can go in is that the baby starts walking, but it falls due to some hurdle between. That's really cute. So the baby gets hurt and

it doesn't get to the candy. It's negative because the baby is sad and it receives a negative reward.

So just like how we humans

learn from our mistakes by trial and error, reinforcement learning is also similar. Here we have an agent, and in this case, the agent is the baby, and the reward is the candy with many hurdles in between. The agent is supposed to find the best possible path

to reach the reward. That is the main goal of

reinforcement learning. Now the reinforcement learning process has two important components. It has something known as an agent and something known as an environment. Now the environment is the setting that the agent is acting on, and the agent represents the reinforcement learning algorithm. The whole reinforcement

learning is basically the agent. The environment is the setting in which you place the agent, and it is the setting wherein the agent takes various action.

The reinforcement learning process starts when the environment

sends a state to the agent. Now the agent, based on

the observations it makes, it takes an action in

response to that state. Now, in turn, the environment

will send the next state and the respective

reward back to the agent. Now the agent will update its knowledge with the reward returned

by the environment to evaluate its last actions. The loop continues until the environment sends a terminal state which means that the

agent has accomplished all of its task. To understand this better, let's suppose that our agent

is playing Counter Strike. The reinforcement learning process can be broken down into a couple of steps. The first step is the

reinforcement learning agent, which is basically the player, he collects a state, S

naught, from the environment. So whenever you're playing Counter Strike, you start off with

stage zero or stage one. You start off from the first level. Now based on this state, S naught, the reinforcement learning agent will take an action, A naught. So guys, action can be

anything that causes a result.

Now if the agent moves

left or right in the game, that is also considered as an action. So initially, the action will be random, because the agent has no

clue about the environment. Let's suppose that you're

playing Counter Strike for the first time. You have no idea about how to play it, so you'll just start randomly. You'll just go with whatever, whichever action you think is right. Now the environment is now in a stage one. After passing stage zero, the environment will go into stage one. Once the environment updates

the stage to stage on, the reinforcement learning agent will get a reward R one

from the environment. This reward can be anything

like additional points or you'll get additional weapons when you're playing Counter Strike. Now this reinforcement

learning loop will go on until the agent is dead or

reaches the destination, and it continuously outputs a sequence of state action and rewards. This exactly how

reinforcement learning works. It starts with the agent

being put in an environment, and the agent will randomly take some action in state zero. After taking an action,

depending on his action, he'll either get a reward and move on to state number one, or he will either die and

go back to the same state.

So this will keep happening until the agent reaches the last stage, or he dies or reaches his destination. That's exactly how

reinforcement learning works. Now reinforcement learning is the logic behind a lot of games these days. It's being implemented in

various games, such as Dota. A lot of you who play

Dota might know this. Now let's talk about a couple of reinforcement learning

definitions or terminologies. So, first, we have something

known as the agent.

Like I mentioned, an agent is the reinforcement learning algorithm that learns from trial and error. An agent is the one

that takes actions like, for example, a solider in Counter Strike navigating through the game, going right, left, and all of that. Is the agent taking some action? The environment is because the world through which the agent moves.

Now the environment, basically, takes the agent's current

state and action as input, and returns the agent's reward and its next state as the output. Next, we have something known as action. All the possible steps

that an agent can take is considered as an action. Next, we have something known as state. Now the current condition

returned by the environment is known as a state. Reward is an instant

return from the environment to apprise the last action of the reinforcement learning agent. All of these terms are

pretty understandable. Next, we have something known as policy. Now, policy is the approach

that the agent uses to determine the next action based on the current state. Policy is basically the approach with which you go around

in the environment. Next, we have something known as value. Now, the expected long-term

return with a discount, as opposed to the short-term rewards R, is known as value.

Now, terms like discount and value, I'll be discussing in the upcoming slides. Action-value is also very

similar to the value, except it takes an extra parameter known as the current action. Don't worry about action and Q value. We'll talk about all of

this in the upcoming slides. So make yourself familiar

with these terms, because we'll be seeing a

whole lot of them this session.

So, before we move any further, let's discuss a couple of more reinforcement learning concepts. Now we have something known

as the reward maximization. So if you haven't realized it already, the basic aim of

reinforcement learning agent is to maximize the report. How does this happen? Let's try to understand this

in a little more detail. So, basically the agent

works based on the theory of reward maximization. Now that's exactly why

the agent must be trained in such a way that he

takes the best action, so that the reward is maximal. Now let me explain a reward maximization with a small example. Now in this figure, you

can see there is a fox, there is some meat, and there is a tiger. Our reinforcement

learning agent is the fox. His end goal is to eat

the maximum amount of meat before being eaten by the tiger. Now because the fox is a very clever guy, he eats the meat that is closer to him, rather than the meat which

is close to the tiger, because the closer he gets to the tiger, the higher are his

chances of getting killed.

That's pretty obvious. Even if the reward near the

tiger are bigger meat chunks, that'll be discounted. This is exactly what discount is. We just discussed it

in the previous slide. This is done because of

the uncertainty factor that the tiger might

actually kill the fox. Now the next thing to

understand is how discounting of a reward works. Now, in order to understand discounting, we define a discount rate called gamma. The value of gamma is

between zero and one. And the smaller the gamma, the larger the discount and so on. Now don't worry about these concepts, gamma and all of that. We'll be seeing that in

our practical demo today. So let's move on and

discuss another concept known as exploration and

exploitation trade-off. Now guys, before that, I

hope all of you understood reward maximization. Basically, the main aim

behind reinforcement learning is to maximize the rewards

that an agent can get.

Now, one of the most important concepts in reinforcement learning is the exploration and

exploitation trade-off. Now, exploration, like the name suggests, it's about exploring and capturing more information about an environment. On the other hand, exploitation is about using the already known

exploited information to heighten your reward. Now consider the same example that we saw previously. So here the fox eats only the meat chunks which are close to him. He doesn't eat the bigger meat chunks which are at the top, even though the bigger meat chunks would get him more reward.

So if the fox only focuses

on the closest reward, he will never reach

the big chunks of meat. This process is known as exploitation. But if the fox decide to explore a bit, it can find the bigger reward, which is the big chunk of meat. This is known as exploration. So this is the difference

between exploitation and exploration. It's always best if the agent

explores the environment, tries to figure out a

way in which we can get the maximum number of rewards. Now let's discuss

another important concept in reinforcement learning, which is known as the

Markov's decision process. Basically, the mathematical

approach for mapping a solution in reinforcement learning is called Markov's decision process. It's the mathematics behind

reinforcement learning. Now, in a way, the purpose

of reinforcement learning is to solve a Markov's decision process. Now in order to get a solution, there are a set of parameters in a Markov's decision process.

There's a set of actions A, there's a set of states S, a reward R, policy pi, and value V. Also, this image represents how a reinforcement learning works. There's an agent. The agent take some

action on the environment. The environment, in turn,

will reward the agent, and it will give him the next state. That's how reinforcement learning works so to sum everything up, what happens in Markov's decision process and reinforcement learning is the agent has to take an action A to transition from the start state to the end state S. While doing so, the agent

will receive some reward R for each action he takes. Now the series of action

that are taken by the agent define the policy and

the rewards collected to find the value. The main goal here is

to maximize the rewards by choosing the optimum policy. So you're gonna choose

the best possible approach in order to maximize the rewards. That's the main aim of

Markov's decision process.

To understand Markov's decision process, let's look at a small example. I'm sure all of you already know about the shortest path problem. We all had such problems

and concepts in math to find the shortest path. Now consider this representation

over here, this figure. Here, our goal is to

find the shortest path between two nodes. Let's say we're trying to find the shortest path between

node A and node D.

Now each edge, as you can see, has a number linked with it. This number denotes the cost to traverse through that edge. So we need to choose a

policy to travel from A to D in such a way that our cost is minimum. So in this problem, the set of states are denoted by the nodes A, B, C, D. The action is to traverse

from one node to the other. For example, if you're going from to A C, there is an action. C to B is an action. B to D is another action.

The reward is the cost

represented by each edge. Policy is the path taken

to reach the destination. So we need to make sure

that we choose a policy in such a way that our cost is minimal. So what you can do is you

can start off at node A, and you can take baby steps

to reach your destination. Initially, only the next

possible node is visible to you. So from A, you can either go to B or you can go to C. So if you follow the greedy approach and take the most optimum step, which is choosing A to C, instead of choosing A to B to C.

Now you're at node C and you want to traverse to node D. Again, you must choose

your path very wisely. So if you traverse from A to C, and C to B, and B to D, your cost is the lest. But if you traverse from A to C to D, your cost will actually increase. Now you need to choose a policy that will minimize your cost over here. So let's say, for example, the agent chose A to C to D. It came to node C, and

then it directly chose D. Now the policy followed by

our agent in this problem is exploitation type, because we didn't explore the other notes. We just selected three nodes

and we traversed through them. And the policy we followed is not actually an optimal policy. We must always explore more to find out the optimal policy. Even if the other nodes are

not giving us any more reward or is actually increasing our cost, we still have to explore and find out if those paths are actually better. That policy is actually better. The method that we implemented here is known as the policy-based learning.

Now the aim here is to

find the best policy among all the possible policies. So guys, apart from policy-based, we also have value-based approach and action-based approach. Value based emphasizes on

maximizing the rewards. And in action base, we emphasize on each action taken by the agent. Now a point to note is that all of these learning approaches

have a simple end goal. The end goal is to

effectively guide the agent through the environment, and acquire the most number of rewards. So this was very simple to understand Markov's decision process, exploitation and exploration trade-off, and we also discussed the different reinforcement

learning definitions. I hope all of this was understandable. Now let's move on and understand an algorithm known as

Q-learning algorithm.

So guys, Q-learning is one of

the most important algorithms in reinforcement learning. And we'll discuss this algorithm with the help of a small example. We'll study this example, and then we'll implement the

same example using Python, and we'll see how it works. So this is how our

demonstration looks for now. Now the problem statement

is to place an agent in any one of the rooms numbered zero, one, two, three, and four. And the goal is for the agent to reach outside the building, which is room number five. So, basically, this zero,

one, two, three, four represents the building, and five represents a room

which is outside the building. Now all these rooms

are connected by those. Now these gaps that you

see between the rooms are basically those, and each room is numbered

from zero to four. The outside of the building can be taught of as a big room which is room number five. Now if you've noticed this diagram, the door number one and door number four lead directly to room number five.

From one, you can directly go to five, and from four, also, you

can directly go to five. But if you want to go to

five from room number two, then you'll first have to

go to room number three, room number one, and

then room number five. So these are indirect links. Direct links are from room

number one and room number four. So I hope all of you are clear

with the problem statement. You're basically going to have a reinforcement learning agent, and than agent has to

traverse through all the rooms in such a way that he

reaches room number five. To solve this problem, first, what we'll do is

we'll represent the rooms on a graph. Now each room is denoted as anode, and the links that are connecting

these nodes are the doors. Alright, so we have node one to five, and the links between each of these nodes represent the doors. So, for example, if you look

at this graph over here, you can see that there

is a direct connection from one to five, meaning that you can directly

go from room number one to your goal, which is room number five.

So if you want to go from

room number three to five, you can either go to room number one, and then go to five, or you can go from room

number three to four, and then to five. So guys, remember, end goal

is to reach room number five. Now to set the room number

five as the goal state, what we'll do is we'll

associate a reward value to each door. The doors that lead

immediately to the goal will have an instant reward of 100. So, basically, one to five

will have a reward of hundred, and four to five will also

have a reward of hundred. Now other doors that are not directly connected to the target room will have a zero reward, because they do not directly

lead us to that goal. So let's say you placed the

agent in room number three. So to go from room number three to one, the agent will get a reward of zero.

And to go from one to five, the agent will get a reward of hundred. Now because the doors are two-way, the two arrows are assigned to each room. You can see an arrow

going towards the room and one coming from the room. So each arrow contains an instant reward as shown in this figure. Now of course room number five will loop back to itself

with a reward of hundred, and all other direct

connections to the goal room will carry a reward of hundred. Now in Q-learning, the

goal is to reach the state with the highest reward. So that if the agent arrives at the goal, it will remain there forever. So I hope all of you are

clear with this diagram. Now, the terminologies in Q-learning include two terms, state and action. Okay, your room basically

represents the state. So if you're in state two, it basically means that

you're in room number two. Now the action is basically

the moment of the agent from one room to the other room. Let's say you're going

from room number two to room number three.

That is basically an action. Now let's consider some more example. Let's say you place the

agent in room number two and he has to get to the goal. So your initial state

will be state number two or room number two. Then from room number two,

you'll go to room number three, which is state three. Then from state three, you can

either go back to state two or go to state one or state four. If you go to state four, from

there you can directly go to your goal room, which is five. This is how the agent

is going to traverse. Now in order to depict the

rewards that you're going to get, we're going to create a matrix

known as the reward matrix. Okay, this is represented by R or also known as the R matrix. Now the minus one in this

table represents null values. That is basically where there isn't a link between the nodes that is

represented as minus one. Now there is no link

between zero and zero. That's why it's minus one. Now if you look at this diagram, there is no direct link from zero to one.

That's why I've put minus

one over here as well. But if you look at zero comma four, we have a value of zero over here, which means that you can

traverse from zero to four, but your reward is going to be zero, because four is not your goal state. However, if you look at the matrix, look at one comma five. In one comma five, we have

a reward value of hundred. This is because you can directly go from room number one to five, and five is the end goal. That's why we've assigned

a reward of hundred. Similarly, for four comma five, we have a reward of hundred. And for five comma five, we have a reward of hundred. Zeroes basically represent other links, but they are zero because they

do not lead to the end goal. So I hope you all understood

the reward matrix. It's very simple.

Now before we move any further, we'll be creating another matrix known as the equitable Q matrix. Now the Q matrix basically

represents the memory of what the agent has

learned through experience. The rules of the Q matrix will represent the current

state of the agent. The columns will represent

the next possible actions leading to the next state, and the formula to calculate the Q matrix is this formula, right? Here we have Q state comma action, R state comma action, which is nothing but the reward matrix. Then we have a parameter

known as the Gamma parameter, which I'll explain shortly. And then we are multiplying

this with a maximum of Q next state comma all actions. Now don't worry if you haven't

understood this formula. I'll explain this with a small example. For now, let's understand

what a Gamma parameter is.

So, basically, the value of Gamma will be between zero and one. If Gamma is closer to zero, it means that the agent

will tend to consider only immediate rewards. Now, if the Gamma is closer to one, it means that the agent

will consider future rewards with greater weight. Now what exactly I'm trying to say is if Gamma is closer to one, then we'll be performing

something known as exploitation. I hope you all remember what exploitation and exploration trade-off is. So, if your gamma is closer to zero, it means that the agent is not going to explore the environment. Instead, it'll just

choose a couple of states, and it'll just traverse

through those states. But if your gamma

parameter is closer to one, it means that the agent will traverse through all possible states, meaning that it'll perform exploration, not exploitation. So the closer your gamma

parameter is to one, the more your agent will explore.

This is exactly what Gamma parameter is. If you want to get the best policy, it's always practical that

you choose a Gamma parameter which is closer to one. We want the agent to

explore the environment as much as possible so that it can get the best

policy and the maximum rewards. I hope this is clear. Now let me just tell you what a Q-learning

algorithm is step by step. So you begin the Q-learning algorithm by setting the Gamma parameter and the environment rewards in matrix R. Okay, so, first, you'll

have set these two values.

We've already calculated

the reward matrix. We need to set the Gamma parameter. Next, you'll initialize

the matrix Q to zero. Now why do you do this? Now, if you remember, I said that Q matrix is basically

the memory of the agent. Initially, obviously, the agent has no memory

of the environment. It's new to the environment and you're placing it randomly anywhere. So it has zero memory. That's why you initialize

the matrix Q to zero. After that, you'll select

a random initial state, and you place your agent

in that initial state. Then you'll set this initial

state as your current state. Now from the current state,

you'll select some action that will lead you to the next state. Then you'll basically

get the maximum Q value for this next state, based on all the possible

actions that we take. Then you'll keep computing the skew value until you reach the goals state.

Now that might be a little bit confusing, so let's look at this entire

thing with a small example. Let's say that first, you're gonna begin with setting your Gamma parameter. So I'm setting my Gamma parameter to 0.8 which is pretty close to one. This means that our agent

will explore the environment as much as possible. And also, I'm setting the

initial state as room one. Meaning, I'm in state

one or I'm in room one. So basically, your agent is

going to be in room number one. The next step is to initialize

the Q matrix as zero matrix. So this is a Q matrix. You can see that

everything is set to zero, because the agent has no memory at all. He hasn't traversed to any node, so he has no memory. Now since the agent is in room one he can either go to room number three or he can go to room number five. Let's randomly select room number five. So, from room number five, you're going to calculate

the maximum Q value for the next state based

on all possible actions.

So all the possible actions

from room number five is one, four, and five. So, basically, the traversing

from Q one comma five, that's why I put one comma five over here, state comma action. Your reward matrix will

have R one comma five. Now R one comma five is basically hundred. That's why I put hundred over here. Now your comma parameter is 0.8. So, guys, what I'm doing here is I'm just substituting

the values in this formula.

So let me just repeat this whole thing. Q state comma action. So you're in state number one, correct? And your action is you're

going to room number five. So your Q state comma

action is one comma five. Again, your reward matrix R

one comma five is hundred. So here's you're gonna put hundred, plus your Gamma parameter. Your Gamma parameter is 0.8. Then you're going to

calculate the maximum Q value for the next state based

on all possible actions. So let's look at the next state. From room number five,

you can go to either one. You can go to four or you can go to five.

So your actions are five

comma one, five comma four, and five comma five. That's exactly what I mentioned over here. Q five comma one, Q five comma

four, and Q five comma five. You're basically putting all

the next possible actions from state number five. From here, you'll calculate the maximum Q value that you're

getting for each of these. Now your Q value is zero, because, initially, your

Q matrix is set to zero. So you're going to get

zero for Q five comma one, five comma four, and five comma five. So that's why you'll get 0.8 and zero, and hence your Q one comma

five becomes hundred. This hundred comes from R one comma five. I hope all of you understood this. So next, what you'll do is you'll update this one comma five

value in your Q matrix, because you just calculated

Q one comma five.

So I've updated it over here. Now for the next episode, we'll start with a randomly

chosen initial state. Again, let's say that we randomly

chose state number three. Now from room number three, you can either go to room

number one, two or four. Let's randomly select room number one. Now, from room number five, you'll calculate the maximum Q value for the next possible actions.

So let's calculate the Q formula for this. So your Q state comma action

becomes three comma one, because you're in state number three and your action is you're

going to room number one. So your R three comma one, let's see what R three comma one is. R three comma one is zero. So you're going to put zero over here, plus your Gamma parameter, which is 0.8, and then you're going to check

the next possible actions from room number one, and you're going to

choose the maximum value from these two.

So Q one comma three and Q one comma five denote your next possible

actions from room number one. So Q one comma three is zero, but Q one comma five is hundred. So we just calculated this

hundred in the previous step. So, out of zero and hundred, hundred is your maximum value, so you're going to choose hundred. Now 0.8 into hundred is nothing but 80. So again, your Q matrix gets updated. You see an 80 over here. So, basically what you're doing

is as you're taking actions, you're updating your Q value, you're just calculating

the Q value at every step, you're putting it in your Q matrix so that your agent remembers that, okay, when I went from room

number one to room number five, I had a Q value of hundred.

Similarly, three to one

gave me a Q value of 80. So basically, this Q matrix represents the memory of your agent. I hope all of you are clear with this. So basically, what we're gonna do is we're gonna keep

iterating through this loop until we've gone through

all possible states and reach the goal state, which is five.

Also, our main aim here is to

find the most optimum policy to get to room number five. Now let's implement the exact

same thing using Python. So that was a lot of theory. Now let's understand how

this is done practically. Alright, so we begin by

importing your library. We're gonna be using the

NumPy library over here. After that, we'll import the R matrix. We've already created the R matrix. This is the exact matrix that I showed you a couple of minutes ago. So I've created a matrix called R and I've basically stored

all the rewards in it. If you want to see the R

matrix, let me print it. So, basically, this is your R matrix. If you remember, node one to five, you have a reward of hundred. Node four to five, you

have a reward of hundred, and five to five, you

have a reward of hundred, because all of these nodes

directly lead us to the reward.

Correct? Next, what we're doing is

we're creating a Q matrix which is basically a six into six matrix. Which represents all the

states, zero to five. And this matrix is basically zero. After, that we're setting

the Gamma parameter. Now guys, you can play

around with this code, and you know you can

change the comma parameter to 0.7 or 0.9 and see how much more

the agent will explore or whether you perform exploitation. Here I've set the Gamma parameter 0.8 which is a pretty good number. Now what I'm doing is I'm

setting the initial state as one.

You can randomly choose this state according to your needs. I've set the initial state as one. Now, this function will basically give me all the available actions

from my initial state. Since I've set my initial state as one, It'll give me all the possible actions. Here what I'm doing is since

my initial state is one, I'm checking in my row number one, which value is equal to

zero or greater than zero. Those denote my available actions. So look at our row number one. Here we have one zero and

we have a hundred over here. This is one comma four and

this is one comma five. So if you look at the row number one, since I've selected the

initial state as one, we'll consider row number one.

Okay, what I'm doing is in row number one, I have two numbers which

are either equal to zero or greater than zero. These denote my possible actions. One comma three has the value of zero and one comma five has

the value of hundred, which means that the agent can either go to room number three or it can go to room number five. What I'm trying to say

is from room number one, you can basically go to room number three or room number five. This is exactly what I've coded over here. If you remember the reward matrix, from one you can traverse to

only room number three directly and room number five directly. Okay, that's exactly what I've mentioned in my code over here.

So this will basically give

me the available actions from my current state. Now once I've moved to me next state, I need to check the available

actions from that state. What I'm doing over

here is basically this. If you're remember, from room number one, we can

go to three and five, correct? And from three and five, I'll randomly select the state. And from that state, I need to find out all possible actions. That's exactly what I've done over here. Okay. Now this will randomly

choose an action for me from all my available actions. Next, we need to update our Q matrix, depending on the actions that we took, if you remember. So that's exactly what this

update function is four. Now guys, this entire is

for calculating the Q value. I hope all of you remember the formula, which is Q state comma action, R state comma action plus

Gamma into max value. Max value will basically

give me the maximum value out of the all possible actions.

I'm basically computing this formula. Now this will just update the Q matrix. Coming to the training phase, what we're gonna do is we

are going to set a range. Here I've set a range of 10,000, meaning that my agent will

perform 10,000 iterations. You can set this depending

on your own needs, and 10,000 iteration is

a pretty huge number. So, basically, my agent

is going to go through 10,000 possible iterations in order to find the best policy. Now this is the exact same

thing that we did earlier. We're setting the current state, and then we're choosing

the available action from the current state. The from there, we'll

choose an action at random. Here we'll calculate a Q value and we'll update the

Q value in the matrix.

Alright. And here I'm doing nothing, but I'm printing the trained Q matrix. This was the training phase. Now the testing phase, basically, you're going to randomly

choose a current state. You're gonna choose a current state, and you're going to keep looping through this entire code, until you reach the goal state,

which is room number five. That's exactly what I'm

doing in this whole thing.

Also, in the end, I'm

printing the selected part. That is basically the

policy that the agent took to reach room number five. Now if I set the current state as one, it should give me the best policy to reach to room number

five from room number one. Alright, let's run this code, and let's see if it's giving us that. Now before that happens, I

want you to check and tell me which is the best possible way to get from room number

one to room number five.

It's obviously directly like this. One to five is the best policy

to get from room number one to room number five. So we should get an

output of one comma five. That's exactly what we're getting this is a Q matrix with all the Q values, and here we are getting the selected path. So if your current state is one, your best policy is to

go from one to five. Now, if you want to

change your current state, let's say we set the current state to two. And before we run the code, let's see which is the best possible way to get to room number

five from room number two. From room number two, you can go to three, then you can go to one, and

then you can go to five. This will give you a reward of hundred, or you can go to room number three, then go to four, and then go to five. This will also give you

a reward of hundred. Our path should be something like that. Let's save it and let's run the file. So, basically, from stage two, you're going to say three, then to four, and then to five.

This is our best possible path from two to room number five. So, guys, this is exactly how the Q learning algorithm works, and this was a simple implementation of the entire example

that I just told you. Now if any of you still have doubts regarding Q learning or

reinforcement learning, make sure you comment them

in the comment section, and I'll try to answer all of your doubts. No we're done with machine learning. We've completed the whole

machine learning model. We've understood reinforcement learning, supervised learning,

unsupervised learning, and so on.

Before I'll get to deep learning, I want to clear a very

common misconception. A lot of people get confused between AI machine

learning and deep learning, because, you know,

artificial intelligence, machine learning and deep learning are very common applications. For example, Siri is an application of artificial intelligence, machine learning, and deep learning. So how are these three connected? Are they the same thing or how exactly is the relationship between

artificial intelligence, machine learning, and deep learning? This is what I'll be discussing. now artificial intelligence

is basically the science of getting machines to mimic

the behavior of human beings.

But when it comes to machine learning, machine learning is a subset

of artificial intelligence that focuses on getting

machines to make decisions by feeding them data. That's exactly what machine learning is. It is a subset of artificial intelligence. Deep learning, on the other hand, is a subset of machine learning that uses the concept of neural networks to solve complex problems. So, to sum it up, artificial intelligence, machine learning, and deep learning, are interconnected fields. Machine learning and deep learning aids artificial intelligence by providing a set of

algorithms and neural networks to solve data-driven problems.

That's how AI, machine

learning, and deep learning are related. I hope all of you have

cleared your misconceptions and doubts about AI,

ML, and deep learning. Now let's look at our next topic, which is limitations of machine learning. Now the first limitation

is machine learning is not capable enough to

handle high dimensional data. This is where the input and

the output is very large. So handling and processing

such type of data becomes very complex and it takes up a lot of resources. This is also sometimes known

as the curse of dimensionality. So, to understand this in simpler terms, look at the image shown on this slide. Consider a line of hundred yards and let's say that you dropped

a coin somewhere on the line.

Now it's quite convenient

for you to find the coin by simply walking along the line. This is very simple because

this line is considered as single dimensional entity. Now next, you consider that you have a square of hundred yards, and let's say you dropped a

coin somewhere in between. Now it's quite evident that

you're going to take more time to find the coin within that square as compared to the previous scenario. The square is, let's say,

a two dimensional entity.

Let's take it a step ahead

and let's consider a cube. Okay, let's say there's

a cube of 500 yards and you have dropped a coin

somewhere in between this cube. Now it becomes even more difficult for you to find the coin this time, because this is a three

dimensional entity. So, as your dimension increases, the problem becomes more complex. So if you observe that the complexity is increasing the increase

in your dimensions, and in real life, the

high dimensional data that we're talking about

has thousands of dimensions that makes it very complex

to handle and process. and a high dimensional data can easily be found in used

cases like image processing, natural language processing,

image translation, and so on. Now in K-means itself, we saw that we had 16

million possible colors. That is a lot of data. So this is why machine

learning is restricted. It cannot be used in the

process of image recognition because image recognition and

images have a lot of pixels and they have a lot of

high dimensional data.

That's why machine learning

becomes very restrictive when it comes to such uses cases. Now the second major challenge

is to tell the computer what are the features it should look for that will play an important role in predicted the outcome and

in getting a good accuracy. Now this process is something

known as feature extraction. Now feeding raw data to

the algorithm rarely works, and this is the reason

why feature extraction is a critical part of

machine learning workflow.

Now the challenge for the

programmer here increases because the effectiveness of the algorithm depends on how insightful

the programmer is. As a programmer, you have to tell the machine

that these are the features. And depending on these features, you have to predict the outcome. That's how machine learning works. So far, in all our demos, we saw that we were providing

predictor variables. we were providing input variables that will help us predict the outcome. We were trying to find

correlations between variables, and we're trying to find out the variable that is very important in

predicting the output variable. So this becomes a challenge

for the programmer. That's why it's very difficult to apply machine learning model to complex problems like object recognition,

handwriting recognition, natural language processing, and so on. Now all these problems and all these limitations

in machine learning led to the introduction of deep learning. Now we're gonna discuss

about deep learning.

Now deep learning is

one of the only methods by which we can overcome the challenges of feature extraction. This is because deep learning models are capable of learning to focus on the right features by themselves, which requires very little

guidance from the programmer. Basically, deep learning mimics

the way our brain functions. That is it learns from experience.

So in deep learning, what happens is feature extraction happens automatically. You need very little

guidance by the programmer. So deep learning will learn the model, and it will understand which

feature or which variable is important in predicting the outcome. Let's say you have millions

of predictor variables for a particular problem statement. How are you going to sit down and understand the significance of each of these predictor variables it's going to be almost impossible to sit down with so many features.

That's why we have deep learning. Whenever there's high dimensionality data or whenever the data is really large and it has a lot of features and a lot of predictor

variables, we use deep learning. Deep learning will extract

features on its own and understand which

features are important in predicting your output. So that's the main idea

behind deep learning. Let me give you a small example also. Suppose we want to make a system that can recognize the

face of different people in an image. Okay, so, basically,

we're creating a system that can identify the faces of

different people in in image. If we solve this by using the typical machine learning algorithms, we'll have to define

facial features like eyes, nose, ears, et cetera. Okay, and then the system will identify which features are more

important for which person.

Now, if you consider deep

learning for the same example, deep learning will automatically

find out the features which are important for classification, because it uses the

concept of neural networks, whereas in machine learning we have to manually define these features on our own. That's the main difference

between deep learning and machine learning. Now the next question is

how does deep learning work? Now when people started

coming up with deep learning, their main aim was to

re-engineer the human brain. Okay, deep learning studies

the basic unit of a brain called the brain cell or a neuron.

All of you biology students will know what I'm talking about. So, basically, deep learning is inspired from our brain structure. Okay, in our brains, we have

something known as neurons, and these neurons are

replicated in deep learning as artificial neurons, which are also called perceptrons. Now, before we understand how

artificial neural networks or artificial neurons work, let's understand how these

biological neurons work, because I'm not sure how many of you are bio students over here. So let's understand the

functionality of biological neurons and how we can mimic this functionality in a perceptron or in

an artificial neuron. So, guys, if you loo at this image, this is basically an image

of a biological neuron. If you focus on the structure

of the biological neuron, it has something known dendrites. These dendrites are basically

used to receive inputs. Now the inputs are basically

found in the cell body, and it's passed on the

next biological neuron. So, through dendrites, you're

going to receive signals from other neurons, basically, input.

Then the cell body will

sum up all these inputs, and the axon will transmit

this input to other neurons. The axon will fire up

through some threshold, and it will get passed

onto the next neuron. So similar to this, a perceptron

or an artificial neuron receives multiple inputs, and applies various

transformations and functions and provides us an output. These multiple inputs are

nothing but your input variables or your predictor variables. You're feeding input data

to an artificial neuron or to a perceptron, and this perceptron will apply various functions and transformations, and it will give you an output. Now just like our brain consists of multiple connected neurons

called neural networks, we also build something known as a network of artificial neurons called artificial neural networks. So that's the basic concept

behind deep learning. To sum it up, what

exactly is deep learning? Now deep learning is a collection of statistical machine learning techniques used to learn feature

hierarchies based on the concept of artificial neural networks.

So the main idea behind deep learning is artificial neural networks which work exactly like

how our brain works. Now in this diagram, you can see that there are a couple of layers. The first layer is known

as the input layer. This is where you'll

receive all the inputs. The last layer is known

as the output layer which provides your desired output. Now, all the layers which are

there between your input layer and your output layer are

known as the hidden layers. Now, they can be any

number of hidden layers, thanks to all the resources

that we have these days. So you can have hundreds of

hidden layers in between. Now, the number of hidden layers and the number of perceptrons

in each of these layers will entirely depend on the problem or on the use case that

you're trying to solve. So this is basically

how deep learning works. So let's look at the

example that we saw earlier. Here what we want to do

is we want to perform image recognition using deep networks.

First, what we're gonna

do is we are going to pass this high dimensional

data to the input layer. To mach the dimensionality

of the input data, the input layer will contain multiple sub layers of perceptrons so that it consume the entire input. Okay, so you'll have multiple

sub layers of perceptrons. Now, the output received

from the input layer will contain patterns and

will only be able to identify the edges of the images,

based on the contrast levels.

This output will then be fed

to hidden layer number one where it'll be able to

identify facial features like your eyes, nose,

ears, and all of that. Now from here, the output will be fed to hidden layer number two, where it will be able to form entire faces it'll go deeper into face recognition, and this output of the hidden layer will be sent to the output layer or any other hidden layer that is there before the output layer.

Now, finally, the output layer

will perform classification, based on the result that you'd get from your previous layers. So, this is exactly how

deep learning works. This is a small analogy that I use to make you understand

what deep learning is. Now let's understand what a

single layer perceptron is. So like I said, perceptron is basically an artificial neuron. For something known as single layer and multiple layer perceptron, we'll first focus on

single layer perceptron. Now before I explain what

a perceptron really is, you should known that perceptrons

are linear classifiers.

A single layer perceptron is a linear or a binary classifier. It is used mainly in supervised learning, and it helps to classify

the given input data into separate classes. So this diagram basically

represents a perceptron. A perceptron has multiple inputs. It has a set of inputs

labeled X one, X two, until X n. Now each of these input is

given a specific weight. Okay, so W one represents

the weight of input X one. W two represents the weight

of input X two, and so on. Now how you assign these weights is a different thing altogether. But for now, you need

to know that each input is assigned a particular weightage. Now what a perceptron does

is it computes some functions on these weighted inputs, and

it will give you the output.

So, basically, these weighted inputs go through something known as summation. Okay, summation is nothing but the product of each of your input with

its respective weight. Now after the summation is done, this passed onto transfer function. A transfer function is nothing

but an activation function. I'll be discussing more

about this in a minute. The activation function. And from the activation function, you'll get the outputs

Y one, Y two, and so on. So guys, you need to

understand four important parts in a perceptron. So, firstly, you have the input values. You have X one, X two, X three. You have something known

as weights and bias, and then you have something

known as the net sum and finally the activation function. Now, all the inputs X are multiplied with

the respective weights. So, X one will be multiplied with W one.

This is known as the summation. After this, you'll add

all the multiplied values, and we'll call them as the weighted sum. This is done using the summation function. Now we'll apply the weighted sum to a correct activation function. Now, a lot of people have a confusion about activation function. Activation function is also

known as the transfer function. Now, in order to understand

activation function, this word stems from the way neurons in a human brain work. The neuron becomes activate only after a certain potential is reached. That threshold is known as

the activation protection. Therefore, mathematically, it can be represented by a function that reaches saturation after a threshold. Okay, we have a lot of

activation functions like signum, sigmoid,

tan, hedge, and so on. You can think of activation function as a function that maps the input to the respective output. And now I also spoke

about weights and bias. Now why do we assign weights

to each of these inputs? What weights do is they show a strength of a particular input, or how important a particular input is for predicting the final output. So, basically, the weightage of an input denotes the importance of that input.

Now, our bias basically allows us to shift the activation function in order to get a precise output. So that was all about perceptrons. Now in order to make you

understand perceptrons better, let's look at a small analogy. Suppose that you wanna go to a party happening near your hose. Now your decision will

depend on a set of factors. First is how is the weather. Second probably is your

wife, or your girlfriend, or your boyfriend going with you. And third, is there any

public transport available? Let's say these are the three factors that you're going to consider

before you go to a party.

So, depending on these predictor variables or these features, you're going to decide whether

you're going to stay at home or go and party. Now, how is the weather is

going to be your first input. We'll represent this with a value X one. Is your wife going with

you is another input X two. Any public transport is available is your another input X three. Now, X one will have two

values, one and zero.

One represents that the weather is good. Zero represents weather is bad. Similarly, one represents

that your wife is going, and zero represents that

your wife is not going. And in X three, again, one represents that there is public transport, and zero represents that

there is no public transport. Now your output will

either be one or zero. One means you are going to the party, and zero means you will

be sitting at home. Now in order to understand weightage, let's say that the most

important factor for you is your weather. If the weather is good, it means that you will

100% go to the party. Now if you weather is not good, you've decided that you'll sit at home. So the maximum weightage is

for your weather variable. So if your weather is really good, you will go to the party. It is a very important

factor in order to understand whether you're going to sit at home or you're going to go to the party. So, basically, if X one equal to one, your output will be one. Meaning that if your weather is good, you'll go to the party.

Now let's randomly assign

weights to each of our input. W one is the weight

associated with input X one. W two is the weight with X two and W three is the weight

associated with X three. Let's say that your W one is six, your W two is two, and W three is two. Now by using the activation function, you're going to set a threshold of five. Now this means that it will fire when the weather is good and won't fire if the weather is bad, irrespective of the other inputs.

Now here, because your weightage is six, so, basically, if you

consider your first input which has a weightage of six, that means you're 100% going to go. Let's say you're considering

only the second input. This means that you're not going to go, because your weightage is two

and your threshold is five. So if your weightage is

below your threshold, it means that you're not going to go. Now let's consider another scenario where our threshold is three. This means that it'll fire when either X one is high or the other two inputs are high. Now W two is associated with

your wife is going or not. Let's say the weather is bad and you have no public transportation, meaning that your x one

and x three is zero, and only your x two is one. Now if your x two is one, your weightage is going to be two.

If your weightage is two, you will not go because the

threshold value is set to three. The threshold value is

set in such a way that if X two and X three

are combined together, only then you'll go, or only if x one is true, then you'll go. So you're assigning

threshold in such a way that you will go for sure

if the weather is good. This is how you assign threshold. This is nothing but your

activation function. So guys, I hope all of you understood, the most amount of weightage is associated with the

input that is very important in predicting your output. This is exactly how a perceptron works. Now let's look at the

limitations of a perceptron. Now in a perceptron, there

are no hidden layers. There's only an input layer, and there is an output layer. We have no hidden layers in between. And because of this, you cannot classify non-linearly separable data points. Okay, if you have data,

like in this figure, how will you separate this.

You cannot use a perceptron to do this. Alright, so complex problems that involve a lot of parameters cannot be solved by a single layer perceptron. That's why we need something known as multiple layer perceptron. So now we'll discuss something known as multilayer perceptron. A multilayer perceptron

has the same structure of a single layer perceptron, but with one or more hidden layer. Okay, and that's why it's

consider as a deep neural network. So in a single layer perceptron, we had only input layer, output layer. We didn't have any hidden layer.

Now when it comes to

multi-layer perceptron, there are hidden layers in between, and then there is the output layer. It was in this similar

manner, like I said, first, you'll have the

input X one, X two, X three, and so on. And each of these inputs

will be assigned some weight. W one, W two, W three, and so on. Then you'll calculate

the weighted summation of each of these inputs and their weights. After that, you'll send

them to the transformation or the activation function, and you'll finally get the output. Now, the only thing is

that you'll have multiple hidden layers in between, one or more than one hidden layers. So, guys, this is how a

multilayer perceptron works. It works on the concept of

feed forward neural networks.

Feed forward means

every node at each level or each layer is connected

to every other node. So that's what feed forward networks are. Now when it comes to assigning weights, what we do is we randomly assign weights. Initially we have input

X one, X two, X three. We randomly assign some

weight W one, W two, W three, and so on. Now it's always necessary

that whatever weights we assign to our input, those weights are actually correct, meaning that those weights

are company significant in predicting your output. So how a multilayer perceptron works is a set of inputs are passed

to the first hidden layer. Now the activations from

that layer are passed through the next layer. And from that layer, it's

passed to the next hidden layer, until you reach the output layer. From the output layer,

you'll form the two classes, class one and class two. Basically, you'll classify your input into one of the two classes. So that's how a multilayer

perceptron works. A very important concept the

multiple layer perceptron is back propagation.

Now what is back propagation. Back propagation algorithm is a supervised learning method

for multilayer perceptrons. Okay, now why do we need back propagation? So guys, when we are

designing a neural network in the beginning, we initialize weights with some random values, or

any variable for that fact. Now, obviously, we need to

make sure that these weights actually are correct, meaning that these weights

show the significance of each predictor variable. These weights have to fit our model in such a way that our

output is very precise. So let's say that we randomly selected some weights in the beginning, but our model output

is much more different than our actual output, meaning that our error value is very huge.

So how will you reduce this error. Basically, what you need to do is we need to somehow explain to the model that we need to change the weight in such a way that the

error becomes minimum. So the main thing is the

weight and your error is very highly related. The weightage that you give to each input will show how much error

is there in your output, because the most significant variables will have the highest weightage. And if the weightage is not correct, then your output is also not correct. Now, back propagation is a

way to update your weights in such a way that your outcome is precise and your error is reduced. So, in short back

propagation is used to train a multilayer perceptron. It's basically use to update your weights in such a way that your

output is more precise, and that your error is reduced.

So training a neural network

is all about back propagation. So the most common deep learning algorithm for supervised training of

the multilayer perceptron is known as back propagation. So, after calculating the

weighted sum of inputs and passing them through

the activation function, we propagate backwards

and update the weights to reduce the error. It's as simple as that. So in the beginning, you're

going to assign some weights to each of your input. Now these inputs will go

through the activation function and it'll go through all the hidden layers and give us an output.

Now when you get the output, the output is not very precise, or it is not the desired output. So what you'll do is

you'll propagate backwards, and you start updating your weights in such a way that your error is as minimum as possible. So, I'm going to repeat this once more. So the idea behind back propagation is to choose weights in such a way that your error gets minimized. To understand this, we'll

look at a small example. Let's say that we have a data

set which has these labels. Okay, your input is zero, one, two, but your desired output

is zero, one, and four now the output of your model when W equal to three is like this.

Notice the difference

between your model output and your desired output. So, your model output is three, but your desired output is two. Similarly, when your model output is six, your desired output is

supposed to be four. Now let's calculate the error

when weight is equal to three. The error is zero over here because your desired output is zero, and your model output is also zero. Now the error in the second case is one. Basically, your model output

minus your desired output. Three minus two, your error is one. Similarly, your error for

the third input is two, which is six minus four. When you take the square, this is actually a very huge difference, your error becomes larger.

Now what we need to do is we need to update the weight value in such a way that our error decreases. Now here we've considered

the weight as four. So when you consider the weight as four, your model output becomes

zero, four, and eight. Your desired output is

zero, two, and four. So your model output becomes

zero, four, and eight, which is a lot. So guys, I hope you all know how to calculate the output over here. What I'm doing is I'm

multiplying the input with your weightage. The weightage is four, so zero into four will give me zero. One into four will give me four, and two into four will give me eight. That's how I'm getting my

model output over here. For now, this is how I'm

getting the output over here. That's how you calculate your weightage. Now, here, if you see

that our desire output is supposed to be zero, two, and four, but we're getting an output

of zero, four, and eight. So our error is actually increasing as we increase our weight. Our error four W equal to four have become zero, four, and 16, whereas the error for W equal to three, zero, one, and four.

I mean the square error. So if you look at this, as

we increase our weightage, our error is increasing. So, obviously, we know that there is no point in increasing

the value of W further. But if we decrease the value of W, our error actually decreases. Alright, if we give a weightage of two, our error decreases. If we can find a relationship

between our weight and error, basically, if you increase the weight, your error also increases. If you decrease the weight,

your error also decreases. Now what we did here

is we first initialize some random value to W, and then we propagated forward.

Then we notice that there is some error. And to reduce that error,

we propagated backwards and increase the value of W. After that, we notice that

the error has increased, and we came to know that we

can't increase the w value. Obviously, if your error is increasing with increasing your weight, you will not increase the weight. So again, we propagated backwards, and we decreased the W value. So, after that, we noticed

that the error has reduced. So what we're trying

is we're trying to get the value of weight in such a way that the error becomes

as minimum as possible so we need to figure out whether we need to increase or decrease thew eight value. Once we know that, we keep

on updating the weight value in that direction, until the error becomes minimum. Now you might reach a point where if you further update the weight, the error will again increase. At that point, you need to stop.

Okay, at that point is where your final weight value is there. So, basically, this

graph denotes that point. Now this point is nothing

but the global loss minimum. If you update the weights further, your error will also increase. Now you need to find out where

your global loss minimum is, and that is where your

optimum weight lies. So let me summarize the steps for you. First, you'll calculate the error. This is how far your model output is from your actual output. Then you'll check whether the error is minimized or not. After that, if the error is very huge, then you'll update the weight, and you'll check the error again. You'll repeat the process

until the error becomes minimum now once you reach the

global loss minimum, you'll stop updating the weights, and we'll finalize your weight value. This is exactly how

back propagation works. Now in order to tell you

mathematically what we're doing is we're using a method

known as gradient descent. Okay, this method is used to adjust all the weights in the network with an aim of reducing the

error at the output layer.

So how gradient descent

optimize our works is the first step is you

will calculate the error by considering the below equation. Here you're subtracting the

summation of your actual output from your network output. Step two is based on the error you get, you will calculate the

rate of change of error with respect to the change in the weight. The learning rate is

something that you set in the beginning itself. Step three is based on

this change in weight, you will calculate the new weight. Alright, your updated

weight will be your weight plus the rate of change of weight. So guys, that was all about back propagation and weight update.

Now let's look at the limitations

of feed forward network. So far, we were discussing

the multiple layer perceptron, which uses the feed forward network. Let's discuss the limitations of these feed forward networks. Now let's consider an example

of image classification. Okay, let's say you've

trained the neural network to classify images of various animals. Now let's consider an example. Here the first output is an elephant. We have an elephant. And this output will have nothing to do with the previous output, which is a dog. This means that the output at time T is independent of the

output at time T minus one. Now consider this scenario where you will require the use of previously obtained output. Okay, the concept is very

similarly to reading a book. As you turn every page, you need an understanding of the previous pages if you want to make

sense of the information, then you need to know

what you learned before.

That's exactly what

you're doing right now. In order to understand deep learning, you have to understand machine learning. So, basically, with the

feed forward network the new output at time T plus one has nothing to do with

the output at time T, or T minus one, or T minus two. So feed forward networks cannot be used while predicting a word in a sentence, as it will have absolutely no relationship with the previous set of words.

So, a feed forward

network cannot be used in use cases wherein you have

to predict the outcome based on your previous outcome. So, in a lot of use cases, your previous output will also

determine your next output. So, for such cases, you may not make use of feed forward network. Now, what modification can you make so that your network can learn from your previous mistakes. For this, we have solution. So, a solution to this is

recurrent neural networks. So, basically, let's say you have an input at time T minus one, and you'll get some output when

you feed it to the network.

Now, some information from

this input at T minus one is fed to the next input, which is input at time T. Some information from this output is fed into the next input, which is input at T plus one. So, basically, you keep

feeding information from the previous input to the next input. That's how recurrent neural

networks really work. So recurrent networks are a type of artificial neural networks designed to recognize

patterns in sequence of data, such as text, genomes,

handwriting, spoken words, time series data, sensors, stock markets, and government agencies. So, guys, recurrent neural

networks are actually a very important part of deep learning, because recurring neural networks have applications in a lot of domains.

Okay, in time series and in stock markets, the main network that I use are recurrent neural networks, because each of your inputs are correlated now to better understand

recurrent neural networks, let's consider a small example let's say that you go

to the gym regularly, and the trainer has given you a schedule for your workout. So basically, the exercises are repeated after every third day. Okay, this is what your

schedule looks like. So, make a note that all

these exercises are repeated in a proper order or in

a sequence every week first, let us use a feedforward network to try and predict the type of exercises that we're going to do. The inputs here are Day

of the week, the month, and your health status. Okay, so, neural network has to be trained using these inputs to provide

us with the prediction of the exercise that we should do. Now let's try and understand

the same thing using recurrent neural networks.

In recurrent neural networks, what we'll do is we'll consider the inputs of the previous day. Okay, so if you did a

shoulder workout yesterday, then you can do a bicep exercise today, and this goes on for the rest of the week. However, if you happen

to miss a day at the gym, the data from the previously

attended time stamps can be considered. It can be done like this. So, if a model is

trained based on the data it can obtain from the previous exercise, the output on the model

will be extremely accurate. In such cases, if you

need to do know the output at T minus one in order to

predict the output at T. In such cases, recurrent neural

networks are very essential. So, basically, I'm feeding some inputs through the neural networks. You'll go through a few functions, and you'll get the output. So, basically, you're

predicting the output based on past information

or based on your past input. So that's how recurrent

neural networks work.

Now let's look at another

type of neural network known as convolutional neural network. To understand why we need

convolutional neural networks, let's look at an analogy. How do you think a

computer reads an image? Consider this image. This is a New York skyline image. On the first glance, you'll see a lot of buildings

and a lot of colors. How does a computer process this image? The image is actually broken

down into three color channels, which is the red, green, and blue. It reads in the form of RGB values. Now each of these color

channels are mapped with the image's pixel then the computer will recognize the value associated with each pixel, and determine the size of the image. Now for the black and white images, there is only one channel, but the concept is still the same. The thing is we cannot make use of fully connected networks when it comes to convolutional neural networks. I'll tell you why.

Now consider the first input image. Okay, first image has size about 28 into 28 into three pixels. And if we input this to a neural network, we'll get about 2,352 weights in the first hidden layer itself. Now consider another example. Okay, let's say we have an image of 200 into 200 into three pixels. So the size of your first hidden layer becomes around 120,000. Now if this is just

the first hidden layer, imagine the number of

neurons that you need to process an entire complex image set. This leads to something

known as overfitting, because all of the hidden

layers are connected. They're massively connected. There's connection between

each and every node. Because of this, we face overfitting. We have way too much of data. We have to use way too many neurons, which is not practical. So that's why we have something known as convolutional neural networks. Now convolutional neural networks, like any other neural network are made up of neurons with

learnable weights and basis. So each neuron receives several input. It takes a weighted sum over them, and it gets passed on through

some activation function, and finally responds with an output.

So, the concept in

convolutional neural networks is that the neuron in a particular layer will only be connected to a small region of the layer before it. Not all the neurons will be connected in a fully-connected manner, which leads to overfitting because we need way too many neurons to solve this problem. Only the regions, which are significant are connected to each other. There is no full connection in convolutional neural networks. So gus, what we did so far is we discussed what a perceptron is. We discussed the different types of neural networks that are there. We discussed a feedforward neural network. We discuss multi layer perceptrons we discussed recurrent neural networks, and convolutional neural networks. I'm not going to go too much in depth with these concepts now I'll be executing a demo. If you you haven't understood any theoretical concept of deep learning, please let me know in the comment section.

Apart from this, I'll also leave a couple of links in the description box, so that you understand the

whole download in a better way. Okay, if you want a more

in-depth explanation, I'll leave a couple of links

in the description box. For now, what I'm gonna

do is I'll be running a practical demonstration to show you what exactly download does so, basically, what we're

going to do in this demo is we're going to predict stock prices. Like I said, stock price prediction is one of the very good applications of deep neural networks. You can easily predict the stock price of a particular stock for the next minute or the next day by using

deep neural networks. So that's exactly what

we're gonna do in this demo now, before I discuss the code, let me tell you a few

things about our data set. The data set contains

around 42,000 minutes of data ranging from April to August 2017 on 500 stocks, as well as the total S&P 500 Index price.

So the index and stocks are arranged in a wide format. So, this is my data set, data_stocks. It's in the CSV format. So what I'm gonna do is I'm going to use the read CSV function in

order to import this data set. This is just the part of

where my data set is stored. This data set was actually

cleaned and prepared, meaning that we don't

have any missing stock and index prices. So the file does not

contain any missing values. Now what we're gonna do first is we'll drop the data valuable we have a variable known as date, which is not really necessary in predicting our outcome over here. So that's exactly what I'm doing here. I'm just dropping the date variable. So here, I'm checking the

dimensions of the data set. This is pretty understandable, using the shape function to do that.

Now, always you make the

data as a NymPy array. This makes computation much easier. The next process is the data splicing. I've already discussed data

the data splicing with you all. Here we're just preparing the training and the testing data. So the training data will contain 80% of the total data set. Okay, and also we are not

shuffling the data set. We're just slicing the

data set sequentially. That's why we have a test start start and the test end variable. In sequence, I'll be selecting the data. There's no need of

shuffling this data set. These are stock prices it does not make sense

to shuffle this data. Now in the next step, we're going to do is we're going to scale the data now, scaling data and data normalization is one of the most important steps. You cannot miss this step I already mentioned earlier what normalization and scaling is. Now most neural networks benefit from scaling inputs.

This is because most

common activation function of the networks neuron such

as tan, hedge, and sigmoid. Tan, hedge, and sigmoid are

basically activation functions, and these are defined in the

range of minus one to one or zero and one. So that's why scaling

is an important thing in deep neural networks for scaling, again, we'll

use the MinMaxScaler. So we're just importing

that function over here. And also one point to note is that you have to be very cautious about what part of data you're scaling and when you're doing it.

A very common mistake is

to scale the whole data set before training and test

splits are being applied. So before data splicing itself, you shouldn't be scaling your data. Now this is a mistake because scaling invokes the

calculation of statistics. For example, minimum or

maximum range of the variable gets affected. So when performing time series

forecasting in real life, you do not have information

from future observations at the time of forecasting. That's why calculation

of scaling statistics has to be conducted on training data, and only then it has to be

applied to the test data. Otherwise, you're basically

using the future information at the time of forecasting, which obviously going to lead to biasness so that's why you need to make sure you do scaling very accurately. So, basically, what we're

doing is the number of features in the training data are stored in a variable known as n stocks.

After this, we'll import

the infamous TensorFlow. So guys, TensorFlow is

actually a very good piece of software and it

is currently the leading deep learning and neural

network computation framework. It is based on a C++ low-level backend, but it's usually

controlled through Python. So TensorFlow actually operates as a graphical representation

of your computations. And this is important

because neural networks are actually graphs of data

and mathematical operation. So that's why TensorFlow is just perfect for neural networks and deep learning. So the next thing after

importing the TensorFlow library is something known as placeholders. Placeholders are used to

store, import, and target data. We need two placeholders

in order to fit our model. So basically, X will

contain the network's input, which is the stock

prices of all the stocks at time T equal to T. And y will contain the network's output, which is the stock price at

time T is equal to T plus one. Now the shape of the X placeholder means that the inputs are

two-dimensional matrix. And the outputs are a

one-dimensional vector. So guys, basically, the

non-argument indicates that at this point we do not yet know the number of observations that'll flow through the neural network.

We just keep it as a

flexible array for now. We'll later define the variable batch size that controls the number of observations in each training batch. Now, apart form this, we also have something know as initializers. Now, before I tell you what

these initializers are, you need to understand that there's something known as variables that are used as flexible containers that are allowed to change

during the execution. Weights and bias are

represented as variables in order to adapt during training. I already discuss weights

and bias with you earlier. Now weights and bias is something that you need to initialize

before you train the model. That's how we discussed it

even while I was explaining neural networks to you.

So here, basically, we make

use of something known as variant scaling initializer and for bias initializer, we make use of zeros initializers. These are some predefined

functions in our TensorFlow model. We'll not get into the

depth of those things. Now let's look at our model

architecture parameters. So the next thing we have to discuss is the model architecture parameters. Now the model that we build, it consists of four hidden layers. For the first layer, we've

assigned 1,024 neurons which is likely more than

double the size of the inputs. The subsequent hidden layers are always half the size of the previous layer, which means that in the

hidden layer number two, we'll have 512 neurons.

Hidden layer three will have 256. And similarly, hidden layer number four will have 128 neurons. Now why do we keep reducing

the number of neurons as we go through each hidden layer. We do this because the number of neurons for each subsequent layer

compresses the information that the network identifies

in the previous layer. Of course there are other

possible network architectures that you can apply for

this problem statement, but I'm trying to keep

it as simple as possible, because I'm introducing

deep learning to you all.

So I can't build a model architecture that's very complex and hard to explain. And of course, we have output over here which will be assigned a single neuron. Now it is very important to understand that variable dimensions

between your input, hidden, and output layers. So, as a rule of thumb in

multilayer perceptrons, the second dimension of the previous layer is the first dimension

in the current layer. So the second dimension

in my first hidden layer is going to be my first dimension

in my second hidden layer.

Now the reason behind

this is pretty logical. It's because the output

from the first hidden layer is passed on as an input

to the second hidden layer. That's why the second

dimension of the previous layer is the same as the first dimension of the next layer or the current layer. I hope this is understandable. Now coming to the bias

dimension over here, the bias dimension is always equal to the second dimension

of your current layer, meaning that you're just going to pass the number of neurons in

that particular hidden layer as your dimension in your bias. So here, the number of neurons, 1,024, you're passing the same number

as a parameter to your bias. Similarly, even for

hidden layer number two, if you see a second dimension here is n_neurons_2. I'm passing the same

parameter over here as well. Similarly, for hidden layer three and hidden layer number four. Alright, I hope this is understandable now we come to the output layer. The output layer will obviously have the output from hidden layer number four. This is our output from hidden layer four that's passed as the first

dimension in our output layer, and it'll finally have your n target, which is set to one over here.

This is our output. Your bias will basically have

the current layer's dimension, which is n target. You're passing that same

parameter over here. Now after you define the required weight and the bias variables, the architecture of the

network has to be specified. What you do is placeholders and variables need to be combined into a system of sequential matrix multiplication. So that's exactly what's

happening over here. Apart from this, all the hidden layers need to be transformed by

using the activation function. So, activation functions are important components of the network because they introduce

non-linearity to the system. This means that high dimensional data can be dealt with with the help

of the activation functions.

Obviously, we have very

high dimensional data when it comes to neural networks. We don't have a single dimension or we don't have two or three inputs. We have thousands and thousands of inputs. So, in order for a

neural network to process that much of high dimensional data, we need something known

as activation functions. That's why we make use

of activation functions. Now, there are dozens

of activation functions, and one of the most common one is the rectified linear unit, rectified linear unit. RELU is nothing but rectified linear unit, which is what we're gonna

be using in this model. So, after, you applied the

transformation function to your hidden layer, you

need to make sure that your output is transposed. This is followed by a very

important function known as cost function. So the cost function of a network is used to generate a measure of deviation between the network's prediction and the actual observed training targets.

So this is basically your actual output minus your model output. It basically calculates the

error between your actual output and your predicted output. So, for regression problems,

the mean squared error function is commonly used. I have discussed MSC, mean

squared error, before. So, basically, we are just measuring the deviation over here. MSC is nothing bot your deviation from your actual output. That's exactly what we're doing here. So after you've computed your error, the next step is obviously to update your weight and your bias. So, we have something

known as the optimizers. They basically take care of

all the necessary computations that are needed to adapt

the network's weight and bias variables during

the training phase. That's exactly what's happening over here. Now the main function of

this optimizer is that it invoke something known as a gradient. Now if you all remember, we

discussed gradient before it basically indicates the direction in which the weights and the bias has to be changed during the training in order to minimize the

network's cost function or the network's error.

So you need to figure out

whether you need to increase the weight and the bias in

order to decrease the error, or is it the other way around? You need to understand the relationship between your error and

your weight variable. That's exactly what the optimizer does. It invokes the gradient. We will give you the

direction in which the weights and the bias have to be changed. So now that you know

what an optimizer does, in our model, we'll be using something known as the AdamOptimizer. This is one of the

current default optimizers in deep learning. Adam basically stands for

adaptive moment estimation, and it can be considered

as a combination between very two popular optimizers

called Adagrad and RMSprop. Now let's not get into the

depth of the optimizers. The main agenda here is for you to understand the

logic behind deep learning. We don't have to go into the functions. I know these are predefined functions which TensorFlow takes care of. Next we have something

known as initializers. Now, initializers are used to initialize the network's variables before training.

We already discussed this before. I'll define the initializer here again. I've already done it

earlier in this session. Initializers are already defined. So I just removed that line of code. Next step would be fitting

the neural network. So after we've defined the

place holders, the variables, variables which are

basically weights and bias, the initializers, the cost functions, and the optimizers of the network, the model has to be trained. Now, this is usually done by using the mini batch training method, because we have very huge data set. So it's always best to use the

mini batch training method. Now what happens during

mini batch training is random data samples of any batch size are drawn from the training data, and they are fed into the network.

So the training data set gets divided into N divided by your batch size batches that are sequentially

fed into the network. So, one after the other, each of these batches will

be fed into the network. At this point, the placeholder

which are your X and Y, they come into play. They store the input and the target data and present them to the

network as inputs and targets. That's the main functionality

of placeholders. What they do is they store

the input and the target data, and they provide this to the network as inputs and targets. That's exactly what your placeholders do.

So let's say that a

sample data batch of X. Now this data batch

flows through the network until it reaches the output layer. There the TensorFlow compares

the model's predictions against the actual observed targets, which is stored in Y. If you all remember, we stored our actual

observed targets in Y. After this, TensorFlow will conduct something known as optimization step, and it'll update the network's parameters like the weight of the

network and the bias. So after having update

your weight and the bias, the next batch is sampled and

the process gets repeated. So this procedure will continue until all the batches have

presented to the network. And one full sweep over all batches is known as an epoch. So I've defined this

entire thing over here. So we're gonna go through 10 epochs, meaning that all the batches are going to go through training, meaning you're going to

input each batch that is X, and it'll flow through the network until it reaches the output layer.

There what happens is TensorFlow will compare your predictions. That is basically what

your model predicted against the actual observed targets which is stored in Y. After this, TensorFlow

will perform optimization wherein it'll update the network paramters like your weight and your bias. After you update the weight and the bias, the next batch will get sampled and the process will keep repeating. This happens until all the batches are implemented in the network. So what I just told you was one epoch. We're going to repeat this 10 times. So a batch size is 256, meaning that we have 256 batches. So here we're going to assign x and y, what I just spoke to you about. The mini batch training starts over here so, basically, your first batch will start flowing through the network until it reaches the output layer. After this, TensorFlow will

compare your model's prediction.

This is where predictions happen. It'll compare your model's prediction to the actual observed targets which is stored in y. Then TensorFlow will

start doing optimization, and it'll update the network paramters like your weight and your bias. So after you update the

weight and the biases, the next batch will get

input into the network, and this process will keep repeating. This process will repeat 10 times because we've defined 10 epochs. Now, also during the training, we evaluate the network's

prediction on the test set, which is basically the data

which we haven't learned, but this data is set aside

for every fifth batch, and this is visualized.

So in our problem statement, what a network is going to do is it's going to predict the stock price continuously over a time

period of T plus one. We're feeding it data about

a stock price at time T. It's going to give us an

output of time T plus one. Now let me run this code and let's see how close

our predicted values are to the actual values. We're going to visualize

this entire thing, and we've also exported this in order to combine it

into a video animation. I'll show you what the video looks like. So now let's look at our visualization. We'll look at our output. So the orange basically

shows our model's prediction. So the model quickly learns the shape and the location of the

time series in the test data and showing us an accurate prediction. It's pretty close to

the actual prediction. Now as I'm explaining this to you, each batch is running here.

We are at epoch two. We have 10 epochs to go over here. So you can see that the

network is actually adapting to the basic shape of the time series, and it's learning finer

patterns in the data. You see it keeps learning patterns and the production is

getting closer and closer after every epoch. So let just wait til we reach epoch 10 and we complete the entire process. So guys, I think the

predictions are pretty close, like the pattern and the

shape is learned very well by our neural network. It is actually mimicking this network. The only deviation is in the values. Apart from that, it's learning the shape of the time series data

in almost the same way.

The shape is exactly the same. It looks very similar to me. Now, also remember that

there are a lot of ways of improving your result. You can change the design of your layers or you can change the number of neurons. You can choose different

initialization functions and activation functions. You can introduce something

known as dropout layers which basically help you

to get rid of overfitting, and there's also something

known as early stopping. Early stopping helps you understand where you must stop your batch training. That's also another method

that you can implement for improving your model. Now there are also different

types of deep learning model that you can use for this problem. Here we use the feedforward network, which basically means that the batches will flow from left to right. Okay, so our 10 epochs are over. Now the final thing that's

getting calculate is our error, MSC or mean squared error.

So guys, don't worry about this warning. It's just a warning. So our mean square error

comes down to 0.0029 which is pretty low because

the target is scaled. And this means that our

accuracy is pretty good. So guys, like I mentioned, if you want to improve

the accuracy of the model, you can use different schemes, you can use different

initialization functions, or you can try out different

transformation functions. You can use something

known as dropout technique and early stopping in order

to make the training phase even more better. So guys, that was the end

of our deep learning demo.

I hope all of you understood

the deep learning demo. For those of you who are just learning deep learning for the first time, it might be a little confusing. So if you have any doubts

regarding the demo, let me know in the comment section. I'll also leave a couple of

links in the description box, so that you can understand deep learning in a little more depth. Now let's look at our

final topic for today, which is natural language processing. Now before we understand

what text mining is and what natural language processing is, we have to understand

the need for text mining and natural language processing.

So guys, the number one reason why we need text mining and natural

language processing is because of the amount of data that we're generating during this time. Like I mentioned earlier, there are around 2.5

quintillion bytes of data that is created every day, and this number is only going to grow. With the evolution of communication through social media, we generate tons and tons of data. The numbers are on your screen. These numbers are

literally for every minute. On Instagram, every minute, 1.7

million pictures are posted. Okay, 1.7 or more than 1.7

million pictures are posted. Similarly, we have tweets. We have around 347,000 tweets

every minute on Twitter. This is actually a lot and lot of data. So, every time we're using a phone, we're generating way too much data. Just watching a video on YouTube is generating a lot of data. When sending text messages from WhatsApp, that is also generating

tons and tons of data. Now the only problem is

not our data generation.

The problem is that out of all the data that we're generating,

only 21% of the data is structured and well-formatted. The remaining of the data is unstructured, and the major source of

unstructured data include text messages from

WhatsApp, Facebook likes, comments on Instagram, bulk emails that we send out ever single day. All of this accounts for

the unstructured data that we have today.

Now the question here is what can be done with so much data. Now the data that we generate can be used to grow businesses. By analyzing and mining the data, we can add more value to a business. This exactly what text

mining is all about. So text mining or text analytics is the analysis of data available to us in a day-to-day spoken

or written language. It is amazing so much

data that we generate can actually be used in text mining.

We have data from word Word documents, PowerPoints, chat messages, emails. All of this is used to

add value to a business now the data that we get from sources like social media, IoT, they are mainly unstructured, and unstructured data cannot be used to draw useful insights

to grow a business. That's exactly why we need to text mining. Text mining or text analytics is the process of deriving

meaningful information from natural language text. So, all the data that we

generate through text messages, emails, documents, files, are written in natural language text. And we are going to use text mining and natural language processing to draw useful insights or

patterns from such data. Now let's look at a few examples to show you how natural

language processing and text mining is used. So now before I move any further, I want to compare text mining and NLP. A lot of you might be confused about what exactly text mining is and how is it related to

natural language processing. A lot of people have also asked me why is NLP and text mining considered as one and the same and are they the same thing.

So, basically, text mining is a vast field that makes use of natural

language processing to derive high quality

information from the text. So, basically, text mining is a process, and natural language

processing is a method used to carry out text mining. So, in a way, you can say that text mining is a vast field which uses and NLP in order perform text

analysis and text mining. So, NLP is a part of text mining. Now let's understand what exactly natural language processing is.

Now, natural language processing is a component of text mining which basically helps a

machine in reading the text. Obviously, machines don't

actually known English or French, they interpret data in the

form of zeroes and ones. So this is where natural

language processing comes in. NLP is what computers and smart phones use to understand our language, both spoken and written language. Now because use language to

interact with our device, NLP became an integral part of our life. NLP uses concepts of computer science and artificial intelligence to study the data and derive

useful information from it. Now before we move any further, let's look at a few applications

of NLP and text mining. Now we all spend a lot

of time surfing the webs. Have you ever notice that if you start typing a word on Google, you immediately get

suggestions like these. These feature is also

known as auto complete. It'll basically suggest the

rest of the word for you.

And we also have something

known as spam detection. Here is an example of

how Google recognizes the misspelling Netflix and shows results for keywords

that match your misspelling. So, the spam detection is also based on the concepts of text mining and natural language processing. Next we have predictive

typing and spell checkers. Features like auto correct,

email classification are all applications

of text mining and NLP.

Now we look at a couple

of more applications of natural language processing. We have something known

as sentimental analysis. Sentimental analysis is extremely useful in social media monitoring, because it allows us to gain an overview of the wider public opinion

behind certain topics. So, basically, sentimental analysis is used to understand the public's opinion or customer's opinion on a certain product or on a certain topic. Sentimental analysis is

actually a very huge part of a lot of social media platforms like Twitter, Facebook. They use sentimental

analysis very frequently. Then we have something known as chatbot. Chatbots are basically the solutions for all the consumer frustration, regarding customer call assistance.

So we have companies like Pizza Hut, Uber who have started using chatbots to provide good customer service, apart form that speech recognition. NLP has widely been used

in speech recognition. We're all aware of Alexa,

Siri, Google Assistant, and Cortana. These are all applications of

natural language processing. Machine translation is another

important application of NLP. An example of this is

the Google Translator that uses NLP to process and translate one language to the other. Other application include spell checkers, keywords search, information extraction, and NLP can be used to

get useful information from various website, from word documents, from files, and et cetera.

It can also be used in

advertisement matching. This basically means a

recommendation of ads based on your history. So now that you have a

basic understanding of where natural language processing is used and what exactly it is, let's take a look at

some important concepts. So, firstly, we're gonna

discuss tokenization. Now tokenization is the mos

basic step in text mining. Tokenization basically

means breaking down data into smaller chunks or tokens so that they can be easily analyzed. Now how tokenization works is it works by breaking a

complex sentence into words. So you're breaking a

huge sentence into words. You'll understand the

importance of each of the word with respect to the whole sentence, after which will produce a description on an input sentence. So, for example, let's

say we have this sentence, tokens are simple. If we apply tokenization on this sentence, what we get is this.

We're just breaking a sentence into words. Then we're understanding the importance of each of these words. We'll perform NLP process

on each of these words to understand how important each word is in this entire sentence. For me, I think tokens and

simple are important words, are is basically another stop word. We'll be discussing about stop

words in our further slides. But for now, you eed to

understand that tokenization is a very simple process that involves breaking sentences into words. Next, we have something known as stemming. Stemming is basically normalizing words into its base form or into its root form. Take a look at this example. We have words like detection, detecting, detected, and detections. Now we all know that the root word for all these words is detect.

Basically, all these words mean detect. So the stemming algorithm

works by cutting off the end or the beginning of the word and taking into account

a list of common prefixes and suffixes that can

be found on any word. So guys, stemming can be

successful in some cases, but not always. That is why a lot of people affirm that stemming has a lot of limitations. So, in order to overcome

the limitations of stemming, we have something known as lemmatization. Now what lemmatization does is it takes into consideration

the morphological analysis of the words. To do so, it is necessary to

have a detailed dictionary which the algorithm can look

through to link the form back to its lemma. So, basically lemmatization is also quite similar to stemming. It maps different words

into one common root.

Sometimes what happens in stemming is that most of the words gets cut off. Let's say we wanted to

cut detection into detect. Sometimes it becomes

det or it becomes tect, or something like that. So because of this, the grammar or the importance of the word goes away. You don't know what

the words mean anymore. Due to the indiscriminate

cutting of the word, sometimes the grammar the

understanding of the word is not there anymore. So that's why lemmatization

was introduced. The output of lemmatization

is always going to be a proper word. Okay, it's not going to be

something that is half cut or anything like that. You're going to understand

the morphological analysis and then only you're going

to perform lemmatization. An example of a lemmatizer is you're going to convert

gone, going, and went into go. All the three words anyway

mean the same thing. So you're going to convert it into go. We are not removing the first

and the last part of the word.

What we're doing is we're understanding the grammar behind the word. We're understanding the English or the morphological analysis of the word, and only then we're going

to perform lemmatization. That's what lemmatization is all about. Now stop words are basically a set of commonly used words in any

language, not just English. Now the reason why stop words are critical to many applications is that if we remove the words

that are very commonly used in a given language, we can finally focus

on the important words.

For example, in the

context of a search engine, let's say you open up Google and you try how to make

strawberry milkshake. What the search engine is going to do is it's going to find a lot more pages that contain the terms how to make, rather than pages which contain the recipe for your strawberry milkshake. That's why you have to

disregard these terms. The search engine can actually focus on the strawberry milkshake recipe, instead of looking for pages

that have how to and so on. So that's why you need to

remove these stop words. Stop words are how to, begin,

gone, various, and, the, all of these are stop words. They are not necessarily important to understand the

importance of the sentence. So you get rid of these

commonly used words, so that you can focus

on the actual keywords.

Another term you need to understand is document term matrix. A document term matrix

is basically a matrix with documents designated by

roles and words by columns. So if your document one has

this sentence, this is fun, or has these word, this is fun, then you're going to get

one, one, one over here. In document two, if you see

we have this and we have is, but we do not have fun. So that's what a document term matrix is. It is basically to understand

whether your document contains each of these words. It is a frequency matrix. That is what a document term matrix is. Now let's move on and look at a natural language processing demo. So what we're gonna do

is we're gonna perform sentimental analysis. Now like I said, sentimental analysis is one of the most popular applications of natural language processing. It refers to the processing of determining whether a given piece of text

or a given sentence of text is positive or negative.

So, in some variations, we consider a sentence to also be neutral. That's a third option. And this technique is

commonly used to discover how people feel about a particular topic or what are people's opinion

about a particular topic. So this is mainly used to

analyze the sentiments of users in various forms, such as in marketing

campaigns, in social media, in e-commerce websites, and so on. So now we'll be performing

sentimental analysis using Python. So we are going to perform

natural language processing by using the NaiveBayesClassifier. That's why we are importing

the NaiveBayesClassifier. So guys, Python provides a library known as natural language toolkit. This library contains all

the functions that are needed to perform natural language processing. Also in this library, we have a predefined data

set called movie reviews. What we're gonna do is

we're going to download that from our NLTK, which is

natural language toolkit. We're basically going to run our analysis on this movie review data set. And that's exactly what

we're doing over here. Now what we're doing is

we're defining a function in order to extract features.

So this is our function. It's just going to extract all our words. Now that we've extracted the data, we need to train it, so we'll do that by using

our movie reviews data set that we just downloaded. We're going to understand the positive words and the negative words. So what we're doing here is

we're just loading our positive and our negative reviews. We're loading both of them. After that, we'll separate each of these into positive features

and negative features. This is pretty understandable. Next, we'll split the data into our training and testing set.

Now this is something

that we've been doing for all our demos. This is also known as data splicing. We've also set a threshold factor of 0.8 which basically means

that 80% of your data set will belong to your training, and 20% will be for your testing. You're going to do this

even for your positive and your negative words. After that, you're just

extracting the features again, and you're just printing the number of training

data points that you have. You're just printing the length

of your training features and you're printing the length of your testing features. We can see the output,

let's run this program. So if you see that we're getting the number of training

data points as 1,600 and your number of testing

data points are 400, there's an 80 to 20% ration over here. After this, we'll be using

the NaiveBayesClassifier and we'll define the object for the NaiveBayesClassifier

with basically classifier, and we'll train this using

our training data set.

We'll also look at the

accuracy of our model. The accuracy of our

classifier is around 73%, which is a really good number. Now this classifier object

will actually contain the most informative words that are obtained during analysis. These words are basically

essential in understanding which word is classified as positive and which is classified as negative. What we're doing here is

we're going to review movies. We're going to see which

movie review is positive or which movie review is negative. Now this classifier will basically have all the informative words

that will help us decide which is a positive review

or a negative review. Then we're just printing these

10 most informative words, and we have outstanding, insulting, vulnerable, ludicrous, uninvolving, avoids, fascination, and so on.

These are the most

important words in our text. Now what we're gonna do is

we're gonna test our model. I've randomly given some reviews. If you want, let's add another review. We'll say I loved the movie. So I've added another review over here. Here we're just printing the review, and we're checking if

this is a positive review or a negative review. Now let's look at our predictions. We'll save this and… I forgot to put a comma over here. Save it and let's run the file again. So these were our randomly

written movie reviews. The predicted sentiment is positive. Our probability score was 0.61. It's pretty accurate here. This is a dull movie and I

would never recommend it, is a negative sentiment. The cinematography is pretty great, that's a positive review. The movie is pathetic is

obviously a negative review. The direction was terrible, and the story was all over the place.

This is also considered

as a negative review. Similarly, I love the movie

is what I just inputted, and I've got a positive review on that. So our classifier actually

works really well. It's giving us good accuracy and it's classifying the

sentiments very accurately. So, guys, this was all

about sentimental analysis. Here we basically saw if a movie review was positive or negative. So guys, that was all for our NLP demo. I hope all of you understood this.

It was a simple sentimental analysis that we saw through Python. So again, if you have doubts, please leave them in the comment section, and I'll help you with all of the queries. So guys, that was our last module, which was on natural language processing. Now before I end today's session, I would like to discuss with you the machine learning engineers program that we have Edureka. So we all are aware of the demand of the machine

learning engineer. So, at Edureka, we have a master's program that involves 200-plus hours

of interactive training. So the machine learning

master's program at Edureka has around nine modules and 200-plus hours of interactive learning. So let me tell you the curriculum that this course provides. So your first module will basically cover Python programming. It'll have all the basics and

all your data visualization, your GUI programming, your functions, and your object-oriented concepts. The second module will cover

machine learning with Python. So you'll supervise algorithms and unsupervised algorithms along with statistics and time series in Python will be covered

in your second module. Your third module will

have graphical modeling.

This is quite important when

ti comes to machine learning. Here you'll be taught

about decision making, graph theory, inference, and

Bayesian and Markov's network, and module number four will cover reinforcement learning in depth. Here you'll understanding

dynamic programming, temporal difference, Bellman equations, all the concepts of

reinforcement learning in depth. All the detail in advance concepts of reinforcement learning. So, module number five

will cover NLP with Python. You'll understand tokenization,

stemming lemmatization, syntax, tree parsing, and so on. And module number six will

have module six will have artificial intelligence and

deep learning with TensorFlow. This module is a very advanced version of all your machine learning and reinforcement learning

that you'll learn. Deep learning will be in depth over here. You'll be using TensorFlow throughout.

They'll cover all the concepts

that we saw, CNN, RNN. it'll cover the various

type of neural networks, like convolutional neural networks, recurrent neural networks, long, short-term memory, neural networks, and auto encoders and so on. The seventh module is all about PySpark. It'll show you how Spark SQL works and all the features and

functions of Spark ML library. And the last module will finally cover about Python Spark using PySpark. Appropriate from this seven modules, you'll also get two

free self-paced courses. Let's actually take a look at the course. So this is your machine learning engineer master's program. You'll have nine courses, 200-plus hours of interactive learning. This is the whole course curriculum, which we just discussed. Here there are seven modules. Apart from these seven modules, you'll be given two

free self-paced courses, which I'll discuss shortly. You can also get to know

the average annual salary for a machine learning engineer, which is over $134,000. And there are also a lot of job openings in the field of machine

learning AI and data science.

So the job titles that you might get are machine learning

engineer, AI engineer, data scientist, data and analytics manger, NLP engineer, and data engineer. So this is basically the curriculum. Your first will by Python

programming certification, machine learning

certification using Python, graphical modeling,

reinforcement learning, natural language processing, AI and deep learning with TensorFlow. Python Spark certification

training using PySpark. If you want to learn more

about each of these modules, you can just go and view the curriculum. They'll explain each and every concept that they'll be showing in this module. All of this is going to be covered here. This is just the first module. Now at the end of this project, you will be given a verified

certificate of completion with your name on it, and these are the free elective courses that you're going to get.

One is your Python scripting

certification training. And the other is your Python Statistics for Data Science Course. Both of these courses

explain Python in depth. The second course on statistics will explain all the concepts of statistics probability,

descriptive statistics, inferential statistics, time series, testing data, data clustering, regression

modeling, and so on. So each of the module is

designed in such a way that you'll have a practical demo or a practical implementation after each and every model. So all the concept that I

theoretically taught to you will be explained through practical demos. This way you'll get a

good understanding of the entire machine

learning and AI concepts. So, if any of you are interested in enrolling for this program or if you want to learn more about the machine learning

course offered by Edureka, please leave your email

IDs in the comment section, and we'll get back to you with all the details of the course.

So guys, with this, we come to the end of this AI full course session. I hope all of you have

understood the basic concepts and the idea behind AI machine

learning, deep learning, and natural language processing. So if you still have doubts regarding any of these topics, mention them in the comment section, and I'll try to answer all your queries. So guys, thank you so much for

joining me in this session. Have a great day. I hope you have enjoyed

listening to this video. Please be kind enough to like it, and you can comment any of

your doubts and queries, and we will reply them at the earliest.

Do look out for more

videos in our playlist and subscribe to Edureka

channel to learn more. Happy learning..