pytorch_ipynb/cnn/cnn-vgg16-celeba.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UEBilEjLj5wY"
   },
   "source": [
    "Deep Learning Models -- A collection of various deep learning architectures, models, and tips for TensorFlow and PyTorch in Jupyter Notebooks.\n",
    "- Author: Sebastian Raschka\n",
    "- GitHub Repository: https://github.com/rasbt/deeplearning-models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 119
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 536,
     "status": "ok",
     "timestamp": 1524974472601,
     "user": {
      "displayName": "Sebastian Raschka",
      "photoUrl": "//lh6.googleusercontent.com/-cxK6yOSQ6uE/AAAAAAAAAAI/AAAAAAAAIfw/P9ar_CHsKOQ/s50-c-k-no/photo.jpg",
      "userId": "118404394130788869227"
     },
     "user_tz": 240
    },
    "id": "GOzuY8Yvj5wb",
    "outputId": "c19362ce-f87a-4cc2-84cc-8d7b4b9e6007"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Author: Sebastian Raschka\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.8.12\n",
      "IPython version      : 8.0.1\n",
      "\n",
      "torch: 1.10.1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -a 'Sebastian Raschka' -v -p torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MEu9MiOxj5wk"
   },
   "source": [
    "- Runs on CPU (not recommended here) or GPU (if available)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rH4XmErYj5wm"
   },
   "source": [
    "# Model Zoo -- CNN Smile Classifier (VGG16 Architecture, CelebA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implementation of the VGG-16 [1] architecture on the CelebA face dataset [2] to train a smile classifier.  \n",
    "\n",
    "\n",
    "References\n",
    "    \n",
    "- [1] Simonyan, K., & Zisserman, A. (2014). Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556.\n",
    "- [2] Zhang, K., Tan, L., Li, Z., & Qiao, Y. (2016). Gender and smile classification using deep convolutional neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops (pp. 34-38).\n",
    "\n",
    "\n",
    "The following table (taken from Simonyan & Zisserman referenced above) summarizes the VGG19 architecture:\n",
    "\n",
    "![](../images/vgg16/vgg16-arch-table.png)\n",
    "\n",
    "**Note that the CelebA images are 218 x 178, not 256 x 256. We resize to 128x128**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## General settings and hyperparameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Here, we specify some general hyperparameter values and general settings\n",
    "- Note that for small datatsets, it is not necessary and better not to use multiple workers as it can sometimes cause issues with too many open files in PyTorch. So, if you have problems with the data loader later, try setting `NUM_WORKERS = 0` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 256\n",
    "NUM_EPOCHS = 25\n",
    "LEARNING_RATE = 0.001\n",
    "NUM_WORKERS = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MkoGLH_Tj5wn"
   },
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "ORj09gnrj5wp"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "from torchvision import datasets\n",
    "from torchvision import transforms\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from PIL import Image\n",
    "\n",
    "\n",
    "if torch.cuda.is_available():\n",
    "    torch.backends.cudnn.deterministic = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the approx. 200,000 CelebA face image dataset is relatively large (approx. 1.3 Gb). If the following automatic download below does not work (e.g., returning a `BadZipFile: File is not a zip file` error), this is usually to rate limit restrictions by the provider hosting the dataset. You can try to download the dataset manually via the download link provided by the author on the official CelebA website at http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html. \n",
    "\n",
    "Alternatively, you can download the dataset from here: https://drive.google.com/file/d/1m8-EBPgi5MRubrm6iQjafK2QMHDBMSfJ/view?. \n",
    "1. Delete the existing `celeba` folder with the partially downloaded files.\n",
    "2. Place the .zip file in the same directory as this notebook, then unzip it.\n",
    "3. The new `celeba` folder should contain the following files:\n",
    "\n",
    "![](./images/celeba-files.png)\n",
    "\n",
    "4. Unzip the `celeba/img_align.celeba.zip` archive inside the `celeba` folder\n",
    "5. Call the `get_dataloaders_celeba` below with `download=False`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "##########################\n",
    "### Dataset\n",
    "##########################\n",
    "\n",
    "\n",
    "custom_transforms = transforms.Compose([\n",
    "    transforms.CenterCrop((160, 160)),\n",
    "    transforms.Resize([128, 128]),\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "])\n",
    "\n",
    "\n",
    "def get_dataloaders_celeba(batch_size, num_workers=0,\n",
    "                           train_transforms=None,\n",
    "                           test_transforms=None,\n",
    "                           download=True):\n",
    "\n",
    "    if train_transforms is None:\n",
    "        train_transforms = transforms.ToTensor()\n",
    "\n",
    "    if test_transforms is None:\n",
    "        test_transforms = transforms.ToTensor()\n",
    "        \n",
    "    get_smile = lambda attr: attr[31]\n",
    "\n",
    "    train_dataset = datasets.CelebA(root='.',\n",
    "                                    split='train',\n",
    "                                    transform=train_transforms,\n",
    "                                    target_type='attr',\n",
    "                                    target_transform=get_smile,\n",
    "                                    download=download)\n",
    "\n",
    "    valid_dataset = datasets.CelebA(root='.',\n",
    "                                    split='valid',\n",
    "                                    target_type='attr',\n",
    "                                    target_transform=get_smile,\n",
    "                                    transform=test_transforms)\n",
    "\n",
    "    test_dataset = datasets.CelebA(root='.',\n",
    "                                   split='test',\n",
    "                                   target_type='attr',\n",
    "                                   target_transform=get_smile,\n",
    "                                   transform=test_transforms)\n",
    "\n",
    "\n",
    "    train_loader = DataLoader(dataset=train_dataset,\n",
    "                              batch_size=batch_size,\n",
    "                              num_workers=num_workers,\n",
    "                              shuffle=True)\n",
    "\n",
    "    valid_loader = DataLoader(dataset=test_dataset,\n",
    "                             batch_size=batch_size,\n",
    "                             num_workers=num_workers,\n",
    "                             shuffle=False)\n",
    "    \n",
    "    test_loader = DataLoader(dataset=test_dataset,\n",
    "                             batch_size=batch_size,\n",
    "                             num_workers=num_workers,\n",
    "                             shuffle=False)\n",
    "\n",
    "    return train_loader, valid_loader, test_loader\n",
    "\n",
    "\n",
    "train_loader, valid_loader, test_loader = get_dataloaders_celeba(\n",
    "    batch_size=BATCH_SIZE,\n",
    "    train_transforms=custom_transforms,\n",
    "    test_transforms=custom_transforms,\n",
    "    download=False,\n",
    "    num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the target vectors of the CelebA datasets are vectors containing 40 attributes: \n",
    "    \n",
    "```\n",
    "    00 - 5_o_Clock_Shadow\n",
    "    01 - Arched_Eyebrows\n",
    "    02 - Attractive \n",
    "    03 - Bags_Under_Eyes\n",
    "    04 - Bald\n",
    "    05 - Bangs\n",
    "    06 - Big_Lips\n",
    "    07 - Big_Nose\n",
    "    08 - Black_Hair\n",
    "    09 - Blond_Hair\n",
    "    10 - Blurry \n",
    "    11 - Brown_Hair \n",
    "    12 - Bushy_Eyebrows \n",
    "    13 - Chubby \n",
    "    14 - Double_Chin \n",
    "    15 - Eyeglasses \n",
    "    16 - Goatee \n",
    "    17 - Gray_Hair \n",
    "    18 - Heavy_Makeup \n",
    "    19 - High_Cheekbones \n",
    "    20 - Male \n",
    "    21 - Mouth_Slightly_Open \n",
    "    22 - Mustache \n",
    "    23 - Narrow_Eyes \n",
    "    24 - No_Beard \n",
    "    25 - Oval_Face \n",
    "    26 - Pale_Skin \n",
    "    27 - Pointy_Nose \n",
    "    28 - Receding_Hairline \n",
    "    29 - Rosy_Cheeks \n",
    "    30 - Sideburns \n",
    "    31 - Smiling \n",
    "    32 - Straight_Hair \n",
    "    33 - Wavy_Hair \n",
    "    34 - Wearing_Earrings \n",
    "    35 - Wearing_Hat \n",
    "    36 - Wearing_Lipstick \n",
    "    37 - Wearing_Necklace \n",
    "    38 - Wearing_Necktie \n",
    "    39 - Young      \n",
    "```\n",
    "\n",
    "Via the custom `get_smile` function above [31], we fetched the Smiling label."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I6hghKPxj5w0"
   },
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 23936,
     "status": "ok",
     "timestamp": 1524974497505,
     "user": {
      "displayName": "Sebastian Raschka",
      "photoUrl": "//lh6.googleusercontent.com/-cxK6yOSQ6uE/AAAAAAAAAAI/AAAAAAAAIfw/P9ar_CHsKOQ/s50-c-k-no/photo.jpg",
      "userId": "118404394130788869227"
     },
     "user_tz": 240
    },
    "id": "NnT0sZIwj5wu",
    "outputId": "55aed925-d17e-4c6a-8c71-0d9b3bde5637"
   },
   "outputs": [],
   "source": [
    "##########################\n",
    "### SETTINGS\n",
    "##########################\n",
    "\n",
    "# Device\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Hyperparameters\n",
    "random_seed = 1\n",
    "learning_rate = 0.001\n",
    "num_epochs = 3\n",
    "\n",
    "# Architecture\n",
    "num_features = 128*128\n",
    "num_classes = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "_lza9t_uj5w1"
   },
   "outputs": [],
   "source": [
    "##########################\n",
    "### MODEL\n",
    "##########################\n",
    "\n",
    "\n",
    "class VGG16(torch.nn.Module):\n",
    "\n",
    "    def __init__(self, num_features, num_classes):\n",
    "        super(VGG16, self).__init__()\n",
    "        \n",
    "        # calculate same padding:\n",
    "        # (w - k + 2*p)/s + 1 = o\n",
    "        # => p = (s(o-1) - w + k)/2\n",
    "        \n",
    "        self.block_1 = nn.Sequential(\n",
    "                nn.Conv2d(in_channels=3,\n",
    "                          out_channels=64,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          # (1(32-1)- 32 + 3)/2 = 1\n",
    "                          padding=1), \n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(in_channels=64,\n",
    "                          out_channels=64,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                             stride=(2, 2))\n",
    "        )\n",
    "        \n",
    "        self.block_2 = nn.Sequential(\n",
    "                nn.Conv2d(in_channels=64,\n",
    "                          out_channels=128,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(in_channels=128,\n",
    "                          out_channels=128,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                             stride=(2, 2))\n",
    "        )\n",
    "        \n",
    "        self.block_3 = nn.Sequential(        \n",
    "                nn.Conv2d(in_channels=128,\n",
    "                          out_channels=256,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(in_channels=256,\n",
    "                          out_channels=256,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),        \n",
    "                nn.Conv2d(in_channels=256,\n",
    "                          out_channels=256,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(in_channels=256,\n",
    "                          out_channels=256,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                             stride=(2, 2))\n",
    "        )\n",
    "        \n",
    "          \n",
    "        self.block_4 = nn.Sequential(   \n",
    "                nn.Conv2d(in_channels=256,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),        \n",
    "                nn.Conv2d(in_channels=512,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),        \n",
    "                nn.Conv2d(in_channels=512,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(in_channels=512,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),   \n",
    "                nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                             stride=(2, 2))\n",
    "        )\n",
    "        \n",
    "        self.block_5 = nn.Sequential(\n",
    "                nn.Conv2d(in_channels=512,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),            \n",
    "                nn.Conv2d(in_channels=512,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),            \n",
    "                nn.Conv2d(in_channels=512,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),\n",
    "                nn.Conv2d(in_channels=512,\n",
    "                          out_channels=512,\n",
    "                          kernel_size=(3, 3),\n",
    "                          stride=(1, 1),\n",
    "                          padding=1),\n",
    "                nn.ReLU(),   \n",
    "                nn.MaxPool2d(kernel_size=(2, 2),\n",
    "                             stride=(2, 2))             \n",
    "        )\n",
    "        \n",
    "        self.classifier = nn.Sequential(\n",
    "                nn.Linear(512*4*4, 4096),\n",
    "                nn.ReLU(),   \n",
    "                nn.Linear(4096, 4096),\n",
    "                nn.ReLU(),\n",
    "                nn.Linear(4096, num_classes)\n",
    "        )\n",
    "            \n",
    "        \n",
    "        for m in self.modules():\n",
    "            if isinstance(m, torch.nn.Conv2d):\n",
    "                #n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n",
    "                #m.weight.data.normal_(0, np.sqrt(2. / n))\n",
    "                m.weight.detach().normal_(0, 0.05)\n",
    "                if m.bias is not None:\n",
    "                    m.bias.detach().zero_()\n",
    "            elif isinstance(m, torch.nn.Linear):\n",
    "                m.weight.detach().normal_(0, 0.05)\n",
    "                m.bias.detach().detach().zero_()\n",
    "        \n",
    "        \n",
    "    def forward(self, x):\n",
    "\n",
    "        x = self.block_1(x)\n",
    "        x = self.block_2(x)\n",
    "        x = self.block_3(x)\n",
    "        x = self.block_4(x)\n",
    "        x = self.block_5(x)\n",
    "\n",
    "        logits = self.classifier(x.view(-1, 512*4*4))\n",
    "        probas = F.softmax(logits, dim=1)\n",
    "\n",
    "        return logits, probas\n",
    "\n",
    "    \n",
    "torch.manual_seed(random_seed)\n",
    "model = VGG16(num_features=num_features,\n",
    "              num_classes=num_classes)\n",
    "\n",
    "model = model.to(device)\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RAodboScj5w6"
   },
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 1547
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2384585,
     "status": "ok",
     "timestamp": 1524976888520,
     "user": {
      "displayName": "Sebastian Raschka",
      "photoUrl": "//lh6.googleusercontent.com/-cxK6yOSQ6uE/AAAAAAAAAAI/AAAAAAAAIfw/P9ar_CHsKOQ/s50-c-k-no/photo.jpg",
      "userId": "118404394130788869227"
     },
     "user_tz": 240
    },
    "id": "Dzh3ROmRj5w7",
    "outputId": "5f8fd8c9-b076-403a-b0b7-fd2d498b48d7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 001/003 | Batch 0000/0636 | Cost: 5911.8281\n",
      "Epoch: 001/003 | Batch 0050/0636 | Cost: 0.6971\n",
      "Epoch: 001/003 | Batch 0100/0636 | Cost: 0.6431\n",
      "Epoch: 001/003 | Batch 0150/0636 | Cost: 0.5499\n",
      "Epoch: 001/003 | Batch 0200/0636 | Cost: 0.4563\n",
      "Epoch: 001/003 | Batch 0250/0636 | Cost: 0.3367\n",
      "Epoch: 001/003 | Batch 0300/0636 | Cost: 0.3535\n",
      "Epoch: 001/003 | Batch 0350/0636 | Cost: 0.2126\n",
      "Epoch: 001/003 | Batch 0400/0636 | Cost: 0.3210\n",
      "Epoch: 001/003 | Batch 0450/0636 | Cost: 0.2475\n",
      "Epoch: 001/003 | Batch 0500/0636 | Cost: 0.2211\n",
      "Epoch: 001/003 | Batch 0550/0636 | Cost: 0.3318\n",
      "Epoch: 001/003 | Batch 0600/0636 | Cost: 0.2987\n",
      "Epoch: 001/003 | Train: 88.431% | Valid: 88.363%\n",
      "Time elapsed: 34.48 min\n",
      "Epoch: 002/003 | Batch 0000/0636 | Cost: 0.2720\n",
      "Epoch: 002/003 | Batch 0050/0636 | Cost: 0.2869\n",
      "Epoch: 002/003 | Batch 0100/0636 | Cost: 0.2454\n",
      "Epoch: 002/003 | Batch 0150/0636 | Cost: 0.2355\n",
      "Epoch: 002/003 | Batch 0200/0636 | Cost: 0.2351\n",
      "Epoch: 002/003 | Batch 0250/0636 | Cost: 0.1884\n",
      "Epoch: 002/003 | Batch 0300/0636 | Cost: 0.2546\n",
      "Epoch: 002/003 | Batch 0350/0636 | Cost: 0.2552\n",
      "Epoch: 002/003 | Batch 0400/0636 | Cost: 0.2022\n",
      "Epoch: 002/003 | Batch 0450/0636 | Cost: 0.2270\n",
      "Epoch: 002/003 | Batch 0500/0636 | Cost: 0.2203\n",
      "Epoch: 002/003 | Batch 0550/0636 | Cost: 0.2608\n",
      "Epoch: 002/003 | Batch 0600/0636 | Cost: 0.2683\n",
      "Epoch: 002/003 | Train: 90.173% | Valid: 89.771%\n",
      "Time elapsed: 68.96 min\n",
      "Epoch: 003/003 | Batch 0000/0636 | Cost: 0.2337\n",
      "Epoch: 003/003 | Batch 0050/0636 | Cost: 0.1952\n",
      "Epoch: 003/003 | Batch 0100/0636 | Cost: 0.2413\n",
      "Epoch: 003/003 | Batch 0150/0636 | Cost: 0.2554\n",
      "Epoch: 003/003 | Batch 0200/0636 | Cost: 0.1685\n",
      "Epoch: 003/003 | Batch 0250/0636 | Cost: 0.2230\n",
      "Epoch: 003/003 | Batch 0300/0636 | Cost: 0.2488\n",
      "Epoch: 003/003 | Batch 0350/0636 | Cost: 0.2356\n",
      "Epoch: 003/003 | Batch 0400/0636 | Cost: 0.1960\n",
      "Epoch: 003/003 | Batch 0450/0636 | Cost: 0.2415\n",
      "Epoch: 003/003 | Batch 0500/0636 | Cost: 0.2152\n",
      "Epoch: 003/003 | Batch 0550/0636 | Cost: 0.2269\n",
      "Epoch: 003/003 | Batch 0600/0636 | Cost: 0.2204\n",
      "Epoch: 003/003 | Train: 90.878% | Valid: 90.512%\n",
      "Time elapsed: 104.14 min\n",
      "Total Training Time: 104.14 min\n"
     ]
    }
   ],
   "source": [
    "def compute_accuracy(model, data_loader):\n",
    "    correct_pred, num_examples = 0, 0\n",
    "    for i, (features, targets) in enumerate(data_loader):\n",
    "            \n",
    "        features = features.to(device)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        logits, probas = model(features)\n",
    "        _, predicted_labels = torch.max(probas, 1)\n",
    "        num_examples += targets.size(0)\n",
    "        correct_pred += (predicted_labels == targets).sum()\n",
    "    return correct_pred.float()/num_examples * 100\n",
    "    \n",
    "\n",
    "start_time = time.time()\n",
    "for epoch in range(num_epochs):\n",
    "    \n",
    "    model.train()\n",
    "    for batch_idx, (features, targets) in enumerate(train_loader):\n",
    "        \n",
    "        features = features.to(device)\n",
    "        targets = targets.to(device)\n",
    "            \n",
    "        ### FORWARD AND BACK PROP\n",
    "        logits, probas = model(features)\n",
    "        cost = F.cross_entropy(logits, targets)\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        cost.backward()\n",
    "        \n",
    "        ### UPDATE MODEL PARAMETERS\n",
    "        optimizer.step()\n",
    "        \n",
    "        ### LOGGING\n",
    "        if not batch_idx % 50:\n",
    "            print ('Epoch: %03d/%03d | Batch %04d/%04d | Cost: %.4f' \n",
    "                   %(epoch+1, num_epochs, batch_idx, \n",
    "                     len(train_loader), cost))\n",
    "\n",
    "        \n",
    "\n",
    "    model.eval()\n",
    "    with torch.set_grad_enabled(False): # save memory during inference\n",
    "        print('Epoch: %03d/%03d | Train: %.3f%% | Valid: %.3f%%' % (\n",
    "              epoch+1, num_epochs, \n",
    "              compute_accuracy(model, train_loader),\n",
    "              compute_accuracy(model, valid_loader)))\n",
    "        \n",
    "    print('Time elapsed: %.2f min' % ((time.time() - start_time)/60))\n",
    "    \n",
    "print('Total Training Time: %.2f min' % ((time.time() - start_time)/60))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "paaeEQHQj5xC"
   },
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 6514,
     "status": "ok",
     "timestamp": 1524976895054,
     "user": {
      "displayName": "Sebastian Raschka",
      "photoUrl": "//lh6.googleusercontent.com/-cxK6yOSQ6uE/AAAAAAAAAAI/AAAAAAAAIfw/P9ar_CHsKOQ/s50-c-k-no/photo.jpg",
      "userId": "118404394130788869227"
     },
     "user_tz": 240
    },
    "id": "gzQMWKq5j5xE",
    "outputId": "de7dc005-5eeb-4177-9f9f-d9b5d1358db9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 90.51%\n"
     ]
    }
   ],
   "source": [
    "with torch.set_grad_enabled(False): # save memory during inference\n",
    "    print('Test accuracy: %.2f%%' % (compute_accuracy(model, test_loader)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f8d8ab00f40>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from helper_data import UnNormalize\n",
    "\n",
    "for batch_idx, (features, targets) in enumerate(test_loader):\n",
    "\n",
    "    features = features\n",
    "    targets = targets\n",
    "    break\n",
    "    \n",
    "unnormalizer = UnNormalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))\n",
    "\n",
    "    \n",
    "plt.imshow(np.transpose(unnormalizer(features[3]), (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability Smile 95.69%\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "logits, probas = model(features.to(device)[3, None])\n",
    "print('Probability Smile %.2f%%' % (probas[0][1]*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torchvision: 0.11.2\n",
      "matplotlib : 3.3.4\n",
      "PIL        : 9.0.1\n",
      "pandas     : 1.2.5\n",
      "torch      : 1.10.1\n",
      "numpy      : 1.22.2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%watermark -iv"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "default_view": {},
   "name": "convnet-vgg16.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.12"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "371px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}