Multi-layer perceptron is a type of feed-forward neural network with multiple neurons arranged in different layers. There will be at least three layers in a multi-layer perceptron network: one is the input layer, another one is the output layer, and there will be one or more hidden layers in between. Each neuron in a particular layer is fully connected with each of the neurons in the next layer. For example, if you look at this X1, X1 is connected with each of the neurons in the next layer. Similarly, if you consider this neuron, it is connected with each and every neuron in the next layer, and so on. That is what is called as fully connected. In this case, the input layer is the visible layer; that is, the input is given at this particular layer. It doesn't do any task over here. Whatever the input is received, it will be transformed to the next layer, that's it. It will not do any modification to the inputs; it will just transform that particular input to the next layer. Then, the hidden layers will not receive input directly, nor will they give the output to the environment. They will receive the input from the previous layer, and then they will do some modification. That output will be given to the next layer, and so on. Now, the output layer will do the computation after receiving the input from the last hidden layer, and then it will output that to the environment. In this case, the input is given to the network through the input layer, and the output is received from the output layer and neuron. In this case, for each and every neuron in the hidden layer, we need to use the activation function. There will be multiple kinds of activation functions, such as linear, nonlinear, and so on. Based on the problem definition, we need to use different activation functions. I have already discussed the different activation functions in artificial neural networks; the link for that video is given in the description below. Usually, whenever we have a binary classification problem, we use the sigmoid activation function. If it's a multiclass classification problem, we use the softmax activation function. Now, we will discuss the multi-layer perceptron learning algorithm. The input to the multi-layer perceptron learning algorithm is the input vector, which is the set of features, and the output is the target. In this case, we need to define the learning rate, Alpha. For each of those, we can say that the edges require the assignment of weights and biases. Usually, we will assign the weights and biases randomly in the range of -5 to +5. In the first step of forward propagation, we need to calculate the input and the output at the input layer. So, the input calculation is whatever the input is given to the network; that is the input. The output of that input layer neuron is nothing but the direct transfer function. Here, that means whatever the input is, the same thing will be transferred to the next layer in this case. That’s the reason the output of this input layer is exactly equivalent to the input to that particular input layer neuron. The next step is to calculate the output at that neuron. Again, it is based on the activation function we are using. In this case, the activation function I have shown here is nothing but the sigmoid activation function. Here, OJ, which represents the output, is always equal to \( \frac{1}{1 + e^{-\text{net input}}} \). The net input is what we denote as IG. So, if you substitute that particular value, you will get the output at the output layer neuron in this case. So, we were able to calculate the output at the output layer neuron. Once you calculate the output at the output layer neuron, the next step is to calculate the error. The error is always equivalent to \( O_{\text{desired}} \), which is nothing but the target output, minus \( O_{\text{estimated}} \), which is the uh calculated output. Once you do this calculation, you are going to get the error term in this case. So, once you calculate the error at the output layer neuron What is the thing we need to do is, we need to apply the backpropagation algorithm, and then we need to propagate this error backside till the first hidden layer. In this case, to do that thing, we use the two things over here. The first one is calculating the error at the output layer neuron, calculating the error at the hidden layer neuron. Here, these are the two different things we need to perform because whatever the error we have calculated, that entire thing is for the output layer neuron. But when you look at this hidden layer neurons, whatever the error we have calculated here, that will be propagated back, propagated by the proportion of this particular weight. Here, for example, weight is equal to 0.5, so 50% will be propagated backside. If it is equivalent to one, 100% will be propagated at the backside over here. So, that is the reason we need to calculate these errors separately. Here, for the error at the output layer neuron, this is the equation we use: error \(k\) (where \(k\) is the output layer neuron) is equal to \( O_k \times (1 - O_k) \times (O_{\text{target}} - O_k) \), where \(O_k\) is the output we have already calculated, and \(O_{\text{target}}\) is the target output. Once we calculate the error at the output layer neuron, what we do is calculate the error at the hidden layer neuron by propagating this error (that is the one which is calculated at the output layer neuron). So, the error at the hidden layer neuron \(J\) is equal to \( O_J \times (1 - O_J) \times \) the previously calculated error. We have already calculated the output at each hidden layer neuron. So, we use that output here, multiplied by the summation of \( \text{error}_k \times w_{jk} \) for all \( k \). \( k \) is nothing but all the output layer neurons. So, that is what I said: whatever the error we have calculated at the output layer neuron, that will be propagated back with the proportion of the weight. Here, if the weight is equal to 1, the entire thing will be propagated back. If the weight is equal to 0.5, 50% will be propagated back. If it is 0.25, 25% will be propagated back, and so on. So, that's the reason we have taken this error term multiplied by the weight for all output layer neurons. We will get the error at the hidden layer neuron in this case. Once we calculate the error at the output layer neuron, as well as the hidden layer neurons, the next step is to update all the weights as well as the biases. Here, to update the weights, we use this equation: \( \Delta W = \alpha \times \text{error at that unit} \times \text{input} \), where \( \alpha \) is the learning rate. Here, you will get a change in weight. Add that change in weight to the previous weight, and you will get the new weight. Here, this is the simplest process we follow to update the weights. Here, similarly, if you want to update the biases, in biases, we don't have this input. The input will be always equivalent to one in that case. That is, \( \Delta \Theta_J = \alpha \times \text{error}_J \). Here, we don't have any input term in this case. Finally, \( \Theta_J = \Theta_J + \Delta \Theta_J \). Here, that is, whatever the change in bias we have calculated, we need to add it to the previous bias so that we will calculate the new bias in this case. So, this is how the multi-layer perceptron network works.