    Gain insights into building and optimizing neural networks in Python. Delve into fundamental concepts, mathematical explanations, and practical implementations to enhance your machine learning skills.

Make your own neutral network in python final.png

Machine learning is one of the fastest growing fields, and we cannot emphasize enough about its importance. This course aims to teach one of the fundamental concepts of machine learning, i.e., Neural Network. You will learn the basic concepts of building a model as well as the mathematical explanation behind Neural Network and based on that; you will build one from scratch (in Python). You will also learn how to train and optimize your network to achieve a better result.

Make Your Own Neural Network in Python

# Calculations in the layers

The first layer of nodes is the input layer, and it doesn't do anything other than represent the input signals. That is, the input nodes don't apply an activation function to the input. There isn't really a reason for this other than that's how it has always been done. The first layer of neural networks is the input layer and all that layer does is represent the inputs. 

So the first input for layer 1 was easy—there aren't any calculations to be done there. 

Next is the second layer, where we do need to do some calculations. For each node in this layer, we need to work out the combined input. Remember the sigmoid function:

$$
y = \frac{1}{1 + e^{-x}}
$$

The $x$ in that function is the combined input into a node. In the previous layer, that combination was the raw outputs from the connected nodes, but moderated by the link weights. The following diagram is like the one we saw previously but now includes the need to moderate the incoming signals with the link weights.

First, let’s focus on node 1 in layer 2. Both nodes in the first input layer are connected to this node. The input nodes have raw values of $1.0$ and $0.5$. The link from the first node has a weight of $0.9$ associated with it. The link from the second has a weight of $0.3$. So, the combined moderated input is:

$$
x =(\text{output
 from
 first node $\cdot$ link weight) + (output from second node $\cdot$ link weight)}
$$
$$
x = (1.0 \times 0.9) + (0.5 \times 0.3)
$$
$$
x = 0.9 + 0.15
$$
$$
x = 1.05
$$

If we didn’t moderate the signal, we'd simply add the signals $1.0 + 0.5$, but we don’t want that. It's the weights that do the learning in a neural networks, because they are iteratively refined to give better and better results. 

So, now we’ve got $x = 1.05$ for the combined moderated input into the first node of the second layer. We can finally calculate that node’s output using the activation function,  $y = \frac{1}{1 + e^{-x}}$ . (Feel free to use a calculator to do this!) The answer is $y = 1 / (1 + 0.3499) = 1 / 1.3499$. So, $y = 0.7408$.

Now we have an actual output from one of the network’s two output nodes. 

Let’s do the calculation again for the remaining node, which is node 2 in the second layer. The combined moderated input $x$ is:

$$
x =(\text{output
 from
 first node $\cdot$ link weight) + (output from second node $\cdot$ link weight)}
$$
$$
x = (1.0 \times 0.2) + (0.5 \times 0.8)
$$
$$
x = 0.2 + 0.4
$$
$$
x = 0.6
$$

Now that we have $x$, we can calculate the node’s output using the sigmoid activation function, $y = 1/(1 + 0.5488) = 1/(1.5488)$. So, $y = 0.6457$. 

The following diagram shows the network outputs that we’ve just calculated.


Learn how output is calculated in neural networks.

Prologue

A Little Background

Let's Get Started!

Backward Propagation of Error

Adjusting the Link Weights

A Gentle Start with Python

Neural Network with Python

Testing Neural Network against MNIST Dataset

Some Suggested Improvements

Even More Fun!

Epilogue

Appendix: A Small Guide to Calculus

Calculate Neural Network Output

Calculations in the layers