Build a Neural Network for Classification from Scratch with PyTorch

Neural networks are a fundamental part of modern machine learning and are often used for tasks such as image recognition, natural language processing, and classification. In this tutorial, we will explore how to build a neural network for classification from scratch using the PyTorch library.

Setting up the Environment

First, we need to install PyTorch and its dependencies. You can do this using pip:

    
      pip install torch torchvision
    
  

Building the Neural Network

Now, let’s define our neural network architecture. We will create a simple neural network with one hidden layer using the nn.Module class in PyTorch:

    
      import torch
      import torch.nn as nn

      class NeuralNetwork(nn.Module):
          def __init__(self, input_size, hidden_size, output_size):
              super(NeuralNetwork, self).__init__()
              self.hidden = nn.Linear(input_size, hidden_size)
              self.relu = nn.ReLU()
              self.output = nn.Linear(hidden_size, output_size)

          def forward(self, x):
              hidden = self.hidden(x)
              activated_hidden = self.relu(hidden)
              output = self.output(activated_hidden)
              return output

      input_size = 784 # size of the input (e.g., for a 28x28 image)
      hidden_size = 128 # number of neurons in the hidden layer
      output_size = 10 # number of output classes

      model = NeuralNetwork(input_size, hidden_size, output_size)
    
  

Training the Neural Network

Now that we have defined our neural network, we can train it using a dataset of labeled examples. We will use the MNIST dataset of handwritten digits as an example:

    
      import torch.optim as optim
      from torchvision import datasets, transforms

      # Define the transform to normalize the data
      transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,))])

      # Download and load the training data
      trainset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transform)
      trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

      criterion = nn.CrossEntropyLoss()
      optimizer = optim.SGD(model.parameters(), lr=0.01)

      for images, labels in trainloader:
          images = images.view(images.shape[0], -1)

          optimizer.zero_grad()

          output = model(images)
          loss = criterion(output, labels)
          loss.backward()
          optimizer.step()
    
  

Testing the Neural Network

Once the neural network is trained, we can use it to make predictions on new data:

    
      testset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=False, transform=transform)
      testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)

      correct = 0
      total = 0

      with torch.no_grad():
          for images, labels in testloader:
              images = images.view(images.shape[0], -1)
              outputs = model(images)
              _, predicted = torch.max(outputs.data, 1)
              total += labels.size(0)
              correct += (predicted == labels).sum().item()

      print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))
    
  

By following this tutorial, you have learned how to build, train, and test a neural network for classification from scratch using PyTorch. This is just the beginning – there are many more advanced topics and techniques to explore in the field of deep learning!