Testing of LeNet Model for CIFAR-10 Dataset

In the previous topic, we found that our LeNet Model with Convolutional Neural Network was able to do the classification of MNIST dataset images. MNIST dataset contains the number of images which are the grayscale images, but in CHIFAR-10 dataset the images are colored and of different things. So our biggest question is that will our LeNet model classify the images of CIFAR-10 dataset. We will copy the code of our previous topic, i.e., Testing of CNN and do the following changes in the image transforms, implementation, training, validation, and the testing section of the code:

Note: If you are new here, then you must have to get knowledge of our previous topic for understanding this efficiently.

Changes in the section of Image Transform:

In the Image Transform section we will do the following changes:

Step 1:

In this, we are working with CIFAR-10 dataset so our first step is to load CIFAR-10 dataset rather than MNIST dataset. We load CIFAR-10 dataset by doing changes in the training dataset as well as validation data set in the following way:

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

Step 2:

In the next step, we will do the changes in our transform statement. We know that the MNIST image are of size 28 by 28 pixels but the CIFAR10 images are of size 32 by 32 pixels. So we will do the changes in the transform.compose() method’s first argument as:

  transform1=transforms.Compose([transforms.Resize((32,32)),transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))])  

Now, if we plot our CIFAR-10 images then it will give us the following output:

Pytorch Testing of LeNet Model for CIFAR-10 Dataset

Step 3:

In the CIFAR10 images, we know that the images are classify in the classes. For better understanding and visualization we specify each images with its class. So we declare a list of classes in which we specifies the classes in order after im_convert () method as:

  classes={‘plane’,’car’,’bird’,’cat’,’dear’,’dog’.’frog’,’horse’,’ship’,’truck’}  

Step 4:

The labels represent the ordered numerical representation of these classes so we will use each respective label to index through our classes list and the output will be appropriate class. We will change the set_title() method as:

It will give the following output:

Pytorch Testing of LeNet Model for CIFAR-10 Dataset

Changes in Implementation, Training, and Validation section:

Our Lenet model was implemented for MNIST images. MNIST images are the grayscale image, but we have to implement our model for CIFAR-10 dataset, which contains colored images. So we have to do the following changes in our code:

Step 1:

Previously, we were working with one channel grayscale images, and now we work with three-channel color images which are passes into the neural network. So in the first convolutional layer, we set 3 rather than one as:

Step 2:

Now, we have to train a large number of parameters. After the convolution of a 5 by 5 kernel, the images becomes 28 by 28 and then with next pooling 14 by 14 performing another convolution with the same size kernel. The image once again gets smaller by 4 by 4 decrement and becomes a 10 by 10. And finally, with another max-pooling, the vector which will then be fed into the fully connected network will be a 5 by 5 by 50.

So we have to change our first fully connected layer in our initializer as:

Step 3:

Now, we also have to change the shape of our output. For this, we have to change our view statement in the forward function as:

Now, we find the total loss and validation loss as well as accuracy and validation accuracy and plot it then it will give us the following output:

Pytorch Testing of LeNet Model for CIFAR-10 Dataset

Step 4:

Now, we will use it to predict images from the web to simply gain a visual perspective of the model accuracy. We will use the following image: https://3c1703fe8d.site.internapcdn.net/newman/gfx/news/hires/2018/2-dog.jpg

When we plot this image, it will be shown as:

Pytorch Testing of LeNet Model for CIFAR-10 Dataset

Step 5:

In the next step, we will remove our invert and convert method because this time our image will be extremely converted to a bio level format, and our network was trained on color images. We will transform the image and plot the images as:

  url=’https://ichef.bbci.co.uk/news/912/cpsprodpb/160B4/production/_103229209_horsea.png’  response=requests.get(url,stream=True)  img=Image.open(response.raw)  img=transform1(img)   plt.imshow(im_convert(img))  

Pytorch Testing of LeNet Model for CIFAR-10 Dataset

After the transformation, we obtain a more abstracted representation of the image. It reduces to a smaller 32 by 32 representation.

Step 6:

Now, we make prediction on this image so we will squeeze the image and find the prediction using class as:

  image1=img.to(device).unsqueeze(0)  output=model(image1)  _,pred=torch.max(output,1)  print(classes[pred.item()])  

Pytorch Testing of LeNet Model for CIFAR-10 Dataset

Changes in Testing section:

