Building a Neural Network in Python: A Step-By-Step Guide

Introduction
Prerequisites
Setting Up
Creating the Neural Network Architecture
Training and Testing the Model
Conclusion

Introduction

In this tutorial, we will learn how to build a neural network from scratch using Python. Neural networks are powerful machine learning models that can be used for various tasks such as image recognition, natural language processing, and anomaly detection. By the end of this tutorial, you will have a solid understanding of how neural networks work and how to implement them in Python.

Prerequisites

Before getting started, make sure you have a basic understanding of Python programming and linear algebra concepts. Familiarity with the following topics will be beneficial:

Python syntax and functions
Basic linear algebra operations (matrix multiplication, vector addition, etc.)
Familiarity with numpy library for numerical operations

It is recommended to have Python and necessary libraries installed on your system. You can install Python from the official website (https://www.python.org/) and install libraries using the pip package manager.

Setting Up

To begin, let’s set up our Python environment. We need to install the numpy library, which is essential for performing mathematical operations in our neural network.

Open a terminal or command prompt.
Run the following command to install numpy:
```
 pip install numpy
```
Once numpy is installed, we can proceed with building our neural network.

Creating the Neural Network Architecture

A neural network consists of input, hidden, and output layers. Each layer is made up of multiple neurons or nodes. The nodes in adjacent layers are connected by weighted edges. The weights determine the strength of the connection between nodes.

Let’s create a simple neural network architecture with one hidden layer to solve a classification problem.

Import the necessary libraries:
```
 import numpy as np
```

Define the neural network class:

 class NeuralNetwork:
     def __init__(self, input_size, hidden_size, output_size):
         self.input_size = input_size
         self.hidden_size = hidden_size
         self.output_size = output_size
         self.weights1 = np.random.randn(input_size, hidden_size)
         self.weights2 = np.random.randn(hidden_size, output_size)

Implement the forward pass:

     def forward(self, X):
         self.z2 = np.dot(X, self.weights1)
         self.a2 = self.sigmoid(self.z2)
         self.z3 = np.dot(self.a2, self.weights2)
         y_hat = self.sigmoid(self.z3)
         return y_hat
	
     def sigmoid(self, z):
         return 1 / (1 + np.exp(-z))

Train the neural network:

     def train(self, X, y, epochs):
         for epoch in range(epochs):
             y_hat = self.forward(X)
             self.backward(X, y, y_hat)
	
     def backward(self, X, y, y_hat):
         delta3 = (y_hat - y) * self.sigmoid_derivative(y_hat)
         d_weights2 = np.dot(self.a2.T, delta3)
         delta2 = np.dot(delta3, self.weights2.T) * self.sigmoid_derivative(self.a2)
         d_weights1 = np.dot(X.T, delta2)
	
         self.weights1 -= d_weights1
         self.weights2 -= d_weights2
	
     def sigmoid_derivative(self, z):
         return z * (1 - z)

Training and Testing the Model

To train and test our neural network, we need a dataset. For this tutorial, let’s use the famous Iris flower dataset.

Import the necessary libraries:

 from sklearn.datasets import load_iris
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import OneHotEncoder

Load the dataset and split it into training and testing sets:

 iris = load_iris()
 X, y = iris.data, iris.target
 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Preprocess the data:

 enc = OneHotEncoder()
 y_train_encoded = enc.fit_transform(y_train.reshape(-1, 1)).toarray()

Create and train the neural network:

 input_size = X_train.shape[1]
 hidden_size = 10
 output_size = len(enc.categories_[0])
	
 nn = NeuralNetwork(input_size, hidden_size, output_size)
 nn.train(X_train, y_train_encoded, epochs=1000)

Evaluate the performance of the neural network:

 y_pred = np.argmax(nn.forward(X_test), axis=1)
 accuracy = np.sum(y_pred == y_test) / len(y_test)
 print(f"Accuracy: {accuracy}")

Conclusion

Congratulations! You have successfully built a neural network from scratch using Python. In this tutorial, we learned about the basics of neural networks, created the architecture for a simple neural network, and trained it on a classification problem. Neural networks are a powerful tool for solving complex machine learning tasks, and this tutorial serves as a starting point for further exploration.

By now, you should have a solid understanding of the key concepts involved in building a neural network and how to implement it using Python. Remember to experiment with different architectures, activation functions, and optimization algorithms to improve the performance of your models.

Keep practicing and exploring the vast field of neural networks to become proficient in this exciting area of machine learning.

Happy coding!

Published: 3 April 2020