{"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.6.4"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":3649,"databundleVersionId":46718,"sourceType":"competition"}],"dockerImageVersionId":30822,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Introduction:\n\nThe CIFAR-10 dataset contains 60,000 color images of 32 x 32 pixels in 3 channels divided into 10 classes. Each class contains 6,000 images. The training set contains 50,000 images, while the test sets provides 10,000 images. This image taken from the CIFAR repository ( https://www.cs.toronto.edu/~kriz/cifar.html ). This is a classification problem with 10 classes(muti-label classification). We can take a view on this image for more comprehension of the dataset.","metadata":{}},{"cell_type":"markdown","source":"**Label Encoding is as follows:**\n\n| **Label** | **Type** |\n| -: | :-: |\n| 0 | airplane |\n| 1 | automobile |\n| 2 | bird |\n| 3 | cat |\n| 4 | deer |\n| 5 | dog |\n| 6 | frog |\n| 7 | horse |\n| 8 | ship |\n| 9 | truck |","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport pickle\nfrom PIL import Image\nimport torchvision.datasets as dsets\nimport torchvision.transforms as transforms\nimport torch\nimport torch.nn as nn\nimport pickle\nimport os\nimport torch.nn.functional as F\nimport requests\nfrom sklearn.metrics import confusion_matrix, classification_report\nimport seaborn as sn\nimport pandas as pd\ntorch.manual_seed(1) # Set manual seed\nfrom sklearn import preprocessing\nfrom torch.utils.data import DataLoader, Dataset, Subset","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:34.14164Z","start_time":"2023-01-12T03:35:31.219551Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 1. Data Preparation\n\n\nThe idea here is to pass as much as different transformed images to our model so that our model learns complex patterns and restricts itself to overfit.\n\nThe following steps have been implemented for the same\n\n- *Image resizing* : As the image size from source is 32X32 we apply resize function just to make sure every images passed to our process is similar in terms of size\n\n\n- *Image transformation*: We apply different transformation to the image. Details mentioned below. Here one point to note is that we can randomly apply every type of transformation as this might lead to underfitting. The reason behind this is that the resolution of the images is already very low and applying some critical transfortions like centercrop, vertical flip and other might decay model performance\n\n\n- *Apply normalization to image*: The mean and standard deviation is taken from different studies researchers have implemented and have them to converge faster. You can experiment with different image size and standard deviations as well\n\n\n- *Apply Random Erasing*: It helps in randomly adding some noise to the image, so that the model can learn to generalize better.","metadata":{}},{"cell_type":"markdown","source":"**Define the image size and transformation pipeline for training and validation**","metadata":{}},{"cell_type":"code","source":"IMAGE_SIZE = 32\n\nmean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]\n# These values are mostly used by researchers as found to very useful in fast convergence\n\n\n# https://pytorch.org/vision/stable/transforms.html\n# We can try various transformation for good generalization of model\ncomposed_train = transforms.Compose([transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)), # Resize the image in a 32X32 shape\n                                     transforms.RandomRotation(20), # Randomly rotate some images by 20 degrees\n                                     transforms.RandomHorizontalFlip(0.1), # Randomly horizontal flip the images\n                                     transforms.ColorJitter(brightness = 0.1, # Randomly adjust color jitter of the images\n                                                            contrast = 0.1, \n                                                            saturation = 0.1), \n                                     transforms.RandomAdjustSharpness(sharpness_factor = 2,\n                                                                      p = 0.1), # Randomly adjust sharpness\n                                     transforms.ToTensor(),   # Converting image to tensor\n                                     transforms.Normalize(mean, std), # Normalizing with standard mean and standard deviation\n                                     transforms.RandomErasing(p=0.75,scale=(0.02, 0.1),value=1.0, inplace=False)])\n\n\ncomposed_test = transforms.Compose([transforms.Resize((IMAGE_SIZE,IMAGE_SIZE)),\n                                    transforms.ToTensor(),\n                                    transforms.Normalize(mean, std)])\n","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:34.154114Z","start_time":"2023-01-12T03:35:34.149023Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Load train and validation dataset**","metadata":{}},{"cell_type":"code","source":"# Load the data and transform the dataset\ntrain_dataset =  dsets.CIFAR10(root='./data', train=True, download=True, transform = composed_train)\nvalidation_dataset = dsets.CIFAR10(root='./data', train=False, download=True, transform = composed_test)\n\n# Create train and validation batch for training\ntrain_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=100)\nvalidation_loader = torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=100)","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:35.774839Z","start_time":"2023-01-12T03:35:34.161393Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Some important functions to print the images and image convertor from tensor to numpy**","metadata":{}},{"cell_type":"code","source":"def show_data(img):\n    try:\n        plt.imshow(img[0])\n    except Exception as e:\n        print(e)\n    print(img[0].shape, img[0].permute(1,2,0).shape)\n    plt.imshow(img[0].permute(1,2,0))\n    plt.title('y = '+ str(img[1]))\n    plt.show()\n    \n# We need to convert the images to numpy arrays as tensors are not compatible with matplotlib.\ndef im_convert(tensor):\n    #Lets\n    img = tensor.cpu().clone().detach().numpy() #\n    img = img.transpose(1, 2, 0)\n    img = img * np.array(tuple(mean)) + np.array(tuple(std))\n    img = img.clip(0, 1) # Clipping the size to print the images later\n    return img","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:35.789356Z","start_time":"2023-01-12T03:35:35.78525Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Lets print some random datasets**","metadata":{}},{"cell_type":"code","source":"show_data(train_dataset[8])","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:35.92177Z","start_time":"2023-01-12T03:35:35.797086Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Different classes in CIPHAR 10 dataset. \nclasses = ('airplane', \n           'automobile', \n           'bird',\n           'cat',\n           'deer',\n           'dog', \n           'frog', \n           'horse', \n           'ship',\n           'truck')\n\n# Define an iterable on the data\ndata_iterable = iter(train_loader) # converting our train_dataloader to iterable so that we can iter through it. \nimages, labels = next(data_iterable) #going from 1st batch of 100 images to the next batch\nfig = plt.figure(figsize=(20, 10)) \n\n# Lets plot 50 images from our train_dataset\nfor idx in np.arange(10):\n    ax = fig.add_subplot(2, 5, idx+1, xticks=[], yticks=[])\n    \n    # Note: imshow cant print tensor !\n    # Lets convert tensor image to numpy using im_convert function for imshow to print the image\n    plt.imshow(im_convert(images[idx]))\n    ax.set_title(classes[labels[idx].item()])","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:46:12.464082Z","start_time":"2023-01-12T06:46:12.211329Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## 2. Convolution Neural Network Implementation","metadata":{}},{"cell_type":"markdown","source":"Steps followed for the modelling process:\n\n1) Define a rough model architecture to follow (credits to IBM for image)\n\n2) Starting with 2 Convolution layer and 1 fully connected layer (fc)\n\n3) Keep adding hidden layers to the above model and check of validation accuracy improves.\n\n4) Note if we increase model layers and neurons this might lead to slower training and increase chances of overfitting. Also increase complexitu might led to getting stuck at saddle point or local minima. Hence to cater all this potential problems, experimented with momentum, dropout & He weight initialization","metadata":{}},{"cell_type":"markdown","source":"**i) Define common model training module**","metadata":{}},{"cell_type":"code","source":"def train_model(model, train_loader, validation_loader, optimizer, n_epochs = 20):\n    \n    # Global variable\n    N_test = len(validation_dataset)\n    accuracy_list = []\n    train_loss_list = []\n    train_cost_list = []\n    val_cost_list = []\n    \n    for epoch in range(n_epochs):\n        train_COST = 0\n        for x,y in train_loader:\n            model.train()\n            optimizer.zero_grad()\n            z = model(x)\n            loss = criterion(z,y)\n            loss.backward()\n            optimizer.step()\n            train_COST+=loss.item()\n            \n        train_COST = train_COST/len(train_loader)\n        train_cost_list.append(train_COST)\n        correct = 0\n        \n        # Perform the prediction on the validation data\n        val_COST = 0\n        for x_test, y_test in validation_loader:\n            model.eval()\n            z = model(x_test)\n            val_loss = criterion(z, y_test)\n            _, yhat = torch.max(z.data, 1)\n            correct += (yhat==y_test).sum().item()\n            val_COST+=val_loss.item()\n        \n        val_COST = val_COST/ len(validation_loader)\n        val_cost_list.append(val_COST)\n            \n        accuracy = correct / N_test\n        accuracy_list.append(accuracy)\n        \n        print(\"--> Epoch Number : {}\".format(epoch + 1),\n              \" | Training Loss : {}\".format(round(train_COST,4)),\n              \" | Validation Loss : {}\".format(round(val_COST,4)),\n              \" | Validation Accuracy : {}%\".format(round(accuracy * 100, 2)))\n        \n    return accuracy_list, train_cost_list, val_cost_list","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:35:38.3747Z","start_time":"2023-01-12T03:35:38.355133Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**ii) CNN Model V1:**","metadata":{}},{"cell_type":"markdown","source":"![image.png](attachment:image.png)","metadata":{},"attachments":{"image.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"Image Credits : IBM","metadata":{}},{"cell_type":"code","source":"class CNN(nn.Module):\n    '''\n    CNN Model V1: \n    1. 2 convolution + max pool layers \n    2. 1 fully connected layers\n    3. Default runtime using 0 momentum and 0 dropout value\n    '''\n    \n    # Constructor\n    def __init__(self, out_1 = 32, out_2 = 64, number_of_classes = 10):\n        super(CNN, self).__init__()\n        self.cnn1 = nn.Conv2d(in_channels = 3, out_channels = out_1, kernel_size = 5, padding = 2)\n        self.maxpool1 = nn.MaxPool2d(kernel_size = 2)\n        \n        \n        self.cnn2 = nn.Conv2d(in_channels = out_1, out_channels = out_2, kernel_size = 5, padding = 2)\n        self.maxpool2 = nn.MaxPool2d(kernel_size = 2)\n        self.fc1 = nn.Linear(out_2 * 8 * 8, number_of_classes)\n        # Calculation of how we got 8*8 is mentioned in the below comment\n        \n    # Prediction\n    def forward(self, x):\n        x = self.cnn1(x)\n        x = torch.relu(x)\n        x = self.maxpool1(x)\n        x = self.cnn2(x)\n        x = torch.relu(x)\n        x = self.maxpool2(x)\n        x = x.view(x.size(0), -1)\n        x = self.fc1(x)\n        return(x)","metadata":{"ExecuteTime":{"end_time":"2023-01-05T20:51:45.55699Z","start_time":"2023-01-05T20:51:45.53852Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"This is how we get the 8x8 image size after cnn1, maxpool1, cnn2 and maxpool2:\n\n   1. 'out_2' is a given parameter when  the cnn2 was defined, it is the output of cnn2 equal to 32\n\n   2. 8x8 is the result of the 'image size' after cnn1, maxpool1, cnn2 and maxpool2:\n\n2.a. Input size is 32x32\n\n2.b. after cnn1, size per channel (total of 16 channels) is (32 + 2*2 -5)/1 + 1 = 32x32\n\n2.c after maxpool 1, size per channel (still total of 32 channels) is (32 + 2*0 - 2)/2 + 1 (stride size is equal to kernel size of 2) = 16x16 \n\n2.c after cnn2, size per channel is (16+ 2*2 -5)/1 + 1 =16x16\n\n2.d. after maxpool2, size per channel is (16  + 2*0 -2)/2 + 1= 8x8","metadata":{}},{"cell_type":"markdown","source":"**Define loss function, optimizer, dataset loader**","metadata":{}},{"cell_type":"code","source":"# Define the model\nmodel_v1 = CNN(out_1=32, out_2=64, number_of_classes = 10)\n\n# Define model training hyperparameters\ncriterion = nn.CrossEntropyLoss()\nlearning_rate = 0.1\noptimizer = torch.optim.SGD(model_v1.parameters(), lr = learning_rate)\n\n# Train the model\naccuracy_list_normal_v1, train_cost_list_v1, val_cost_list_v1 = train_model(model=model_v1,n_epochs=20,train_loader=train_loader,validation_loader=validation_loader,optimizer=optimizer)","metadata":{"ExecuteTime":{"end_time":"2023-01-05T20:51:25.37358Z","start_time":"2023-01-05T20:51:19.471493Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"The above with momentum 0 gave less accurate results hence sticking back to momentum = 0.2","metadata":{}},{"cell_type":"markdown","source":"**iii) CNN Model V1 with momentum:**","metadata":{}},{"cell_type":"code","source":"# Define the model\nmodel_mmt_v1 = CNN(out_1=32, out_2=64, number_of_classes = 10)\n\n# Define the model learning hyperparameters\ncriterion = nn.CrossEntropyLoss()\nlearning_rate = 0.1\noptimizer = torch.optim.SGD(model_mmt_v1.parameters(), lr = learning_rate, momentum = 0.2)\n\n# Train the model\naccuracy_list_normal_mmt_v1, train_cost_list_mmt_v1, val_cost_list_mmt_v1=train_model(model=model_mmt_v1,n_epochs=20,train_loader=train_loader,validation_loader=validation_loader,optimizer=optimizer)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T16:57:27.523485Z","start_time":"2023-01-03T16:48:57.592468Z"},"_kg_hide-output":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**iv) CNN Model V2:**\n\nAdded one more hidden layer in the Fully connected segment of the model.\nUsed momentum = 0.2 and dropout value = 0.5","metadata":{}},{"cell_type":"code","source":"class CNN_V2(nn.Module):    \n    '''\n    CNN Model V2: \n    1. 2 convolution & max pool layers \n    2. 2 fully connected layers\n    3. Default runtime using 0.2 momentum and dropout value p = 0.5\n    '''\n    # Constructor\n    def __init__(self, out_1 = 32, out_2 = 64, number_of_classes = 10, p = 0):\n        super(CNN_V2, self).__init__()\n        self.cnn1 = nn.Conv2d(in_channels = 3, out_channels = out_1, kernel_size = 5, padding = 2)\n        self.maxpool1 = nn.MaxPool2d(kernel_size = 2)\n        \n        \n        self.cnn2 = nn.Conv2d(in_channels = out_1, out_channels = out_2, kernel_size = 5, padding = 2)\n        self.maxpool2 = nn.MaxPool2d(kernel_size = 2)\n        self.fc1 = nn.Linear(out_2 * 8 * 8, 1000) # Roughly taken seein the input and the output\n        self.drop = nn.Dropout(p=p)\n        self.fc2 = nn.Linear(1000, number_of_classes)\n        \n    # Prediction\n    def forward(self, x):\n        x = self.cnn1(x)\n        x = torch.relu(x)\n        x = self.maxpool1(x)\n        x = self.cnn2(x)\n        x = torch.relu(x)\n        x = self.maxpool2(x)\n        x = x.view(x.size(0), -1)\n        x = self.fc1(x)\n        x = F.relu(self.drop(x))\n        x = self.fc2(x)\n        return(x)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T17:40:03.314323Z","start_time":"2023-01-03T17:40:03.293794Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define the model\nmodel_mmt_v2 = CNN_V2(out_1=32, out_2=64, number_of_classes = 10, p=0.5)\n\n# Define model learning hyperparamters\ncriterion = nn.CrossEntropyLoss()\nlearning_rate = 0.1\noptimizer = torch.optim.SGD(model_mmt_v2.parameters(), lr = learning_rate, momentum = 0.2)\n\n# Train the model\naccuracy_list_normal_v2, train_cost_list_v2, val_cost_list_v2=train_model(model=model_mmt_v2,n_epochs=20,train_loader=train_loader,validation_loader=validation_loader,optimizer=optimizer)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T17:49:05.958617Z","start_time":"2023-01-03T17:40:05.444982Z"},"_kg_hide-output":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"*Takeaway*: The accuracy improved by some bits using momentum, dropout and additional fc layer combo hence we will keep momentum & dropouts intact for other models as well","metadata":{}},{"cell_type":"markdown","source":"**v) CNN Model V3 :**\n\nAdded one more hidden layer in the Fully connected segment of the model.\nUsed momentum = 0.2 and dropout value = 0.5","metadata":{}},{"cell_type":"code","source":"class CNN_V3(nn.Module):\n    '''\n    CNN Model V3: \n    1. 2 convolution & max pool layers \n    2. 3 fully connected layers\n    3. Default runtime using 0.2 momentum and dropout value p = 0.5\n    '''\n    # Constructor\n    def __init__(self, out_1 = 32, out_2 = 64, number_of_classes = 10, p = 0):\n        super(CNN_V3, self).__init__()\n        self.cnn1 = nn.Conv2d(in_channels = 3, out_channels = out_1, kernel_size = 5, padding = 2)\n        self.maxpool1 = nn.MaxPool2d(kernel_size = 2)\n        \n        self.cnn2 = nn.Conv2d(in_channels = out_1, out_channels = out_2, kernel_size = 5, padding = 2)\n        self.maxpool2 = nn.MaxPool2d(kernel_size = 2)\n        \n        # Hidden layer 1\n        self.fc1 = nn.Linear(out_2 * 8 * 8, 1000) # Roughly taken seein the input and the output\n        self.drop = nn.Dropout(p=p)\n        \n        # Hidden layer 2\n        self.fc2 = nn.Linear(1000, 1000)\n        \n        # Final layer\n        self.fc3 = nn.Linear(1000, 10)\n        \n    # Predictiona\n    def forward(self, x):\n        x = self.cnn1(x)\n        x = torch.relu(x)\n        x = self.maxpool1(x)\n        x = self.cnn2(x)\n        x = torch.relu(x)\n        x = self.maxpool2(x)\n        x = x.view(x.size(0), -1)\n        x = self.fc1(x)\n        x = F.relu(self.drop(x))\n        x = self.fc2(x)\n        x = F.relu(self.drop(x))\n        x = self.fc3(x)\n        return(x)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T19:09:15.507392Z","start_time":"2023-01-03T19:09:15.488167Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define the model\nmodel_mmt_v31 = CNN_V3(out_1=32, out_2=64, number_of_classes = 10, p=0.5)\n\n# Define the model training hyperparameters\ncriterion = nn.CrossEntropyLoss()\nlearning_rate = 0.1\noptimizer = torch.optim.SGD(model_mmt_v31.parameters(), lr = learning_rate, momentum = 0.2)\n\n# Train the model\naccuracy_list_normal_v31, loss_list_normal_v31=train_model(model=model_mmt_v31,n_epochs=20,train_loader=train_loader,validation_loader=validation_loader,optimizer=optimizer)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T19:18:26.296322Z","start_time":"2023-01-03T19:09:17.656088Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"*Takeaway*: The accuracy improved by some perctange on further addition of the hidden layer. Lets test some more models","metadata":{}},{"cell_type":"markdown","source":"**vi) CNN Model V3_V2 :**\n\nAdding one more hidden layer & one more convolution layer","metadata":{}},{"cell_type":"code","source":"class CNN_V3_V2(nn.Module):\n    \n    '''\n    CNN Model V3-V2: \n    1. 3 convolution & max pool layers \n    2. 3 fully connected layers\n    3. Default runtime using 0.2 momentum and dropout value p = 0.5\n    '''\n    # Constructor\n    def __init__(self, out_1 = 32, out_2 = 64, out_3 = 128, number_of_classes = 10, p = 0):\n        super(CNN_V3_V2, self).__init__()\n        self.cnn1 = nn.Conv2d(in_channels = 3, out_channels = out_1, kernel_size = 5, padding = 2)\n        self.maxpool1 = nn.MaxPool2d(kernel_size = 2)\n        \n        self.cnn2 = nn.Conv2d(in_channels = out_1, out_channels = out_2, kernel_size = 5, padding = 2)\n        self.maxpool2 = nn.MaxPool2d(kernel_size = 2)\n        \n        self.cnn3 = nn.Conv2d(in_channels = out_2, out_channels = out_3, kernel_size = 5, padding = 2)\n        self.maxpool3 = nn.MaxPool2d(kernel_size = 2)\n        \n        # Hidden layer 1\n        self.fc1 = nn.Linear(out_3 * 4 * 4, 1000) \n        # 8x8 will change to 4x4 as we added a convolution & max pool layer refer calculation comment above\n        self.drop = nn.Dropout(p=p)\n        \n        # Hidden layer 2\n        self.fc2 = nn.Linear(1000, 1000)\n        \n        # Final layer\n        self.fc3 = nn.Linear(1000, 10)\n        \n    # Predictiona\n    def forward(self, x):\n        \n        x = self.cnn1(x)\n        x = torch.relu(x)\n        x = self.maxpool1(x)\n        \n        x = self.cnn2(x)\n        x = torch.relu(x)\n        x = self.maxpool2(x)\n        \n        x = self.cnn3(x)\n        x = torch.relu(x)\n        x = self.maxpool3(x)\n        \n        x = x.view(x.size(0), -1)\n        x = self.fc1(x)\n        \n        x = F.relu(self.drop(x))\n        x = self.fc2(x)\n        \n        x = F.relu(self.drop(x))\n        x = self.fc3(x)\n        \n        return(x)","metadata":{"ExecuteTime":{"end_time":"2023-01-04T02:18:35.444033Z","start_time":"2023-01-04T02:18:35.42473Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define model\nmodel_mmt_v32 = CNN_V3_V2(out_1=32, out_2=64, out_3 =128, number_of_classes = 10, p=0.5)\n\n# Define the model hyperparameters\ncriterion = nn.CrossEntropyLoss()\nlearning_rate = 0.1\noptimizer = torch.optim.SGD(model_mmt_v32.parameters(), lr = learning_rate, momentum = 0.2)\n\n# Train the model\naccuracy_list_normal_v32, loss_list_normal_v32=train_model(model=model_mmt_v32, n_epochs=20, train_loader=train_loader, validation_loader=validation_loader, optimizer=optimizer)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T19:39:37.840168Z","start_time":"2023-01-03T19:30:06.323184Z"},"_kg_hide-output":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"*Takeaway*: The accuracy again improved by some perctange on further addition of the FC layer and the convolution and max pool layer. Now lets see if we can converge faster with similar performance using He intialization","metadata":{}},{"cell_type":"markdown","source":"**vii) CNN Model V3-V3 :**\n\nAdding one more fully connected layer and initializing weights using He initialization","metadata":{}},{"cell_type":"code","source":"class CNN_V3_V3(nn.Module):\n    '''\n    CNN Model V3-V2: \n    1. 3 convolution & max pool layers \n    2. 4 fully connected layers\n    3. Default runtime using 0.2 momentum and dropout value p = 0.5\n    4. Weights initialized using He weight initialization\n    '''\n    # Constructor\n    def __init__(self, out_1 = 32, out_2 = 64, out_3 = 128, number_of_classes = 10, p = 0):\n        super(CNN_V3_V3, self).__init__()\n        self.cnn1 = nn.Conv2d(in_channels = 3, out_channels = out_1, kernel_size = 5, padding = 2)\n        self.maxpool1 = nn.MaxPool2d(kernel_size = 2)\n        \n        self.cnn2 = nn.Conv2d(in_channels = out_1, out_channels = out_2, kernel_size = 5, padding = 2)\n        self.maxpool2 = nn.MaxPool2d(kernel_size = 2)\n        \n        self.cnn3 = nn.Conv2d(in_channels = out_2, out_channels = out_3, kernel_size = 5, padding = 2)\n        self.maxpool3 = nn.MaxPool2d(kernel_size = 2)\n        \n        # Hidden layer 1\n        self.fc1 = nn.Linear(out_3 * 4 * 4, 1000) \n        torch.nn.init.kaiming_uniform_(self.fc1.weight, nonlinearity='relu')\n        self.drop = nn.Dropout(p=p)\n        \n        # Hidden layer 2\n        self.fc2 = nn.Linear(1000, 1000)\n        torch.nn.init.kaiming_uniform_(self.fc2.weight, nonlinearity='relu') # He weight initialization\n\n        # Hidden layer 3\n        self.fc3 = nn.Linear(1000, 1000)\n        torch.nn.init.kaiming_uniform_(self.fc3.weight, nonlinearity='relu') # He weight initialization\n        \n        # Final layer\n        self.fc4 = nn.Linear(1000, 10)\n        torch.nn.init.kaiming_uniform_(self.fc4.weight, nonlinearity='relu') # He weight initialization\n        \n    # Predictiona\n    def forward(self, x):\n        \n        x = self.cnn1(x)\n        x = torch.relu(x)\n        x = self.maxpool1(x)\n        \n        x = self.cnn2(x)\n        x = torch.relu(x)\n        x = self.maxpool2(x)\n        \n        x = self.cnn3(x)\n        x = torch.relu(x)\n        x = self.maxpool3(x)\n        \n        x = x.view(x.size(0), -1)\n        x = self.fc1(x)\n        \n        x = F.relu(self.drop(x))\n        x = self.fc2(x)\n        \n        x = F.relu(self.drop(x))\n        x = self.fc3(x)\n\n        x = F.relu(self.drop(x))\n        x = self.fc4(x)\n        \n        return(x)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T23:20:22.26522Z","start_time":"2023-01-03T23:20:22.242576Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Define the model\nmodel_mmt_v33 = CNN_V3_V3(out_1=32, out_2=64, out_3 =128, number_of_classes = 10, p=0.5)\ncriterion = nn.CrossEntropyLoss()\nlearning_rate = 0.1\noptimizer = torch.optim.SGD(model_mmt_v33.parameters(), lr = learning_rate, momentum = 0.2)\n\n# Train the model\naccuracy_list_normal_v33, loss_list_normal_v33=train_model(model=model_mmt_v33, n_epochs=20, train_loader=train_loader, validation_loader=validation_loader, optimizer=optimizer)","metadata":{"ExecuteTime":{"end_time":"2023-01-03T20:01:39.212984Z","start_time":"2023-01-03T19:51:48.109994Z"},"_kg_hide-output":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"*Takeaway*: The accuracy reduced drastically using He weight initialization. Lets drop this approach as we couldnt find global minima through this approach. Lets use traditional random weight initialization with the above architecture","metadata":{}},{"cell_type":"markdown","source":"**viii) CNN Model V3-V4** \n\nUSed similar architecture as CNN_V3_V3. The only difference is additon of more more fc layer and removal of He weight initialization.\n\n**Below is the rough architecture which my model follows:**","metadata":{}},{"cell_type":"markdown","source":"**Extra additions to model apart from additional convolution layer**\n1. Lets add dropout to convolution layers with p=0.2 as high value might lead to underfit as these are the initial layers from which the model extract useful features from the image.\n2. Added Batch normalization as this will help us to converge faster","metadata":{}},{"cell_type":"code","source":"class CNN_V3_V4(nn.Module):\n    \"\"\"\n    Adding one more hidden layer & dropout value & one more convolution layer\n    Total 3 hidden layers, 3 convolution layer & Batch Normalization\n    \"\"\"\n    # Constructor\n    def __init__(self, out_1 = 32, out_2 = 64, out_3 = 128, number_of_classes = 10, p = 0):\n        super(CNN_V3_V4, self).__init__()\n        self.cnn1 = nn.Conv2d(in_channels = 3, out_channels = out_1, kernel_size = 5, padding = 2)\n        self.maxpool1 = nn.MaxPool2d(kernel_size = 2)\n        self.conv1_bn = nn.BatchNorm2d(out_1)\n        self.drop_conv = nn.Dropout(p=0.2)\n        \n        self.cnn2 = nn.Conv2d(in_channels = out_1, out_channels = out_2, kernel_size = 5, padding = 2)\n        self.maxpool2 = nn.MaxPool2d(kernel_size = 2)\n        self.conv2_bn = nn.BatchNorm2d(out_2)\n        \n        self.cnn3 = nn.Conv2d(in_channels = out_2, out_channels = out_3, kernel_size = 5, padding = 2)\n        self.maxpool3 = nn.MaxPool2d(kernel_size = 2)\n        self.conv3_bn = nn.BatchNorm2d(out_3)\n        \n        # Hidden layer 1\n        self.fc1 = nn.Linear(out_3 * 4 * 4, 1000) \n        self.drop = nn.Dropout(p=p)\n        self.fc1_bn = nn.BatchNorm1d(1000)\n        \n        # Hidden layer 2\n        self.fc2 = nn.Linear(1000, 1000)\n        self.fc2_bn = nn.BatchNorm1d(1000)\n\n        # Hidden layer 3\n        self.fc3 = nn.Linear(1000, 1000)\n        self.fc3_bn = nn.BatchNorm1d(1000)\n        \n        # Hidden layer 4\n        self.fc4 = nn.Linear(1000, 1000)\n        self.fc4_bn = nn.BatchNorm1d(1000)\n        \n        # Final layer\n        self.fc5 = nn.Linear(1000, 10)\n        self.fc5_bn = nn.BatchNorm1d(10)\n        \n    # Predictiona\n    def forward(self, x):\n        \n        x = self.cnn1(x)\n        x = self.conv1_bn(x)\n        x = self.maxpool1(x)\n        x = self.drop_conv(x)\n        \n        x = self.cnn2(x)\n        x = self.conv2_bn(x)\n        x = torch.relu(x)\n        x = self.maxpool2(x)\n        x = self.drop_conv(x)\n        \n        x = self.cnn3(x)\n        x = self.conv3_bn(x)\n        x = torch.relu(x)\n        x = self.maxpool3(x)\n        x = self.drop_conv(x)\n        \n        x = x.view(x.size(0), -1)\n        x = self.fc1(x)\n        x = self.fc1_bn(x)\n        \n        x = F.relu(self.drop(x))\n        x = self.fc2(x)\n        x = self.fc2_bn(x)\n        \n        x = F.relu(self.drop(x))\n        x = self.fc3(x)\n        x = self.fc3_bn(x)\n        \n        x = F.relu(self.drop(x))\n        x = self.fc4(x)\n        x = self.fc4_bn(x)\n\n        x = F.relu(self.drop(x))\n        x = self.fc5(x)\n        x = self.fc5_bn(x)\n        \n        return(x)","metadata":{"ExecuteTime":{"end_time":"2023-01-12T03:50:32.798589Z","start_time":"2023-01-12T03:50:32.775876Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_mmt_v34 = CNN_V3_V4(out_1=32, out_2=64, out_3 =128, number_of_classes = 10, p=0.5)\ncriterion = nn.CrossEntropyLoss()\nlearning_rate = 0.1\noptimizer = torch.optim.SGD(model_mmt_v34.parameters(), lr = learning_rate, momentum = 0.2)\n\n# Train the model\naccuracy_list_normal_v34, train_cost_list_v34, val_cost_list_v34=train_model(model=model_mmt_v34, n_epochs=200, train_loader=train_loader, validation_loader=validation_loader, optimizer=optimizer)","metadata":{"ExecuteTime":{"end_time":"2023-01-12T05:58:45.697658Z","start_time":"2023-01-12T03:50:33.230875Z"},"_kg_hide-output":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 3. Model Performance Report & Error Analysis","metadata":{}},{"cell_type":"markdown","source":"**i) Printing model training loss vs accuracy:**","metadata":{}},{"cell_type":"code","source":"fig, ax1 = plt.subplots()\ncolor = 'tab:red'\nax1.plot(train_cost_list_v34,color=color)\nax1.set_xlabel('epoch',color=color)\nax1.set_ylabel('total loss',color=color)\nax1.tick_params(axis='y', color=color)\n    \nax2 = ax1.twinx()  \ncolor = 'tab:blue'\nax2.set_ylabel('accuracy', color=color)  \nax2.plot( accuracy_list_normal_v34, color=color)\nax2.tick_params(axis='y', labelcolor=color)\nfig.tight_layout()","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:01:27.104742Z","start_time":"2023-01-12T06:01:26.903829Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Takeaway**\n\nAs we can see that there is no sort of anomolous behavior in model traning and model converges to minima smoothly","metadata":{}},{"cell_type":"markdown","source":"**ii) Printing training and validation loss:**","metadata":{}},{"cell_type":"code","source":"plt.plot(train_cost_list_v34, 'r', label='Training Loss')\nplt.plot(val_cost_list_v34,  'g',  label='Validation Loss')\nplt.xlabel(\"Iteration\")\nplt.title(\"Loss\")\nplt.legend()","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:01:30.115149Z","start_time":"2023-01-12T06:01:30.001415Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Takeaways :** \n\nWe can see that the training loss and validation loss are close to each other. This gives a sense that we did a decent job in **avoiding our model to overfit.**","metadata":{}},{"cell_type":"markdown","source":"**iii) Error Analysis: Printing Confusion Matrix & Classification Report :**","metadata":{}},{"cell_type":"code","source":"y_pred = []\ny_true = []\n\n# iterate over test data\nfor x, y in torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=1):\n    z = model_mmt_v34(x)\n    _, yhat = torch.max(z, 1)\n    pred = yhat.data.cpu().numpy()\n    y_pred.extend(pred) # Save Prediction\n\n    labels = y.data.cpu().numpy()\n    y_true.extend(labels) # Save Truth\n\n# Build confusion matrix\ncf_matrix = confusion_matrix(y_true, y_pred)\ndf_cm = pd.DataFrame(cf_matrix/np.sum(cf_matrix) *10, index = [i for i in classes],\n                     columns = [i for i in classes])\nplt.figure(figsize = (12,7))\nsn.heatmap(df_cm, annot=True)\nplt.savefig('output.png')","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:02:30.943667Z","start_time":"2023-01-12T06:01:33.045037Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(classification_report(y_true, y_pred))","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:04:05.364903Z","start_time":"2023-01-12T06:04:05.331539Z"},"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Plot the mis-classified samples\ncount = 0\ni = 0\nfor x, y in torch.utils.data.DataLoader(dataset=validation_dataset, batch_size=1):\n    z = model_mmt_v34(x)\n    _, yhat = torch.max(z, 1)\n    if yhat != y:\n        show_data(validation_dataset[i])\n        plt.show()\n        print(\"yhat: \",yhat)\n        count += 1\n    if count >= 3:\n        break\n    i+=1","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:04:49.989669Z","start_time":"2023-01-12T06:04:49.526144Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"**Takeaway**\n\n1) Model is not able to perform well in predicting bird, cats, dogs as compared to other class.\n\n2) Overall model accuracy is decent. If we are able to get more data for cats and dogs we can improve our model performance\n\n3) As we can see in the above image model gets confused in predicting airplane an bird, which is fair enough as the underlying matrix might resemble very close to each other. Hence if we can get more training data or we can specifically add more oversampling of data for model to learn better, there is chance to further boost the accuracy.","metadata":{}},{"cell_type":"markdown","source":"**iv) Printing how out model performs on the first 20 images:**","metadata":{}},{"cell_type":"code","source":"data_iterable = iter(validation_loader)\nimages, labels = next(data_iterable)\noutput = model_mmt_v34(images)\n_, preds = torch.max(output, 1)\n\nfig = plt.figure(figsize=(25, 5))\n\nfor idx in np.arange(20):\n    ax = fig.add_subplot(2, 10, idx+1, xticks=[], yticks=[])\n    plt.imshow(im_convert(images[idx]))\n    ax.set_title(\"{} ({})\".format(str(classes[preds[idx].item()]), str(classes[labels[idx].item()])), color=(\"green\" if preds[idx]==labels[idx] else \"red\"))","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:04:55.151415Z","start_time":"2023-01-12T06:04:54.49281Z"},"_kg_hide-input":true,"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 4. Prediction on Test","metadata":{}},{"cell_type":"code","source":"class TestImageDataset(Dataset):\n    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):\n        self.img_labels = pd.read_csv(annotations_file)\n        self.img_dir = img_dir\n        self.transform = transform\n        self.target_transform = target_transform\n\n    def __len__(self):\n        return len(self.img_labels)\n\n    def __getitem__(self, idx):\n        # Define the path where images are stored by yourself.\n        # Remember, the first image is ./train/1.png\n        img_path = self.img_dir + '/' + str(self.img_labels.iloc[idx, 0]) +'.png'\n\n        # Read image. Recall how you converted an image to numpy array in the previous step.\n        image = np.asarray(Image.open(img_path).convert('RGB'))\n\n        label = self.img_labels.iloc[idx, 1]\n        if self.transform:\n            image = self.transform(image)\n        if self.target_transform:\n            label = self.target_transform(label)\n        return image, label","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:05:08.731504Z","start_time":"2023-01-12T06:05:08.716616Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Creating transform pipeline for test data\ncomposed_test_check = transforms.Compose([transforms.ToPILImage(), \n                                          transforms.Resize((IMAGE_SIZE,IMAGE_SIZE)),\n                                          transforms.ToTensor(),\n                                          transforms.Normalize(mean, std)])\n\ntest_dataset =  dsets.CIFAR10(root='./data/test', download=True, transform = composed_test_check)\ntest_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=500, shuffle=False)","metadata":{"ExecuteTime":{"end_time":"2023-01-12T06:36:54.879279Z","start_time":"2023-01-12T06:05:24.677915Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"y_test_pred = []\ny_test_true = []\n\n# iterate over test data\nfor x, y in torch.utils.data.DataLoader(dataset=test_dataset, batch_size=1):\n    z = model_mmt_v34(x)\n    _, yhat = torch.max(z, 1)\n    pred = yhat.data.cpu().numpy()\n    y_pred.extend(pred) # Save Prediction\n\n    labels = y.data.cpu().numpy()\n    y_true.extend(labels) # Save Truth\n\n# Build confusion matrix\ncf_matrix = confusion_matrix(y_test_true, y_test_pred)\ndf_cm = pd.DataFrame(cf_matrix/np.sum(cf_matrix) *10, index = [i for i in classes],\n                     columns = [i for i in classes])\nplt.figure(figsize = (12,7))\nsn.heatmap(df_cm, annot=True)\nplt.savefig('output.png')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(classification_report(y_test_true, y_test_pred))","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}