Update app.py

app.py

@@ -1,375 +1,219 @@
 # -*- coding: utf-8 -*-
-"""CNN(mnist).ipynb
+"""B20AI006_MNIST_Trial.ipynb
 
 Automatically generated by Colaboratory.
 
 Original file is located at
-    https://colab.research.google.com/drive/1_4EIIBRbLBfS5tDz6VSgPIIpSv1t03Y7
-
-CNN are mainly used to classify the images <br> 
-A basic CNN requires two additional layers called convoluation and pooling before the FNN <br> 
-CNN involves a Kernel<br>
-Kernel is sliding/convuling matrix across the image with two operations<br> 
-1. element-wise multiplication 
-2. summation
-<br>
-Now comes the pooling part mainly there are two types of pooling<br> 
-1. Max pooling- getting the max element after the kernel iteration over the image 
-2. average pooling- getting the average of all the elements in the matrix 
-
-Now comes stride- it means number of steps in each convulation. By default it is 1. <br> 
-After using stride we can see that the input size becomes lesser so we add zeros symetrically in the matrix so the output becomes the same dimension of input <br> 
-
-The dimension of the output after applying all these <br> 
-O=(W-K+2P)/25  + 1<br> 
-W=input <br>
-K=kernel size <br>
-P=padding=(K-1)/2<br>
-S=stride
-
-# Importing libraries
-"""
-
-import torch 
-import torch.nn as nn 
-from torchvision import transforms,datasets 
-from torch.utils.data import dataset, DataLoader
-import torchvision.datasets as dsets
-
-"""# Loading the data """
-
-#we will be using the mnist dataset for this purpose 
-train_dataset = dsets.MNIST(root='./data', 
-                            train=True, 
-                            transform=transforms.ToTensor(),
-                            download=True)
-
-test_dataset = dsets.MNIST(root='./data', 
-                           train=False, 
-                           transform=transforms.ToTensor())
-
-#making our dataset iterable 
-batch_size = 100
-n_iters = 3000
-num_epochs = n_iters / (len(train_dataset) / batch_size)
-num_epochs = int(num_epochs)
-
-train_loader = torch.utils.data.DataLoader(dataset=train_dataset, 
-                                           batch_size=batch_size, 
-                                           shuffle=True)
-
-test_loader = torch.utils.data.DataLoader(dataset=test_dataset, 
-                                          batch_size=batch_size, 
-                                          shuffle=False)
-
-"""# Defining our model """
-
-class CNN(nn.Module): 
-  def __init__(self): 
-    super(CNN,self).__init__()
-
-    #defining the layers 
-    self.block1=nn.Sequential(nn.Conv2d(1,16,kernel_size=(5,5),stride=1,padding=2),
-                              nn.ReLU(),
-                              nn.MaxPool2d(kernel_size=2))
-    #output after this operation 
-    #(28-5+2/1 +1 =28 then max pooling 28/2=14)
-    
-    self.block2=nn.Sequential(nn.Conv2d(16,32,kernel_size=(5,5),stride=1,padding=2),
-                              nn.ReLU(),
-                              nn.MaxPool2d(kernel_size=2))
-    
-    #output after this 
-    #(14-5+2*2/1 +1 = 13+1=14 then 14/2= 7)
-    
-    self.layer=nn.Linear(32*7*7,10)
-
+    https://colab.research.google.com/drive/1xG500b51pcVvYpP_fgsQ2IgEPQ3TLIup
 
-  def forward(self,x): 
-    x=self.block1(x)
-    x=self.block2(x) 
-    #flatteing the output 
-    x = x.view(x.size(0), -1)
-    #now feeding inot the linear network 
-    x = self.layer(x)
-
-    return x
-
-#making instance 
-model=CNN()
-print(model)
-
-"""# Training the model"""
-
-#initialising the loss and optimizer 
-criterion=nn.CrossEntropyLoss()
-learning_rate = 0.01
-optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
-
-print(model.parameters())
+###Importing Libraries
+"""
 
-print(len(list(model.parameters())))
+# Commented out IPython magic to ensure Python compatibility.
+import os
+import sys
+import numpy as np
 
-# Convolution 1: 16 Kernels
-print(list(model.parameters())[0].size())
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
 
-# Convolution 1 Bias: 16 Kernels
-print(list(model.parameters())[1].size())
+import torch.profiler
+from torch.utils.data import DataLoader, TensorDataset
 
-# Convolution 2: 32 Kernels with depth = 16
-print(list(model.parameters())[2].size())
+import torchvision.utils
+from torchvision import models
+import torchvision.datasets as dsets
+import torchvision.transforms as transforms
+from torchvision.models import resnet18, ResNet18_Weights
 
-# Convolution 2 Bias: 32 Kernels with depth = 16
-print(list(model.parameters())[3].size())
 
-# Fully Connected Layer 1
-print(list(model.parameters())[4].size())
+from sklearn.manifold import TSNE
 
-# Fully Connected Layer Bias
-print(list(model.parameters())[5].size())
+from sklearn.metrics import accuracy_score
+import matplotlib.pyplot as plt
+# %matplotlib inline
 
-#lets begin the training 
-iter=0 
+import warnings
+warnings.filterwarnings('ignore')
 
-for epochs in range(num_epochs): 
-  for i,(images,labels) in enumerate(train_loader):
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+device
 
-    #loading the images 
-    images.requires_grad_() 
+"""##Q1
 
