Validation of Neural Network for Image Recognition

In the training section, we trained our model on the MNIST dataset (Endless dataset), and it seemed to reach a reasonable loss and accuracy. If the model can take what it has learned and generalize itself to new data, then it would be a true testament to its performance. This will be done with the help of the following steps:

Step 1:

We will create our validation set with the help of our training dataset, which we have created in the training section. In this time we will set train equals to false as:

  validation_dataset=datasets.MNIST(root=’./data’,train=False,download=True,transform=transform1)  

Step 2:

Now as we have declared a training loader in the training section similarly we will declare a validation loader in validation section. Validation loader will also create in the same way as we have created training loader, but this time we pass training loader rather than training the dataset, and we set shuffle equals to false because we will not be trained our validation data. There is no need to shuffle it because it is only for testing purpose.

  validation_loader=torch.utils.data.DataLoader(dataset=validation_dataset,batch_size=100,shuffle=False)  

Step 3:

Our next step is to analyze the validation loss and accuracy at every epoch. For this purpose, we have to create two lists for validation running lost, and validation running loss corrects.

Step 4:

In the next step, we will validate the model. The model will validate the same epoch. After we finished iterating through the entire training set to train our data, we will now iterate through our validation set to test our data.

We will first measure for two things. The first one is the performance of our model, i.e., how many correct classifications. Our model makes on the test set on the validation set to check for overfitting. We will set running loss and running corrects of validation as:

Step 5:

We can now loop through our test data. So after the else statement, we will define a loop statement for labels and inputs as:

Step 6:

As we iterate through our batches of images, we must flatten them, and we must reshape them with the help of view method.

Note: The shape of each image tensor is (1, 28, and 28) which means a total of 784 pixels.

According to the structure of the neural network, our input values are going to be multiplied by our weight matrix connecting our input layer to the first hidden layer. To conduct this multiplication, we must make our images one dimensional. Instead of each image is 28 rows by two columns, we must flatten it into a single row of 784 pixels.

Now, with the help of these inputs, we get outputs as

Step 7:

With the help of the outputs, we will calculate the total categorical cross-entropy loss, and the output is ultimately compared with the actual labels.

We are not training our neural network, so there is no need to call zero_grad(), backward() or any of that. And there is also no need to compute derivative anymore. In the scope of operation to save memory, we call no_grad() method before For loop with the torch as:

It will temporarily set all the require grad flag to be false.

Step 8:

Now, we will calculate the validation loss and accuracy in the same way as we have calculated the training loss and training accuracy as:

  _,val_preds=torch.max(val_outputs,1)  val_loss+=val_loss1.item()  val_correct+=torch.sum(val_preds==val_labels.data)  

Step 9:

Now, we will calculate the validation epoch loss which will be done as same as how we calculate the training epoch loss where we divide the total running loss by the length of the dataset. So it will be write as:

  val_epoch_loss=val_loss/len(validation_loader)  val_epoch_acc=correct.float()/len(validation_loader)  val_loss_history.append(val_epoch_loss)  val_correct_history.append(epoch_acc)  

Step 10:

We will print validation loss and validation accuracy as:

  print(‘validation_loss:{:.4f},{:.4f}’.format(val_epoch_loss,val_epoch_acc.item()))  

Validation of Neural Network for Image Recognition

Step 11:

Nor, for better understanding, we will plot it for visualization purpose. We will plot it as:

  plt.plot(loss_history,label=’Training Loss’)  plt.plot(val_loss_history,label=’Validation Loss’)  plt.legend()  plt.show()  

Validation of Neural Network for Image Recognition

  plt.plot(correct_history,label=’Training accuracy’)  plt.plot(val_correct_history,label=’Validation accuracy’)  plt.legend()  plt.show()  

Validation of Neural Network for Image Recognition

Complete Code

  import torch  import matplotlib.pyplot as plt  import numpy as np  import torch.nn.functional as func  from torch import nn  from torchvision import datasets,transforms   transform1=transforms.Compose([transforms.Resize((28,28)),transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))])  training_dataset=datasets.MNIST(root=’./data’,train=True,download=True,transform=transform1)  validation_dataset=datasets.MNIST(root=’./data’,train=False,download=True,transform=transform1)  training_loader=torch.utils.data.DataLoader(dataset=training_dataset,batch_size=100,shuffle=True)  validation_loader=torch.utils.data.DataLoader(dataset=validation_dataset,batch_size=100,shuffle=False)  def im_convert(tensor):      image=tensor.clone().detach().numpy()      image=image.transpose(1,2,0)      print(image.shape)      image=image*(np.array((0.5,0.5,0.5))+np.array((0.5,0.5,0.5)))      image=image.clip(0,1)      return image  class classification1(nn.Module):      def __init__(self,input_layer,hidden_layer1,hidden_layer2,output_layer):          super().__init__()          self.linear1=nn.Linear(input_layer,hidden_layer1)          self.linear2=nn.Linear(hidden_layer1,hidden_layer2)          self.linear3=nn.Linear(hidden_layer2,output_layer)      def forward(self,x):          x=func.relu(self.linear1(x))          x=func.relu(self.linear2(x))          x=self.linear3(x)          return x  model=classification1(784,125,65,10)  criteron=nn.CrossEntropyLoss()  optimizer=torch.optim.Adam(model.parameters(),lr=0.0001)  epochs=12  loss_history=[]  correct_history=[]  val_loss_history=[]  val_correct_history=[]  for e in range(epochs):      loss=0.0      correct=0.0      val_loss=0.0      val_correct=0.0      for input,labels in training_loader:          inputs=input.view(input.shape[0],-1)          outputs=model(inputs)          loss1=criteron(outputs,labels)          optimizer.zero_grad()          loss1.backward()          optimizer.step()          _,preds=torch.max(outputs,1)          loss+=loss1.item()          correct+=torch.sum(preds==labels.data)      else:          with torch.no_grad():              for val_input,val_labels in validation_loader:                  val_inputs=val_input.view(val_input.shape[0],-1)                  val_outputs=model(val_inputs)                  val_loss1=criteron(val_outputs,val_labels)                   _,val_preds=torch.max(val_outputs,1)                  val_loss+=val_loss1.item()                  val_correct+=torch.sum(val_preds==val_labels.data)          epoch_loss=loss/len(training_loader)          epoch_acc=correct.float()/len(training_loader)          loss_history.append(epoch_loss)          correct_history.append(epoch_acc)          val_epoch_loss=val_loss/len(validation_loader)          val_epoch_acc=correct.float()/len(validation_loader)          val_loss_history.append(val_epoch_loss)          val_correct_history.append(epoch_acc)          print(‘training_loss:{:.4f},{:.4f}’.format(epoch_loss,epoch_acc.item()))          print(‘validation_loss:{:.4f},{:.4f}’.format(val_epoch_loss,val_epoch_acc.item()))  plt.plot(correct_history,label=’Correct history ‘)  plt.plot(val_correct_history,label=’Validation correct history’)  plt.legend()  plt.show()  plt.plot(correct_history,label=’Training accuracy’)  plt.plot(val_correct_history,label=’Validation accuracy’)  plt.legend()  plt.show()  

Next TopicTesting of Image Recognition Model

Validation of Neural Network for Image Recognition

Validation of Neural Network for Image Recognition

Note: The shape of each image tensor is (1, 28, and 28) which means a total of 784 pixels.

Complete Code

PyTorch Testing

Verbal Reasoning | Logical Venn Diagram 4

You may also like