The testing section will be same as before. The same process of CNN testing will be follow but in colorful images we will use classes to predict each validation image as:

  dataiter=iter(validation_loader)    images,labels=dataiter.next()    images_=images.to(device)    labels=labels.to(device)    output=model(images_)    _,preds=torch.max(output,1)    fig=plt.figure(figsize=(25,4))    for idx in np.arange(20):        ax=fig.add_subplot(2,10,idx+1,xticks=[],yticks=[])      plt.imshow(im_convert(images[idx]))        ax.set_title(“{}({})”.format(str(classes[preds[idx].item()]),str(classes[labels[idx].item())),color=(“green” if preds[idx]==labels[idx] else “red”))    plt.show()    

Pytorch Testing of LeNet Model for CIFAR-10 Dataset

It seems to predict most of the images accurately. Overall it is very good that our model is so much able to generalize itself to new data based on its trained parameters.

Complete code:

  import torch  import matplotlib.pyplot as plt  import numpy as np  import torch.nn.functional as func  import PIL.ImageOps  from torch import nn  from torchvision import datasets,transforms   import requests  from PIL import Image    device=torch.device(“cuda:0” if torch.cuda.is_available() else “cpu”)  transform1=transforms.Compose([transforms.Resize((32,32)),transforms.ToTensor(),transforms.Normalize((0.5,),(0.5,))])  training_dataset=datasets.CIFAR10(root=’./data’,train=True,download=True,transform=transform1)  validation_dataset=datasets.CIFAR10(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.cpu().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        classes=(‘plane’,’car’,’bird’,’cat’,’dear’,’dog’,’frog’,’horse’,’ship’,’truck’)  dataiter=iter(training_loader)  images,labels=dataiter.next()  fig=plt.figure(figsize=(25,4))  for idx in np.arange(20):      ax=fig.add_subplot(2,10,idx+1)      plt.imshow(im_convert(images[idx]))      ax.set_title(classes[labels[idx].item()])  class LeNet(nn.Module):          def __init__(self):              super().__init__()              self.conv1=nn.Conv2d(3,20,5,1)              self.conv2=nn.Conv2d(20,50,5,1)              self.fully1=nn.Linear(5*5*50,500)              self.dropout1=nn.Dropout(0.5)               self.fully2=nn.Linear(500,10)          def forward(self,x):              x=func.relu(self.conv1(x))              x=func.max_pool2d(x,2,2)              x=func.relu(self.conv2(x))              x=func.max_pool2d(x,2,2)              x=x.view(-1,5*5*50)#Reshaping the output into desired shape              x=func.relu(self.fully1(x))#Applying relu activation function to our first fully connected layer              x=self.dropout1(x)              x=self.fully2(x)#We will not apply activation function here because we are dealing with multiclass dataset              return x      model=LeNet().to(device)  criteron=nn.CrossEntropyLoss()  optimizer=torch.optim.Adam(model.parameters(),lr=0.00001)   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:          input=input.to(device)          labels=labels.to(device)          outputs=model(input)          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_input=val_input.to(device)                  val_labels=val_labels.to(device)                  val_outputs=model(val_input)                  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=val_correct.float()/len(validation_loader)          val_loss_history.append(val_epoch_loss)          val_correct_history.append(val_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(loss_history,label=’Training Loss’)    plt.plot(val_loss_history,label=’Validation Loss’)    plt.legend()    plt.show()  plt.plot(correct_history,label=’Training accuracy’)    plt.plot(val_correct_history,label=’Validation accuracy’)    plt.legend()    plt.show()    url=’https://3c1703fe8d.site.internapcdn.net/newman/gfx/news/hires/2018/2-dog.jpg’  response=requests.get(url,stream=True)  img=Image.open(response.raw)  img=transform1(img)     image1=img.to(device).unsqueeze(0)  output=model(image1)  _,pred=torch.max(output,1)  print(classes[pred.item()])  dataiter=iter(validation_loader)    images,labels=dataiter.next()    images_=images.to(device)    labels=labels.to(device)    output=model(images_)    _,preds=torch.max(output,1)    fig=plt.figure(figsize=(25,4))    for idx in np.arange(20):        ax=fig.add_subplot(2,10,idx+1,xticks=[],yticks=[])        plt.imshow(im_convert(images[idx]))        ax.set_title(“{}({})”.format(str(classes[preds[idx].item()]),str(classes[labels[idx].item()]),color=(“green” if preds[idx]==labels[idx] else “red”))    plt.show()  

Next TopicHyperparameter Tuning Technique

Testing of LeNet Model for CIFAR-10 Dataset

Testing of LeNet Model for CIFAR-10 Dataset

Note: If you are new here, then you must have to get knowledge of our previous topic for understanding this efficiently.

Changes in the section of Image Transform:

Changes in Implementation, Training, and Validation section:

Changes in Testing section:

Complete code:

Title in Python

Verbal Reasoning | Blood Relations 4

You may also like