-    #first clearning the parameters 
-    optimizer.zero_grad()
-     
-    #calclauting the output and loss 
-    output=model(images) 
+###Loading CIFAR10
+"""
 
-    loss=criterion(output,labels)
+# Define the transformations to apply to the images
 
-    #backprapgating the loss 
-    loss.backward() 
+transform_train = transforms.Compose([
+    transforms.ToTensor()    
+])
 
-    #updating the parameters 
-    optimizer.step() 
 
-    iter+=1 
+transform = transforms.Compose(
+    [
+      transforms.ToTensor(),
+     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
 
-    #printing for every 500 iterations 
-    if iter%500==0: 
-      # Calculate Accuracy         
-      correct = 0
-      total = 0
+transform_test = transforms.Compose([
+    transforms.ToTensor()
+])
 
-    #now iterate through the test dataset 
 
-      for images,labels in test_loader: 
-        images = images.requires_grad_() 
-        outputs = model(images) 
-        _, predicted = torch.max(outputs.data, 1) 
-        total += labels.size(0) 
-        correct += (predicted == labels).sum()
-      
-      accuracy = 100 * correct / total
+mnist_train = dsets.MNIST(root='./', train=True,
+                                       download=True, transform=transform_train)
+mnist_test  = dsets.MNIST(root='./', train=False,
+                                       download=True, transform=transform_test)
 
-      # Print Loss
-      print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.item(), accuracy))
 
-"""Accuracy came out to 96.63
+train_loader = torch.utils.data.DataLoader(mnist_train, batch_size=64,
+                                         shuffle=True, num_workers=1)
 
-# Model 2
+test_loader = torch.utils.data.DataLoader(mnist_test, batch_size=64,
+                                        shuffle=False, num_workers=1)
 
-This involves average pooling layer
-"""
+"""###Defining CNN model as mentioned in question"""
 
-class CNN2(nn.Module): 
-  def __init__(self): 
-    super().__init__()
-
-    #defining the layers 
-    self.block1=nn.Sequential(nn.Conv2d(1,16,kernel_size=(5,5),stride=1,padding=2),
-                              nn.ReLU(),
-                              nn.AvgPool2d(kernel_size=2))
-    #output after this operation 
-    #(28-5+2/1 +1 =28 then max pooling 28/2=14)
-    
-    self.block2=nn.Sequential(nn.Conv2d(16,32,kernel_size=(5,5),stride=1,padding=2),
-                              nn.ReLU(),
-                              nn.AvgPool2d(kernel_size=2))
-    
-    #output after this 
-    #(14-5+2*2/1 +1 = 13+1=14 then 14/2= 7)
-    
-    self.layer=nn.Linear(32*7*7,10)
-
-
-  def forward(self,x): 
-    x=self.block1(x)
-    x=self.block2(x) 
-    #flatteing the output 
-    x = x.view(x.size(0), -1)
-    #now feeding inot the linear network 
-    x = self.layer(x)
-
-    return x
-
-#making instance 
-model2=CNN2()
-print(model2)
-
-learning_rate = 0.01
-optimizer = torch.optim.SGD(model2.parameters(), lr=learning_rate)
-
-#lets begin the training 
-iter=0 
-
-for epochs in range(num_epochs): 
-  for i,(images,labels) in enumerate(train_loader):
-
-    #loading the images 
-    images.requires_grad_() 
-
-    #first clearning the parameters 
-    optimizer.zero_grad()
-     
-    #calclauting the output and loss 
-    output=model2(images) 
-
-    loss=criterion(output,labels)
-
-    #backprapgating the loss 
-    loss.backward() 
-
-    #updating the parameters 
-    optimizer.step() 
-
-    iter+=1 
-
-    #printing for every 500 iterations 
-    if iter%500==0: 
-      # Calculate Accuracy         
-      correct = 0
-      total = 0
-
-    #now iterate through the test dataset 
-
-      for images,labels in test_loader: 
-        images = images.requires_grad_() 
-        outputs = model2(images) 
-        _, predicted = torch.max(outputs.data, 1) 
-        total += labels.size(0) 
-        correct += (predicted == labels).sum()
-      
-      accuracy = 100 * correct / total
-
-      # Print Loss
-      print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.item(), accuracy))
-
-"""Accuracy came out to be 93 %
-
-# Model 3
-This involves vaild pooling which means smaller output size
-"""
+import torch
+import torch.nn as nn
 
