An Image Classification using Pytorch

#put CNN blog link

Let’s Start Code:
Import required library
import numpy as np
import torch
import torchvision
import matplotlib.pyplot as plt
from time import time
from torchvision import datasets, transforms
from torch import nn, optim

Check PyTorch Version:
# version of pytorch
print(torch.__version__)
Output:- 1.6.0+cu101

So, I am using the 1.5.1 version of PyTorch. If you are using any other version, you might get a few warnings or errors, so you can update to this version of PyTorch. We will perform some transformations on the images, like normalizing the pixel values.

# transformations to be applied on images
transform = transforms.Compose([transforms.ToTensor(),
                          	transforms.Normalize((0.5,), (0.5,)),
                          	])

Now, let’s load the training and testing dataset of the MNIST direct from the library.
# defining the training and testing set
trainset = datasets.MNIST('./data', download=True, train=True, transform=transform)
testset = datasets.MNIST('./', download=True, train=False, transform=transform)

# defining trainloader and testloader
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)

Let’s look at the summary of the training set first:
# shape of training data
dataiter = iter(trainloader)
images, labels = dataiter.next()

print(images.shape)
print(labels.shape)
output:
torch.Size([64, 1, 28, 28])
torch.Size([64])
# defining the model architecture
class Net(nn.Module):  
 def __init__(self):
     super(Net, self).__init__()
 
     self.cnn_layers = nn.Sequential(
         # Defining a 2D convolution layer
         nn.Conv2d(1, 4, kernel_size=3, stride=1, padding=1),
         nn.BatchNorm2d(4),
         nn.ReLU(inplace=True),
         nn.MaxPool2d(kernel_size=2, stride=2),
         # Defining another 2D convolution layer
         nn.Conv2d(4, 4, kernel_size=3, stride=1, padding=1),
         nn.BatchNorm2d(4),
         nn.ReLU(inplace=True),
         nn.MaxPool2d(kernel_size=2, stride=2),
     )
 
     self.linear_layers = nn.Sequential(
         nn.Linear(4 * 7 * 7, 10)
     )
 
 # Defining the forward pass   
 def forward(self, x):
     x = self.cnn_layers(x)
     x = x.view(x.size(0), -1)
     x = self.linear_layers(x)
     return x

# defining the model
model = Net()
# defining the optimizer
optimizer = optim.Adam(model.parameters(), lr=0.01)
# defining the loss function
criterion = nn.CrossEntropyLoss()
# checking if GPU is available
if torch.cuda.is_available():
   model = model.cuda()
   criterion = criterion.cuda()
  
print(model)

for i in range(10):
   running_loss = 0
   for images, labels in trainloader:
 
       if torch.cuda.is_available():
         images = images.cuda()
         labels = labels.cuda()
 
       # Training pass
       optimizer.zero_grad()
      
       output = model(images)
       loss = criterion(output, labels)
      
       #This is where the model learns by backpropagating
       loss.backward()
      
       #And optimizes its weights here
       optimizer.step()
      
       running_loss += loss.item()
   else:
       print("Epoch {} - Training loss: {}".format(i+1, running_loss/len(trainloader)))

# getting predictions on test set and measuring the performance
correct_count, all_count = 0, 0
for images,labels in testloader:
 for i in range(len(labels)):
   if torch.cuda.is_available():
       images = images.cuda()
       labels = labels.cuda()
   img = images[i].view(1, 1, 28, 28)
   with torch.no_grad():
       logps = model(img)
 
  
   ps = torch.exp(logps)
   probab = list(ps.cpu()[0])
   pred_label = probab.index(max(probab))
   true_label = labels.cpu()[i]
   if(true_label == pred_label):
     correct_count += 1
   all_count += 1
 
print("Number Of Images Tested =", all_count)
print("\nModel Accuracy =", (correct_count/all_count))

Implementing CNN in TensorFlow.
# importing the libraries
import tensorflow as tf
 
from tensorflow.keras import datasets, layers, models
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt
# version of tensorflow
print(tf.__version__)

(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data(path='mnist.npz')
# Normalize pixel values to be between 0 and 1
train_images, test_images = train_images / 255.0, test_images / 255.0

# visualizing a few images
plt.figure(figsize=(10,10))
for i in range(9):
   plt.subplot(3,3,i+1)
   plt.xticks([])
   plt.yticks([])
   plt.grid(False)
   plt.imshow(train_images[i], cmap='gray')
plt.show()

# shape of the training and test set
(train_images.shape, train_labels.shape), (test_images.shape, test_labels.shape)

# reshaping the images
train_images = train_images.reshape((60000, 28, 28, 1))
test_images = test_images.reshape((10000, 28, 28, 1))
O/P: (((60000, 28, 28), (60000,)), ((10000, 28, 28), (10000,)))
 
So, we have 60,000 images of shape 28 by 28 in the training set and 10,000 images of the same shape in the test set. Next, we will resize the shape of images and one-hot encode the target variable:
 
# one hot encoding the target variable
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# defining the model architecture
model = models.Sequential()
model.add(layers.Conv2D(4, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2), strides=2))
model.add(layers.Conv2D(4, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2), strides=2))
model.add(layers.Flatten())
model.add(layers.Dense(10, activation='softmax'))

# summary of the model
model.summary()

O/P:
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 26, 26, 4)         40        
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 13, 13, 4)         0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 11, 11, 4)         148       
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 5, 5, 4)           0         
_________________________________________________________________
flatten (Flatten)            (None, 100)               0         
_________________________________________________________________
dense (Dense)                (None, 10)                1010      
=================================================================
Total params: 1,198
Trainable params: 1,198
Non-trainable params: 0
_________________________________________________________________

# compiling the model
model.compile(optimizer='adam',
             loss='categorical_crossentropy',
             metrics=['accuracy'])
We are using Adam optimizer, and you can change it as well. The loss function is set to be as categorical cross-entropy since we are solving a multi-class classification problem and the metric is accuracy. Now let’s train our model for 10 epochs:
# training the model
history = model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels))
Epoch 1/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.4587 - accuracy: 0.8612 - val_loss: 0.2001 - val_accuracy: 0.9412
Epoch 2/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.1850 - accuracy: 0.9440 - val_loss: 0.1378 - val_accuracy: 0.9617
Epoch 3/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.1433 - accuracy: 0.9566 - val_loss: 0.1142 - val_accuracy: 0.9674
Epoch 4/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.1215 - accuracy: 0.9631 - val_loss: 0.1040 - val_accuracy: 0.9699
Epoch 5/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.1079 - accuracy: 0.9674 - val_loss: 0.0901 - val_accuracy: 0.9739
Epoch 6/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0981 - accuracy: 0.9705 - val_loss: 0.0792 - val_accuracy: 0.9765
Epoch 7/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0902 - accuracy: 0.9724 - val_loss: 0.0772 - val_accuracy: 0.9762
Epoch 8/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0861 - accuracy: 0.9728 - val_loss: 0.0770 - val_accuracy: 0.9771
Epoch 9/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0818 - accuracy: 0.9749 - val_loss: 0.0738 - val_accuracy: 0.9779
Epoch 10/10
1875/1875 [==============================] - 5s 3ms/step - loss: 0.0789 - accuracy: 0.9754 - val_loss: 0.0678 - val_accuracy: 0.9792