Now, we have seen a neural network in the previous example.
Now, how about we focus on that one neuron we have learned and we give it some numeric example.
Now, this is not actually what deep learning or artificial intelligence is using neural network.
No, this is just a very, very basic example.
In order to teach you how a neuron activates our neuron functions in its basic form.
Now, one neuron is not even enough to build a real neural network.
It's not a network anymore.
It's a simple neuron.
But once we learn how the feed for the processes go and what I mean by feet forward is when you give
some input like an image pixel, then you get an output.
This is a forward process because there is also a backwards process, which we will talk about briefly
later.
OK, so once we learn this forward, the process for one neuron, we can generalize it to more complex,
real examples.
Now, let me give you some example.
Let's say that I have trained this neuron in order to predict if A is near failure or not.
OK, now it's really hard to do that with one neuron, but let's say that we have successfully done
that so that we can see how one neuron works.
So industrial automation, we have started to integrate artificial intelligence and deep learning near
our p.l.c. or near our automation gear so that let's say we have a factory that has a lot of motors
and you want to know when a certain motor is about to fail so that you can go and do the proper maintenance
to it, because maybe if this motor has failed, it will hold your whole production line, causing you
to lose a lot of money.
So a very good application of, let's say, deep learning here is to give this deep learning network
some parameters in order to decide if a motor is about to fail or not.
OK, so what kind of parameters do we need to do that?
Well, we could use the model temperature, the motor, and we can use also a parameter.
Like how many times did we surpass the current threshold, let's say in the past one hour?
We can use a lot of parameters here.
And every parameter of these, let's say moderate temperature, motor current overload has its corresponding
rate.
Great.
So let's say the most important thing is how many overload failures we had in the last hour.
And this we would give it a weight of seven because this is a huge thing, let's say, for the motor.
Can't we give it?
It's also a very important parameter, but it's less important than this failure here.
So we give it, let's say, a way to fight the motor of temperature, let's say, is less important
than the stool because the motor itself is going to heat up when it is operating 24/7.
Let's say it's less important than these two parameters.
So we give it the weight of four.
OK, let's say that these tweets are not given by us, but we have trained this, which we will talk
about later as well.
We have a train that and these were the resulting weight.
Now weight has its own process.
In order to be calculated, it used back propagation.
There is a lot of math going on in order to calculate this weight.
But let's say that this one is already trained and see how one neuron behaves with weight.
OK, so let's say that our activation function, let's say that our Y here is a notification to be generated
if the motor is about to fail.
So if this calculation here yields tools that it's about to fail, this way is going to give us a notification.
And we will see it in our, let's say, monitoring system.
We will see that, OK, a red light has lit here.
And be careful.
You need to go do maintenance, let's say, for this motor, or we could get an estimate modification.
It doesn't matter how we convey the notification.
The important is that we generate a signal here in order to do that.
Now, the activation function here is also not very realistic one, but it says if the parameter is
larger than 300, I want to fire a neuron.
Is either of will fire or give you an output or it won't fire in case if the output is binary.
Binary, I mean, if the output is going to be yes or no.
So either the neuron will fire or it will not fire.
OK, so in order to fire this cold calculation here need to be larger than 300.
So let us now crunch these numbers together and see what is the state of the model giving these statements
here.
Now, these are the numbers.
We had just some of them up here.
And remember, the formula is X1 times one six, two times the next three times three.
We just do this simple math here and we get a result of 375.
Five now, three hundred seventy five is actually larger than 300, remember the three hundred?
Here is the activation function, right?
So if it's larger than 300, it means we will activate.
So here it is, larger than 300.
It means that this neuron will fire, let's say, a value of one to the output, meaning that, well,
this motor is near failure and we need to run and do some diagnostic and maintenance to it before it
fails and halts our production line.
So this was a very basic example about this.
And we going to build up on this in the upcoming lectures.
Now, don't worry, I won't be going a lot into the deep concepts of math for deep learning because
it's pretty complicated and the math complication is way beyond the limits of this course.
But don't even worry about it, because I'm going to teach you how you can handle all of that without
really worrying a lot about the complicated math.
I'm going to teach you what you really need and we will do some real life applications on that so that
you can go and build your own deep learning model.
But you need to bear with me and don't skip any lectures and the section and try to follow up one by
one so that we can build this concept together.