PyTorch_VGG_ResNet_VGGout.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[{"file_id":"https://github.com/pytorch/tutorials/blob/gh-pages/_downloads/62840b1eece760d5e42593187847261f/transfer_learning_tutorial.ipynb","timestamp":1604694802955}],"collapsed_sections":[]},"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.8"},"accelerator":"GPU"},"cells":[{"cell_type":"markdown","metadata":{"id":"Aj5xifWZUpFe"},"source":["## **Deep Learning Made Easy**\n","\n","----\n","\n","Author:  <a href=\"https://www.linkedin.com/in/valdivino-alexandre-de-santiago-j%C3%BAnior-103109206/?locale=en_US\">Valdivino Alexandre de Santiago Júnior</a>.\n","\n","<br>\n","\n","**Licence**: GNU GENERAL PUBLIC LICENSE, Version 3 (GPLv3)\n","\n","<br>\n","\n","This is a notebook to demonstrate how easy is to create \"new\" deep neural networks (DNNs) by changing a few lines of code of previously proposed models and, hence, create new architectures. <a href=\"https://github.com/pytorch/vision/blob/main/torchvision/models/vgg.py\">VGG</a> and <a href=\"https://github.com/pytorch/vision/blob/main/torchvision/models/resnet.py\">ResNet</a> deep convolutional neural networks (CNNs) by the PyTorch Team are modified to create two new architectures: VGG12BN and ResNet-14.  \n","\n","<br>\n","\n","To run this notebook in Colab, use the link below:\n","\n","[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/vsantjr/DeepLearningMadeEasy/blob/master/PyTorch_VGG_ResNet_VGGout.ipynb)"]},{"cell_type":"code","metadata":{"id":"USKiDAQzQpLn","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1666093303292,"user_tz":180,"elapsed":29688,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"outputId":"5395bd54-42e9-4d53-bdd6-883fba924967"},"source":["%matplotlib inline\n","from google.colab import drive\n","drive.mount('/content/drive')"],"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}]},{"cell_type":"code","metadata":{"id":"e6tyULOW57g1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1666093304924,"user_tz":180,"elapsed":1637,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"outputId":"702bad8e-73a7-4a04-e0f6-61143e2d9af6"},"source":["# Change to \"root\" directory\n","%cd /content/drive/My Drive/Colab Notebooks/pyTorch/dlme\n","%ls"],"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["/content/drive/My Drive/Colab Notebooks/pyTorch/dlme\n","'BigGAN TF Hub Demo.ipynb'\n"," \u001b[0m\u001b[01;34mceleba\u001b[0m/\n"," CGAN.ipynb\n","'Copy of PyTorch_DCGAN3.ipynb'\n"," densenetmodified.py\n","'DISCIPLINA PyTorch_DCGAN.ipynb'\n","'ESRGAN image_enhancing.ipynb'\n"," GANSynth_Music.ipynb\n","'GMM cluster.ipynb'\n"," hello_nas.ipynb\n"," \u001b[01;34mimagenettetvt320\u001b[0m/\n"," KDE1_Kernel-Density-Estimation.ipynb\n"," KDE2_Kernel-Density-Estimation.ipynb\n"," \u001b[01;34mmaps\u001b[0m/\n"," maps_256.npz\n"," maps.zip\n"," \u001b[01;34mmisc\u001b[0m/\n"," MNIST_optuna_after.ipynb\n"," model_010960.h5\n"," \u001b[01;34mout\u001b[0m/\n"," Pix2Pix.ipynb\n"," plot_010960.png\n"," \u001b[01;34m__pycache__\u001b[0m/\n"," PyTorch_CGAN.ipynb\n"," PyTorch_CIFAR-10.ipynb\n"," PyTorch_CIFAR-10_Profiler.ipynb\n","'PyTorch CIFAR-10_Valdivino Santiago.ipynb'\n","'PyTorch CIFAR-10_Valdivino Santiago_Profiler.ipynb'\n","'PyTorch CIFAR-10_Valdivino SantiagoV2.ipynb'\n"," PyTorch_DCGAN.ipynb\n"," PyTorch_DCGAN_LNCC.ipynb\n"," pytorch-deep-explainer-mnist-example.ipynb\n"," PyTorch_DenseNet.ipynb\n","'PyTorch_Mask R-CNN.ipynb'\n"," PyTorch_MNIST.ipynb\n"," PyTorch_MNIST_Profiler.ipynb\n","'PyTorch MNIST_Valdivino Santiago.ipynb'\n","'PyTorch MNIST_Valdivino Santiago_Profiler.ipynb'\n","'PyTorch MNIST_Valdivino SantiagoV2.ipynb'\n"," PyTorch_PROGAN.ipynb\n","'PyTorch_Semantic Segmentation.ipynb'\n"," PyTorch_SSD-NVIDIA.ipynb\n","'PyTorch_TransferLayer_Inc layers.ipynb'\n"," PyTorch_TransferLayer.ipynb\n"," PyTorch_U-Net.ipynb\n"," PyTorch_VGG_ResNet_ResNetout.ipynb\n"," PyTorch_VGG_ResNet_VGGout.ipynb\n"," resnetmodified.py\n"," Ricardo_DL_UNet_CropExample.ipynb\n","'Spherical Gaussian.ipynb'\n"," StyleGAN3+CLIP.ipynb\n"," TF_CycleGAN.ipynb\n","'TorchvisionMaskRCNN - Simple.ipynb'\n"," \u001b[01;34mtout\u001b[0m/\n"," user_options.txt\n"," vggmodified.py\n"," XAI-Final_ModelComparisonWithSaliency.ipynb\n","'YOLOv5-Custom-Training - Roboflow.ipynb'\n","'YOLOv5 Tutorial - Official.ipynb'\n"]}]},{"cell_type":"markdown","metadata":{"id":"UT5TyIalWS20"},"source":["## **Create directories and unzip the datasets**\n","----\n","\n","Create the following directories under the \"root\" directory:\n","\n","\n","\n","1.   ```imagenettetvt320```. It will contain the <a href=\"https://github.com/fastai/imagenette\">imagenette320 px</a> datasets. However, we split the original validation dataset into two: validation with 1/3 of the images of the original validation set, and 2/3 of the images compose the test dataset; \n","2.   ```out```. It is to store the best model during training and other relevant outputs.\n","\n","<br>\n","\n","After that, run the command below only once to unzip all datasets (training, validation, test). It is assumed that the .zip file (imagenettetvt320.zip) has already been uploaded to the \"root\" Google Drive's directory.\n","\n"]},{"cell_type":"code","metadata":{"id":"1uC_s9K9oOn5","executionInfo":{"status":"ok","timestamp":1666093304925,"user_tz":180,"elapsed":12,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}}},"source":["#!unzip \"/content/drive/My Drive/Colab Notebooks/pyTorch/dlme/imagenettetvt320.zip\" -d \"/content/drive/My Drive/Colab Notebooks/pyTorch/dlme/imagenettetvt320\"\n"],"execution_count":4,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Y6L8yHrA8DkI"},"source":["## **Modified models**\n","----\n","\n","Below, ```vggmodified``` and ```resnetmodified``` are the files with the modifications accomplished to created the two new models. Take a look at them to precisely see the very few modifications which have been made. "]},{"cell_type":"code","metadata":{"id":"U0FcCjo7QpLs","executionInfo":{"status":"ok","timestamp":1666093310065,"user_tz":180,"elapsed":5151,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}}},"source":["from __future__ import print_function, division\n","import matplotlib.pyplot as plt\n","import numpy as np\n","import PIL\n","import torch\n","import torch.nn as nn\n","import torch.optim as optim\n","import sys\n","import os\n","import time\n","import torchvision\n","from torchvision import datasets, transforms # models: out\n","from vggmodified import * # VGG modified\n","from resnetmodified import * # ResNet modified\n","from prettytable import PrettyTable\n","from torch.autograd import Variable\n","plt.ion()   # Interactive mode"],"execution_count":5,"outputs":[]},{"cell_type":"code","metadata":{"id":"JWT4u8Y10iYo","executionInfo":{"status":"ok","timestamp":1666093310066,"user_tz":180,"elapsed":12,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}}},"source":["# This function obtains the number of trainable parameters of the \n","# model/network.\n","def count_parameters(model):\n","    table = PrettyTable([\"Modules\", \"Parameters\"])\n","    total_params = 0\n","    for name, parameter in model.named_parameters():\n","        if not parameter.requires_grad: continue\n","        param = parameter.numel()\n","        table.add_row([name, param])\n","        total_params+=param\n","    print(table)\n","    print(f\"Total trainable params: {total_params}\")\n","    return total_params"],"execution_count":6,"outputs":[]},{"cell_type":"code","metadata":{"id":"7V_8YREq1qoZ","executionInfo":{"status":"ok","timestamp":1666093310066,"user_tz":180,"elapsed":10,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}}},"source":["# Custom dataset that includes image file paths. Extends \n","# torchvision.datasets.ImageFolder\n","class FileNames(datasets.ImageFolder):\n","    \n","    # Override the __getitem__ method. this is the method that dataloader calls\n","    def __getitem__(self, index):\n","        # This is what ImageFolder normally returns \n","        original_tuple = super(FileNames, self).__getitem__(index)\n","        # The image file path\n","        path = self.imgs[index][0]\n","        # Make a new tuple that includes original and the path\n","        tuple_with_path = (original_tuple + (path,))\n","        return tuple_with_path"],"execution_count":7,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"ykP8jMHk0uyy"},"source":["## **Define important variables**\n","----\n","\n","Here, we define the classes and also some hyper-parameters."]},{"cell_type":"code","metadata":{"id":"L_8lSuWnQpLv","executionInfo":{"status":"ok","timestamp":1666093310066,"user_tz":180,"elapsed":9,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}}},"source":["# The directory of the datasets\n","data_dir = '/content/drive/My Drive/Colab Notebooks/pyTorch/dlme/imagenettetvt320'\n","\n","# All relevant outputs are here\n","output_dir = '/content/drive/My Drive/Colab Notebooks/pyTorch/dlme/out' \n","\n","# The number of classes\n","num_classes = 10\n","\n","# Variables related to the selected CNN\n","indic = '' # Indicator of the selected CNN\n","hei_wid = 224 # Images will be cropped to 224 x 224\n","\n","# Hyper-parameters\n","num_epochs = 10 # Number of epochs\n","batch_size = 4 # The size of input data took for one iteration\n","learning_rate = 0.001 # Learning rate\n","moment = 0.9 # Momentum"],"execution_count":8,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"u6m4ROGbedPh"},"source":["## **Select the CNN and load data**\n","----\n","\n","Select the CNN and load data. All images are cropped below to 224 x 224 (variable ```hei_wid```). Moreover, note that dynamic data augmentation and \n","normalisation are used for the training dataset only. For the validation and test datasets, only normalisation.\n","\n","\n","\n","\n","\n"]},{"cell_type":"code","metadata":{"id":"kLu0VHbPnfy5","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1666093337800,"user_tz":180,"elapsed":27743,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"outputId":"27fef10f-37f7-4acd-bcfd-fbe154373cdc"},"source":["print(\"Select the CNN: \")\n","print(\"Press '1' for VGG16BN.\")\n","print(\"Press '2' for VGG19BN.\")\n","print(\"Press '3' for VGG12BN (new).\")\n","print(\"Press '4' for ResNet-18.\")\n","print(\"Press '5' for ResNet-34.\")\n","print(\"Press '6' for ResNet-14 (new).\")\n","opt = input(\"Enter your choice:\")\n","if opt =='1':\n","\tindic = 'VGG16BN'\n","\tprint(\"You selected VGG16BN!\")\n","elif opt =='2':\n","\tindic = 'VGG19BN'\n","\tprint(\"You selected VGG19BN!\")\n","elif opt =='3':\n","\tindic = 'VGG12BN'\n","\tprint(\"You selected VGG12BN (new)!\") \n","elif opt =='4':\n","\tindic = 'ResNet-18'\n","\tprint(\"You selected ResNet-18!\")\n","elif opt =='5':\n","\tindic = 'ResNet-34'\n","\tprint(\"You selected ResNet-34!\") \n","elif opt =='6':\n","  indic = 'ResNet-14'\n","  print(\"You selected ResNet-14 (new)!\")\n","else:\n","  print(\"Invalid Option!\") \n","\n","# File that contains the best model obtained during the training phase\n","best_model_full = output_dir+'/best_model_'+indic+'.pt' \n","\n","# Tranformations for each dataset. Note that dynamic data augmentation and\n","# normalisation are used for the training dataset only. For the validation\n","# and test datasets, only normalisation.\n","data_transforms = {\n","    'train': transforms.Compose([\n","        transforms.RandomResizedCrop(hei_wid),\n","        transforms.RandomHorizontalFlip(),                         \n","        transforms.ToTensor(),\n","        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])\n","    ]),\n","        \n","    'val': transforms.Compose([\n","        transforms.Resize(256),\n","        transforms.CenterCrop(hei_wid),\n","        transforms.ToTensor(),\n","        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])\n","    ]),\n","\n","    'test': transforms.Compose([\n","        transforms.Resize(256),                        \n","        transforms.CenterCrop(hei_wid), \n","        transforms.ToTensor(),\n","        transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])\n","    ])\n","}\n","\n","image_datasets = {x: FileNames(os.path.join(data_dir, x),\n","                                          data_transforms[x])\n","                  for x in ['train', 'val', 'test']}\n","\n","dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size,\n","                                             shuffle=True, num_workers=2)\n","              for x in ['train', 'val', 'test']}\n","\n","dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val', 'test']}\n","\n","# Just checking the sizes\n","print('\\nDataset sizes: ', dataset_sizes)\n","print('Dataloaders sizes: ', len(dataloaders))\n","class_names = image_datasets['train'].classes\n","class_namesv = image_datasets['val'].classes\n","class_namest = image_datasets['test'].classes\n","print('Training classes: ', class_names)\n","print('Training lengths: ', len(class_names))\n","print('Validation classes: ', class_namesv)\n","print('Validation lengths: ', len(class_namesv))\n","print('Test classes: ', class_namest)\n","print('Test lengths: ', len(class_namest))\n","print('Height x Width: {} x {}'.format(hei_wid,hei_wid))\n","\n","device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"],"execution_count":9,"outputs":[{"output_type":"stream","name":"stdout","text":["Select the CNN: \n","Press '1' for VGG16BN.\n","Press '2' for VGG19BN.\n","Press '3' for VGG12BN (new).\n","Press '4' for ResNet-18.\n","Press '5' for ResNet-34.\n","Press '6' for ResNet-14 (new).\n","Enter your choice:3\n","You selected VGG12BN (new)!\n","\n","Dataset sizes:  {'train': 9469, 'val': 1309, 'test': 2616}\n","Dataloaders sizes:  3\n","Training classes:  ['cassetePlayer', 'chainShaw', 'church', 'englishSpringer', 'frenchHorn', 'garbageTruck', 'gasPump', 'golfBall', 'parachute', 'tench']\n","Training lengths:  10\n","Validation classes:  ['cassetePlayer', 'chainSaw', 'church', 'englishSpringer', 'frenchHorn', 'garbageTruck', 'gasPump', 'golfBall', 'parachute', 'tench']\n","Validation lengths:  10\n","Test classes:  ['cassetePlayer', 'chainShaw', 'church', 'englishSpringer', 'frenchHorn', 'garbageTruck', 'gasPump', 'golfBall', 'parachute', 'tench']\n","Test lengths:  10\n","Height x Width: 224 x 224\n"]}]},{"cell_type":"code","metadata":{"id":"zBEkaKDFPMo8","colab":{"base_uri":"https://localhost:8080/","height":674},"executionInfo":{"status":"ok","timestamp":1666093342397,"user_tz":180,"elapsed":4603,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"outputId":"41fbc86a-aabf-457e-9ef7-a7aaa247cb1f"},"source":["# Just visualising some images\n","def visualise_images(img):\n","    img = img / 2 + 0.5     # Unnormalize\n","    npimg = img.numpy()\n","    plt.imshow(np.transpose(npimg, (1, 2, 0)))\n","    plt.show()\n","\n","\n","# Get a batch: training dataset\n","dataiter = iter(dataloaders['train'])\n","images, labels, paths = dataiter.next()\n","print('One batch - training dataset:', images.shape)\n","\n","print('\\nEach image of the batch:')\n","for i in range(labels.shape[0]):\n","  print('Image: {} - Input shape: {} - Class: {}'.format(i, images[i].shape, image_datasets['train'].classes[labels[i]]))\n","  if i == (labels.shape[0]-1):\n","    print('The \"image\" itself: ', images[i])\n","\n","# Show images\n","visualise_images(torchvision.utils.make_grid(images))\n","# Print labels\n","print(' - '.join('%5s' % image_datasets['train'].classes[labels[j]] for j in range(batch_size)))"],"execution_count":10,"outputs":[{"output_type":"stream","name":"stdout","text":["One batch - training dataset: torch.Size([4, 3, 224, 224])\n","\n","Each image of the batch:\n","Image: 0 - Input shape: torch.Size([3, 224, 224]) - Class: cassetePlayer\n","Image: 1 - Input shape: torch.Size([3, 224, 224]) - Class: gasPump\n","Image: 2 - Input shape: torch.Size([3, 224, 224]) - Class: frenchHorn\n","Image: 3 - Input shape: torch.Size([3, 224, 224]) - Class: cassetePlayer\n","The \"image\" itself:  tensor([[[-0.5373, -0.5137, -0.4745,  ...,  0.7569,  0.7490,  0.7569],\n","         [-0.4902, -0.4824, -0.4039,  ...,  0.7569,  0.7490,  0.7490],\n","         [-0.3098, -0.2863, -0.2078,  ...,  0.7961,  0.7725,  0.7569],\n","         ...,\n","         [ 0.2157,  0.2235,  0.2392,  ...,  0.3333,  0.3255,  0.3176],\n","         [ 0.1843,  0.1843,  0.1922,  ...,  0.3255,  0.3255,  0.3176],\n","         [ 0.1373,  0.1294,  0.1608,  ...,  0.2863,  0.2941,  0.2941]],\n","\n","        [[-0.6392, -0.6078, -0.5137,  ...,  0.7882,  0.7804,  0.7882],\n","         [-0.5686, -0.5686, -0.4196,  ...,  0.7804,  0.7725,  0.7725],\n","         [-0.3882, -0.3804, -0.2000,  ...,  0.8118,  0.7882,  0.7725],\n","         ...,\n","         [-0.1843, -0.1765, -0.1294,  ..., -0.0275, -0.0353, -0.0431],\n","         [-0.2392, -0.2392, -0.1922,  ..., -0.0510, -0.0510, -0.0588],\n","         [-0.2941, -0.2941, -0.2549,  ..., -0.1059, -0.0980, -0.0980]],\n","\n","        [[-0.7176, -0.6706, -0.5373,  ...,  0.8118,  0.8039,  0.8118],\n","         [-0.6000, -0.5765, -0.4196,  ...,  0.8353,  0.8196,  0.8196],\n","         [-0.3569, -0.3255, -0.1765,  ...,  0.8745,  0.8588,  0.8431],\n","         ...,\n","         [-0.6471, -0.6392, -0.6392,  ..., -0.5529, -0.5608, -0.5686],\n","         [-0.6863, -0.6863, -0.7020,  ..., -0.5922, -0.5922, -0.6000],\n","         [-0.7569, -0.7569, -0.7882,  ..., -0.6706, -0.6627, -0.6627]]])\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}},{"output_type":"stream","name":"stdout","text":["cassetePlayer - gasPump - frenchHorn - cassetePlayer\n"]}]},{"cell_type":"markdown","metadata":{"id":"WwlB-OqOP_1e"},"source":["## **Instantiate the selected CNN**\n","----\n","\n","Now, we instantiate the previous selected CNN.\n"]},{"cell_type":"code","metadata":{"id":"s604GV_vQpL7","executionInfo":{"status":"ok","timestamp":1666093347465,"user_tz":180,"elapsed":5072,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}}},"source":["# ResNet: Number of input features for the last layer (fully-connected)\n","num_ftrs = -1 \n","if opt =='1':\n","  net = vgg16_bn()\n","elif opt =='2':\n","  net = vgg19_bn()\n","elif opt =='3':\n","  net = vgg12_bn()\n","elif opt =='4':\n","  net = resnet18()\n","  num_ftrs = net.fc.in_features\n","  print('Input features - ResNet-18:', num_ftrs) \n","  net.fc = nn.Linear(num_ftrs, num_classes)\n","elif opt =='5':\n","  net = resnet34()\n","  num_ftrs = net.fc.in_features\n","  print('Input features - ResNet-34:', num_ftrs)\n","  net.fc = nn.Linear(num_ftrs, num_classes)\n","elif opt =='6':\n","  net = resnet14()\n","  num_ftrs = net.fc.in_features\n","  print('Input features - ResNet-14:', num_ftrs)\n","  net.fc = nn.Linear(num_ftrs, num_classes)  \n","else:\n","  print(\"Invalid Option!\")\n","     \n","net = net.to(device)"],"execution_count":11,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Z0j7VfK14k44"},"source":["## **Define loss function and optimiser**\n","\n","----\n","\n","The <a href=\"https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html\">CrossEntropyLoss</a> function combines LogSoftmax and NLLLoss in one single class. Optimiser is SGD, the learning rate and momentum have already been defined."]},{"cell_type":"code","metadata":{"id":"8v-8sAja0Xy_","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1666093347465,"user_tz":180,"elapsed":16,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"outputId":"52157fc3-8044-4d44-88a9-c966b44deab8"},"source":["# Cross-entropy Loss\n","loss_function = nn.CrossEntropyLoss()\n","\n","# All parameters are being optimised\n","optimiser = optim.SGD(net.parameters(), lr=learning_rate, momentum=moment)\n","\n","print('Checking trainable parameters: {}'.format(count_parameters(net)))"],"execution_count":12,"outputs":[{"output_type":"stream","name":"stdout","text":["+---------------------+------------+\n","|       Modules       | Parameters |\n","+---------------------+------------+\n","|  features.0.weight  |    1728    |\n","|   features.0.bias   |     64     |\n","|  features.1.weight  |     64     |\n","|   features.1.bias   |     64     |\n","|  features.3.weight  |   36864    |\n","|   features.3.bias   |     64     |\n","|  features.4.weight  |     64     |\n","|   features.4.bias   |     64     |\n","|  features.7.weight  |   73728    |\n","|   features.7.bias   |    128     |\n","|  features.8.weight  |    128     |\n","|   features.8.bias   |    128     |\n","|  features.10.weight |   147456   |\n","|   features.10.bias  |    128     |\n","|  features.11.weight |    128     |\n","|   features.11.bias  |    128     |\n","|  features.14.weight |   294912   |\n","|   features.14.bias  |    256     |\n","|  features.15.weight |    256     |\n","|   features.15.bias  |    256     |\n","|  features.17.weight |   589824   |\n","|   features.17.bias  |    256     |\n","|  features.18.weight |    256     |\n","|   features.18.bias  |    256     |\n","|  features.21.weight |  1179648   |\n","|   features.21.bias  |    512     |\n","|  features.22.weight |    512     |\n","|   features.22.bias  |    512     |\n","|  features.24.weight |  2359296   |\n","|   features.24.bias  |    512     |\n","|  features.25.weight |    512     |\n","|   features.25.bias  |    512     |\n","|  features.27.weight |  2359296   |\n","|   features.27.bias  |    512     |\n","|  features.28.weight |    512     |\n","|   features.28.bias  |    512     |\n","| classifier.0.weight | 102760448  |\n","|  classifier.0.bias  |    4096    |\n","| classifier.3.weight |  16777216  |\n","|  classifier.3.bias  |    4096    |\n","| classifier.6.weight |   40960    |\n","|  classifier.6.bias  |     10     |\n","+---------------------+------------+\n","Total trainable params: 126636874\n","Checking trainable parameters: 126636874\n"]}]},{"cell_type":"markdown","metadata":{"id":"_57Wdpy9y9AA"},"source":["## **Run the Training Phase**\n","----\n","\n","Now, we can run the training phase. \n","\n"]},{"cell_type":"code","metadata":{"id":"f4PhqdBkQpL-","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1666099721375,"user_tz":180,"elapsed":6373924,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"outputId":"7f138865-79a3-465f-8f6c-f9a7536d0a80"},"source":["train_losses = []\n","train_acc = []\n","val_losses = []\n","val_acc = []\n","best_loss_validation = sys.float_info.max\n","best_epoch = sys.float_info.max\n","train_time_init = time.time()\n","#### Main training loop: Begin\n","for epoch in range(num_epochs):\n","  #### Each epoch has a training and validation phase: Begin\n","  for phase in ['train', 'val']:\n","    if phase == 'train':\n","      net.train() # Set model to training mode\n","    else:\n","      net.eval()  # Set model to evaluate mode\n","   \n","    running_loss = 0.0\n","    running_corrects = 0\n","    # Iterate over data: Begin\n","    for images, labels, paths in dataloaders[phase]: \n","      images = Variable(images).to(device) # Send to GPU\n","      labels = Variable(labels).to(device) # Send to GPU\n","    \n","      optimiser.zero_grad()\n","      with torch.set_grad_enabled(phase == 'train'):\n","        outputs = net(images)\n","        _, preds = torch.max(outputs, 1)\n","        loss = loss_function(outputs, labels)\n","        \n","        # Backward + optimise only if in training phase. \n","        if phase == 'train':\n","          loss.backward()\n","          optimiser.step()\n","    \n","      running_loss += loss.item() * images.size(0)\n","      running_corrects += torch.sum(preds == labels.data)\n","    # Iterate over data: End\n","\n","    epoch_loss = running_loss / dataset_sizes[phase]\n","    epoch_acc = running_corrects.double() / dataset_sizes[phase] \n","    print('Phase: {}, Epoch {}/{}, Loss: {:.4f}, Accuracy: {:.4f}'.format(\n","                 phase, epoch+1, num_epochs, epoch_loss, epoch_acc))\n","    \n","    if phase == 'train': # Training\n","      train_losses.append(epoch_loss)\n","      train_acc.append(epoch_acc.cpu()) \n","    else: # Validation\n","      val_losses.append(epoch_loss)\n","      val_acc.append(epoch_acc.cpu()) \n","      if (epoch_loss < best_loss_validation):\n","        best_loss_validation = epoch_loss\n","        best_epoch = epoch + 1\n","        if os.path.exists(best_model_full):\n","          os.remove(best_model_full)\n","          print('####### Validation loss: previous best model removed!!!!')\n","        else:\n","          print(\"####### Validation loss: there is no saved model yet!!!!\")\n","        torch.save(net.state_dict(), best_model_full)\n","        print('####### Validation loss: new best model saved in Epoch: {} !!!!'.format(str(epoch + 1)))\n","  #### Each epoch has a training and validation phase: End\n","#### Main training loop: End\n","train_time_end = time.time() - train_time_init"],"execution_count":13,"outputs":[{"output_type":"stream","name":"stdout","text":["Phase: train, Epoch 1/10, Loss: 2.2856, Accuracy: 0.1967\n","Phase: val, Epoch 1/10, Loss: 1.9887, Accuracy: 0.3010\n","####### Validation loss: there is no saved model yet!!!!\n","####### Validation loss: new best model saved in Epoch: 1 !!!!\n","Phase: train, Epoch 2/10, Loss: 2.0806, Accuracy: 0.2578\n","Phase: val, Epoch 2/10, Loss: 1.9605, Accuracy: 0.3430\n","####### Validation loss: previous best model removed!!!!\n","####### Validation loss: new best model saved in Epoch: 2 !!!!\n","Phase: train, Epoch 3/10, Loss: 2.0105, Accuracy: 0.2911\n","Phase: val, Epoch 3/10, Loss: 1.7712, Accuracy: 0.4163\n","####### Validation loss: previous best model removed!!!!\n","####### Validation loss: new best model saved in Epoch: 3 !!!!\n","Phase: train, Epoch 4/10, Loss: 1.9171, Accuracy: 0.3368\n","Phase: val, Epoch 4/10, Loss: 1.7401, Accuracy: 0.4041\n","####### Validation loss: previous best model removed!!!!\n","####### Validation loss: new best model saved in Epoch: 4 !!!!\n","Phase: train, Epoch 5/10, Loss: 1.8540, Accuracy: 0.3575\n","Phase: val, Epoch 5/10, Loss: 1.8211, Accuracy: 0.4278\n","Phase: train, Epoch 6/10, Loss: 1.7843, Accuracy: 0.3849\n","Phase: val, Epoch 6/10, Loss: 1.5166, Accuracy: 0.5180\n","####### Validation loss: previous best model removed!!!!\n","####### Validation loss: new best model saved in Epoch: 6 !!!!\n","Phase: train, Epoch 7/10, Loss: 1.7032, Accuracy: 0.4238\n","Phase: val, Epoch 7/10, Loss: 1.6268, Accuracy: 0.4912\n","Phase: train, Epoch 8/10, Loss: 1.6355, Accuracy: 0.4434\n","Phase: val, Epoch 8/10, Loss: 1.3099, Accuracy: 0.5752\n","####### Validation loss: previous best model removed!!!!\n","####### Validation loss: new best model saved in Epoch: 8 !!!!\n","Phase: train, Epoch 9/10, Loss: 1.5567, Accuracy: 0.4854\n","Phase: val, Epoch 9/10, Loss: 1.2334, Accuracy: 0.6104\n","####### Validation loss: previous best model removed!!!!\n","####### Validation loss: new best model saved in Epoch: 9 !!!!\n","Phase: train, Epoch 10/10, Loss: 1.4800, Accuracy: 0.5191\n","Phase: val, Epoch 10/10, Loss: 1.1963, Accuracy: 0.6142\n","####### Validation loss: previous best model removed!!!!\n","####### Validation loss: new best model saved in Epoch: 10 !!!!\n"]}]},{"cell_type":"markdown","metadata":{"id":"W7ULwn9_3OBd"},"source":["## **Training phase: results**\n","----\n","\n","Just showing the loss and accuracy during the training phase: training and validation datasets."]},{"cell_type":"code","metadata":{"id":"ju6gMaj2uVZ9","colab":{"base_uri":"https://localhost:8080/","height":573},"executionInfo":{"status":"ok","timestamp":1666099722890,"user_tz":180,"elapsed":1518,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"outputId":"23b6288e-e074-4575-c44d-06d97d9b0f60"},"source":["x = range(1,len(train_losses)+1)\n","\n","plt.figure(figsize=(8,4))\n","plt.title(\"Training Phase: Loss\")\n","plt.plot(x,train_losses,label=\"Train\")\n","plt.plot(x,val_losses,label=\"Val\")\n","plt.xticks(range(1,len(x)+1))\n","plt.xlabel(\"Epochs\")\n","plt.ylabel(\"Loss\")\n","plt.legend()\n","plt.savefig(f\"{output_dir}/training_loss_\"+indic+\".png\")\n","plt.show()\n","\n","plt.figure(figsize=(8,4))\n","plt.title(\"Training Phase: Accuracy\")\n","plt.plot(x,train_acc,label=\"Train\")\n","plt.plot(x,val_acc,label=\"Val\")\n","plt.xticks(range(1,len(x)+1))\n","plt.xlabel(\"Epochs\")\n","plt.ylabel(\"Accuracy\")\n","plt.legend()\n","plt.savefig(f\"{output_dir}/training_acc_\"+indic+\".png\")\n","plt.show()"],"execution_count":14,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 576x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}},{"output_type":"display_data","data":{"text/plain":["<Figure size 576x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"JZCuo3XMuxTF"},"source":["## **Load the model**\n","----\n","\n","You can load your best model to use in the inference phase. "]},{"cell_type":"code","metadata":{"id":"Gj9zs93luzVX","executionInfo":{"status":"ok","timestamp":1666100740038,"user_tz":180,"elapsed":3666,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"colab":{"base_uri":"https://localhost:8080/"},"outputId":"b89bd154-c2c6-4f13-9e90-7b5faadb1ea3"},"source":["if opt =='1':\n","  net = vgg16_bn()\n","elif opt =='2':\n","  net = vgg19_bn()\n","elif opt =='3':\n","  net = vgg12_bn()\n","elif opt =='4':\n","  net = resnet18()\n","  net.fc = nn.Linear(num_ftrs, num_classes)\n","elif opt =='5':\n","  net = resnet34()\n","  net.fc = nn.Linear(num_ftrs, num_classes)\n","elif opt =='6':\n","  net = resnet14()\n","  net.fc = nn.Linear(num_ftrs, num_classes)\n","else:\n","  print(\"Invalid Option!\")\n","     \n","net = net.to(device)\n","net.load_state_dict(torch.load(best_model_full))\n","#net.load_state_dict(torch.load(best_model_full, map_location=torch.device('cpu')))\n","print(\"Best {} model loaded!\".format(indic))"],"execution_count":17,"outputs":[{"output_type":"stream","name":"stdout","text":["Best VGG12BN model loaded!\n"]}]},{"cell_type":"markdown","metadata":{"id":"2caCiV5P4bZb"},"source":["## **Inference phase**\n","\n","----\n","\n","In the inference phase, we measure the performance of our model based on the test dataset. \n"]},{"cell_type":"code","metadata":{"id":"ubywwcgWef5v","executionInfo":{"status":"ok","timestamp":1666100905404,"user_tz":180,"elapsed":162857,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}},"colab":{"base_uri":"https://localhost:8080/"},"outputId":"41479e3f-e256-4cba-a95f-5672c73c5ad5"},"source":["am_training = net.training\n","print('Am I training? ', am_training)\n","net.eval()\n","am_training = net.training\n","print('Am I training? ', am_training)\n","inference_loss = 0.0\n","inference_corrects = 0\n","phase = 'test'\n","\n","infer_time_init = time.time()\n","with torch.no_grad():\n","  # Iterate over data: Begin\n","  for images, labels, paths in dataloaders[phase]: \n","      images = Variable(images).to(device) # Send to GPU\n","      labels = Variable(labels).to(device) # Send to GPU\n","\n","      outputs_infer = net(images)\n","      _, preds_infer = torch.max(outputs_infer,1)\n","      loss_infer = loss_function(outputs_infer, labels)\n","\n","      inference_loss += loss_infer.item() * images.size(0)\n","      inference_corrects += torch.sum(preds_infer == labels.data)\n","  # Iterate over data: End\n","\n","final_inference_loss = inference_loss / dataset_sizes[phase]\n","final_inference_acc = inference_corrects.double() / dataset_sizes[phase]\n","\n","infer_time_end = time.time() - infer_time_init\n","print('\\nTraining and inference in {:.0f}m {:.0f}s  OR  {:.0f}s'.format(\n","        (train_time_end + infer_time_end) // 60, \n","        (train_time_end + infer_time_end) % 60,\n","         train_time_end + infer_time_end))\n","\n","print('\\nLoss of {}: {:.4f}'.format(indic, final_inference_loss))\n","print()\n","print('Accuracy of {}: {:.4f}'.format(indic, final_inference_acc))"],"execution_count":18,"outputs":[{"output_type":"stream","name":"stdout","text":["Am I training?  True\n","Am I training?  False\n","\n","Training and inference in 108m 56s  OR  6536s\n","\n","Loss of VGG12BN: 1.1845\n","\n","Accuracy of VGG12BN: 0.6468\n"]}]},{"cell_type":"code","metadata":{"id":"BZO93xAVygtA","executionInfo":{"status":"ok","timestamp":1666101152911,"user_tz":180,"elapsed":453,"user":{"displayName":"Edilene Santiago","userId":"06530542736679196152"}}},"source":["plt.ioff()"],"execution_count":19,"outputs":[]}]}