-class CNN3(nn.Module):
+class MNISTModel(nn.Module):
     def __init__(self):
-        super(CNN3, self).__init__()
-
-        # Convolution 1
-        self.cnn1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=5, stride=1, padding=0)
-        self.relu1 = nn.ReLU()
-
-        # Max pool 1
-        self.maxpool1 = nn.MaxPool2d(kernel_size=2)
-
-        # Convolution 2
-        self.cnn2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, stride=1, padding=0)
-        self.relu2 = nn.ReLU()
-
-        # Max pool 2
-        self.maxpool2 = nn.MaxPool2d(kernel_size=2)
-
-        # Fully connected 1 (readout)
-        self.fc1 = nn.Linear(32 * 4 * 4, 10) 
+        super(MNISTModel, self).__init__()
+        self.conv_layers = nn.Sequential(
+            nn.Conv2d(in_channels=1, out_channels=8, kernel_size=3, stride=1, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(in_channels=8, out_channels=16, kernel_size=3, stride=1,padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=2),
+            # nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1,padding=1),
+            # nn.ReLU(inplace=True),
+            # nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1,padding=1),
+            # nn.ReLU(inplace=True),
+            # nn.MaxPool2d(kernel_size=2),
+            # nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1,padding=1),
+            # nn.ReLU(inplace=True),
+            # nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1,padding=1),
+            # nn.ReLU(inplace=True),
+            # nn.MaxPool2d(kernel_size=2)
+        )
+        self.fc_layers = nn.Sequential(
+            nn.Linear(in_features=3136, out_features=10)
+        )
 
     def forward(self, x):
-        # Convolution 1
-        out = self.cnn1(x)
-        out = self.relu1(out)
-
-        # Max pool 1
-        out = self.maxpool1(out)
-
-        # Convolution 2 
-        out = self.cnn2(out)
-        out = self.relu2(out)
-
-        # Max pool 2 
-        out = self.maxpool2(out)
-
-        # Resize
-        # Original size: (100, 32, 7, 7)
-        # out.size(0): 100
-        # New out size: (100, 32*7*7)
-        out = out.view(out.size(0), -1)
-
-        # Linear function (readout)
-        out = self.fc1(out)
-
-        return out
-
-#making instance 
-model3=CNN3()
-print(model3)
-
-learning_rate = 0.01
-optimizer = torch.optim.SGD(model3.parameters(), lr=learning_rate)
-
-#lets begin the training 
-iter=0 
-
-for epochs in range(num_epochs): 
-  for i,(images,labels) in enumerate(train_loader):
-
-    #loading the images 
-    images.requires_grad_() 
-
-    #first clearning the parameters 
-    optimizer.zero_grad()
-     
-    #calclauting the output and loss 
-    output=model3(images) 
-
-    loss=criterion(output,labels)
-
-    #backprapgating the loss 
-    loss.backward() 
-
-    #updating the parameters 
-    optimizer.step() 
-
-    iter+=1 
-
-    #printing for every 500 iterations 
-    if iter%500==0: 
-      # Calculate Accuracy         
-      correct = 0
-      total = 0
-
-    #now iterate through the test dataset 
-
-      for images,labels in test_loader: 
-        images = images.requires_grad_() 
-        outputs = model3(images) 
-        _, predicted = torch.max(outputs.data, 1) 
-        total += labels.size(0) 
-        correct += (predicted == labels).sum()
-      
-      accuracy = 100 * correct / total
-
-      # Print Loss
-      print('Iteration: {}. Loss: {}. Accuracy: {}'.format(iter, loss.item(), accuracy))
-
-"""Accuracy is 96 for the model 3
-
-We can see in the above models the model with max pooling and padding=1 gave the best accuracy
-"""
-
+        x = self.conv_layers(x)
+        x = torch.flatten(x, 1)
+        # print(x.shape)
+        x = self.fc_layers(x)
+        return x
+
+model = MNISTModel()
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.001)
+
+"""###Training the model"""
+
+def train_main(train_loader, test_loader, num_epochs, optimizer, model, device='cpu'):
+    # Lists to store the train and test losses and accuracies
+    train_losses = []
+    test_losses = []
+    train_accs = []
+    test_accs = []
+
+    criterion = nn.CrossEntropyLoss()
+
+    model.to(device)
+
+    for epoch in range(num_epochs):
+        train_loss = 0
+        train_correct = 0
+        train_total = 0
+
+        for i, (images, labels) in enumerate(train_loader):
+            # Send inputs and targets to GPU if available
+            images = images.to(device)
+            labels = labels.to(device)
+
+            optimizer.zero_grad() # zero the gradients
+            outputs = model(images)
+            loss = criterion(outputs, labels) # calculate the loss
+            loss.backward() # backpropagation
+            optimizer.step() # update weights
+            train_loss += loss.item()
+
+            # calculate the training accuracy
+            _, predicted = torch.max(outputs.data, 1)
+            train_total += labels.size(0)
+            train_correct += (predicted == labels).sum().item()
+
+            # prof.step()  ##Taking step in tensorboard profiler
+
+        # evaluate the model on the test set
+        test_loss = 0
+        test_correct = 0
+        test_total = 0
+        with torch.no_grad():
+            for images, labels in test_loader:
+                # Send inputs and targets to GPU if available
+                images = images.to(device)
+                labels = labels.to(device)
+
+                outputs = model(images)
+                loss = criterion(outputs, labels)
+                test_loss += loss.item()
+
+                # calculate the testing accuracy
+                _, predicted = torch.max(outputs.data, 1)
+                test_total += labels.size(0)
+                test_correct += (predicted == labels).sum().item()
+
+        # append the average loss and accuracy for the epoch to the lists
+        train_loss /= len(train_loader)
+        test_loss /= len(test_loader)
+        train_acc = 100.0 * train_correct / train_total
+        test_acc = 100.0 * test_correct / test_total
+        train_losses.append(train_loss)
+        test_losses.append(test_loss)
+        train_accs.append(train_acc)
+        test_accs.append(test_acc)
+        print('Epoch: {}, train loss: {:.4f}, test loss: {:.4f}, train accuracy: {:.2f}%, test accuracy: {:.2f}%'.format(epoch+1, train_loss, test_loss, train_acc, test_acc))
+        
+        # save the results to a text file
+    with open("results.txt", "w") as f:
+        for epoch in range(num_epochs):
+            f.write("Epoch: {}, train loss: {:.4f}, test loss: {:.4f}, train accuracy: {:.2f}%, test accuracy: {:.2f}%\n".format(epoch+1, train_losses[epoch], test_losses[epoch], train_accs[epoch], test_accs[epoch]))
+
+    # plot the loss and accuracy curves side by side
+    fig, axs = plt.subplots(1, 2, figsize=(12, 4))
+    axs[0].plot(train_losses, label='Train Loss')
+    axs[0].plot(test_losses, label='Test Loss')
+    axs[0].set_xlabel('Epoch')
+    axs[0].set_ylabel('Loss')
+    axs[0].legend()
+    axs[1].plot(train_accs, label='Train Accuracy')
+    axs[1].plot(test_accs, label='Test Accuracy')
+    axs[1].set_xlabel('Epoch')
+    axs[1].set_ylabel('Accuracy')
+    axs[1].legend()
+    plt.savefig('loss_and_accuracy.png')
+    torch.save(model, 'trained_model.pt')
+    plt.show()
+
+num_epochs=3
+train_main(train_loader, test_loader, num_epochs, optimizer, model, device)
+
+
+
+"""###ResNet18 model"""
+
+# model = models.resnet18(pretrained=False)
+# num_ftrs = model.fc.in_features
+# model.fc = nn.Linear(num_ftrs, 10)
+
+# # model.to(device)
+# criterion = nn.CrossEntropyLoss()
+# optimizer = optim.Adam(model.parameters(), lr=0.001)