pytorch_ipynb/cnn/cnn-vgg16-celeba-data-parallel.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": [
      "Sebastian Raschka \n",
      "\n",
      "CPython 3.6.8\n",
      "IPython 7.2.0\n",
      "\n",
      "torch 1.0.1.post2\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -a 'Sebastian Raschka' -v -p torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rH4XmErYj5wm"
   },
   "source": [
    "# Model Zoo -- CNN Gender Classifier (VGG16 Architecture, CelebA) with Data Parallelism"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are multiple ways of leveraging multiple GPUs when using PyTorch. One of these approaches is to send a copy of the model to each available GPU and split the minibatches across using `DataParallel`.\n",
    "\n",
    "To break it down into conceptual steps, this is what `DataParallel` does \n",
    "\n",
    "1. each GPU performs a forward pass on a chunk of the minibatch (on a copy of the model) to obtain the predictions;\n",
    "2. the first/default GPU gathers these predictions from all GPUs to compute the loss of each minibatch-chunk with respect to the true labels (this is done on the first/default GPU, because we typically define the loss, like `torch.nn.CrossEntropyLoss` outside the model);\n",
    "3. each GPU then peforms backpropagation to compute the gradient of the loss on their-subbatch with respect to the neural network weights;\n",
    "3. the first GPU sums up the gradients obtained from each GPU (computer engineers usually refer to this step as \"reduce\");\n",
    "4. the first GPU updates the weights in the neural network via gradient descent and sends copies to the individual GPUs for the next round.\n",
    "\n",
    "While the list above may look a bit complicated at first, the `DataParallel` class automatically takes care of it all, and it is very easy to use in practice.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Parallelism vs regular Backpropagation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that using `DataParallel` will result in slightly different models compared to regular backpropagation. The reason is that via data parallelism, we combine the gradients from 4 individual forward and backward runs to update the model. In regular backprop, we would update the model after each minibatch. The following figure illustrates regular backpropagation showing 2 iterations:\n",
    "\n",
    "![](../images/dataparallel/minibatch-update.png)\n",
    "\n",
    "The next figure shows one model update iteration with `DataParallel` assuming 2 GPUs:\n",
    "\n",
    "![](../images/dataparallel/minibatch-update-dataparallel.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation Details"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use `DataParallel`, in the \"Model\" section (i.e., the corresponding code cell) we replace\n",
    "\n",
    "```python\n",
    "model.to(device)\n",
    "```\n",
    "\n",
    "with \n",
    "\n",
    "```python\n",
    "model = VGG16(num_features=num_features, num_classes=num_classes)\n",
    "if torch.cuda.device_count() > 1:\n",
    "    print(\"Using\", torch.cuda.device_count(), \"GPUs\")\n",
    "    model = nn.DataParallel(model)\n",
    "```\n",
    "\n",
    "and let the `DataParallel` class take care of the rest. Note that in order for this to work, the data currently needs to be on the first cuda device, \"cuda:0\". Otherwise, we will get a `RuntimeError: all tensors must be on devices[0]`. Hence, we define `device` below, which we use to transfer the input data to during training. Hence, make sure you set \n",
    "\n",
    "```python\n",
    "device = torch.device(\"cuda:0\")\n",
    "```\n",
    "\n",
    "and not \n",
    "\n",
    "```python\n",
    "device = torch.device(\"cuda:1\")\n",
    "```\n",
    "\n",
    "(or any other CUDA device number), so that in the training loop, we can use\n",
    "\n",
    "```python\n",
    "    for i, (features, targets) in enumerate(data_loader):\n",
    "            \n",
    "        features = features.to(device)\n",
    "        targets = targets.to(device)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you look at the implementation part\n",
    "\n",
    "\n",
    "```python\n",
    "\n",
    "#### DATA PARALLEL START ####\n",
    "\n",
    "model = VGG16(num_features=num_features, num_classes=num_classes)\n",
    "if torch.cuda.device_count() > 1:\n",
    "    print(\"Using\", torch.cuda.device_count(), \"GPUs\")\n",
    "    model = nn.DataParallel(model)\n",
    "\n",
    "#### DATA PARALLEL END ####\n",
    "    \n",
    "model.to(device)\n",
    "\n",
    "#### DATA PARALLEL START ####\n",
    "\n",
    "\n",
    "cost_fn = torch.nn.CrossEntropyLoss()  \n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)  \n",
    "```\n",
    "\n",
    "you notice that the `CrossEntropyLoss` (we could also use the one implemented in nn.functional) is not part of the model. Hence, the loss will be computed on the device where the target labels are, which is the default device (usually the first GPU). This is the reason why the outputs are gathered on the first/default GPU. I sketched a more detailed outline of the whole process below:\n",
    "\n",
    "![](../images/dataparallel/dataparallel.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Speed Comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using the same batch size as in the 1-GPU version of this code, means that if we have four GPUs, the 64-batch dataset gets split into four 16-batch sized datasets that will be distributed across the different GPUs. I noticed that the computation time is approximately half for 4 GPUs compared to 1 GPU (using GeForce 1080Ti cards).\n",
    "\n",
    "- When I multiply the batch size by 4 in the `DataParallel` version, so that each GPU gets a minibatch of size 64, I notice that the model trains approximately 3x faster on 4 GPUs compared to the single GPU version."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Network Architecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The network in this notebook is an implementation of the VGG-16 [1] architecture on the CelebA face dataset [2] to train a gender 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": {
    "colab_type": "text",
    "id": "MkoGLH_Tj5wn"
   },
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": [
    "### Downloading the Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the ~200,000 CelebA face image dataset is relatively large (~1.3 Gb). The download link provided below was provided by the author on the official CelebA website at http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Download and unzip the file `img_align_celeba.zip`, which contains the images in jpeg format.\n",
    "\n",
    "2) Download the `list_attr_celeba.txt` file, which contains the class labels\n",
    "\n",
    "3) Download the `list_eval_partition.txt` file, which contains  training/validation/test partitioning info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preparing the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Male</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>000001.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000002.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000003.jpg</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000004.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000005.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Male\n",
       "000001.jpg     0\n",
       "000002.jpg     0\n",
       "000003.jpg     1\n",
       "000004.jpg     0\n",
       "000005.jpg     0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1 = pd.read_csv('list_attr_celeba.txt', sep=\"\\s+\", skiprows=1, usecols=['Male'])\n",
    "\n",
    "# Make 0 (female) & 1 (male) labels instead of -1 & 1\n",
    "df1.loc[df1['Male'] == -1, 'Male'] = 0\n",
    "\n",
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Partition</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Filename</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>000001.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000002.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000003.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000004.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000005.jpg</th>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Partition\n",
       "Filename             \n",
       "000001.jpg          0\n",
       "000002.jpg          0\n",
       "000003.jpg          0\n",
       "000004.jpg          0\n",
       "000005.jpg          0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2 = pd.read_csv('list_eval_partition.txt', sep=\"\\s+\", skiprows=0, header=None)\n",
    "df2.columns = ['Filename', 'Partition']\n",
    "df2 = df2.set_index('Filename')\n",
    "\n",
    "df2.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Male</th>\n",
       "      <th>Partition</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>000001.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000002.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000003.jpg</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000004.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000005.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Male  Partition\n",
       "000001.jpg     0          0\n",
       "000002.jpg     0          0\n",
       "000003.jpg     1          0\n",
       "000004.jpg     0          0\n",
       "000005.jpg     0          0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3 = df1.merge(df2, left_index=True, right_index=True)\n",
    "df3.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Male</th>\n",
       "      <th>Partition</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>000001.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000002.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000003.jpg</th>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000004.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>000005.jpg</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Male  Partition\n",
       "000001.jpg     0          0\n",
       "000002.jpg     0          0\n",
       "000003.jpg     1          0\n",
       "000004.jpg     0          0\n",
       "000005.jpg     0          0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df3.to_csv('celeba-gender-partitions.csv')\n",
    "df4 = pd.read_csv('celeba-gender-partitions.csv', index_col=0)\n",
    "df4.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df4.loc[df4['Partition'] == 0].to_csv('celeba-gender-train.csv')\n",
    "df4.loc[df4['Partition'] == 1].to_csv('celeba-gender-valid.csv')\n",
    "df4.loc[df4['Partition'] == 2].to_csv('celeba-gender-test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(218, 178, 3)\n"
     ]
    },
    {
     "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": [
    "img = Image.open('img_align_celeba/000001.jpg')\n",
    "print(np.asarray(img, dtype=np.uint8).shape)\n",
    "plt.imshow(img);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing a Custom DataLoader Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CelebaDataset(Dataset):\n",
    "    \"\"\"Custom Dataset for loading CelebA face images\"\"\"\n",
    "\n",
    "    def __init__(self, csv_path, img_dir, transform=None):\n",
    "    \n",
    "        df = pd.read_csv(csv_path, index_col=0)\n",
    "        self.img_dir = img_dir\n",
    "        self.csv_path = csv_path\n",
    "        self.img_names = df.index.values\n",
    "        self.y = df['Male'].values\n",
    "        self.transform = transform\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        img = Image.open(os.path.join(self.img_dir,\n",
    "                                      self.img_names[index]))\n",
    "        \n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img)\n",
    "        \n",
    "        label = self.y[index]\n",
    "        return img, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.y.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running the VGG16 on this dataset with a minibatch size of 64 uses approximately 6.6 Gb of GPU memory. However, since we will split the batch size over for GPUs now, along with the model, we can actually comfortably use 64*4 as the batch size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that transforms.ToTensor()\n",
    "# already divides pixels by 255. internally\n",
    "\n",
    "custom_transform = transforms.Compose([transforms.CenterCrop((178, 178)),\n",
    "                                       transforms.Resize((128, 128)),\n",
    "                                       #transforms.Grayscale(),                                       \n",
    "                                       #transforms.Lambda(lambda x: x/255.),\n",
    "                                       transforms.ToTensor()])\n",
    "\n",
    "train_dataset = CelebaDataset(csv_path='celeba-gender-train.csv',\n",
    "                              img_dir='img_align_celeba/',\n",
    "                              transform=custom_transform)\n",
    "\n",
    "valid_dataset = CelebaDataset(csv_path='celeba-gender-valid.csv',\n",
    "                              img_dir='img_align_celeba/',\n",
    "                              transform=custom_transform)\n",
    "\n",
    "test_dataset = CelebaDataset(csv_path='celeba-gender-test.csv',\n",
    "                             img_dir='img_align_celeba/',\n",
    "                             transform=custom_transform)\n",
    "\n",
    "BATCH_SIZE=64*torch.cuda.device_count()\n",
    "\n",
    "\n",
    "train_loader = DataLoader(dataset=train_dataset,\n",
    "                          batch_size=BATCH_SIZE,\n",
    "                          shuffle=True,\n",
    "                          num_workers=4)\n",
    "\n",
    "valid_loader = DataLoader(dataset=valid_dataset,\n",
    "                          batch_size=BATCH_SIZE,\n",
    "                          shuffle=False,\n",
    "                          num_workers=4)\n",
    "\n",
    "test_loader = DataLoader(dataset=test_dataset,\n",
    "                         batch_size=BATCH_SIZE,\n",
    "                         shuffle=False,\n",
    "                         num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that for DataParallel to work, the data currently needs to be on the first cuda device, \"cuda:0\". Otherwise, we will get a `RuntimeError: all tensors must be on devices[0]`. Hence, we define `device` below, which we use to transfer the input data to during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 | Batch index: 0 | Batch size: 256\n",
      "Epoch: 2 | Batch index: 0 | Batch size: 256\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda:0\")\n",
    "torch.manual_seed(0)\n",
    "\n",
    "num_epochs = 2\n",
    "for epoch in range(num_epochs):\n",
    "\n",
    "    for batch_idx, (x, y) in enumerate(train_loader):\n",
    "        \n",
    "        print('Epoch:', epoch+1, end='')\n",
    "        print(' | Batch index:', batch_idx, end='')\n",
    "        print(' | Batch size:', y.size()[0])\n",
    "        \n",
    "        x = x.to(device)\n",
    "        y = y.to(device)\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "I6hghKPxj5w0"
   },
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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",
    "# 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": 13,
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using 4 GPUs\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(random_seed)\n",
    "\n",
    "#### DATA PARALLEL START ####\n",
    "\n",
    "model = VGG16(num_features=num_features, num_classes=num_classes)\n",
    "if torch.cuda.device_count() > 1:\n",
    "    print(\"Using\", torch.cuda.device_count(), \"GPUs\")\n",
    "    model = nn.DataParallel(model)\n",
    "\n",
    "#### DATA PARALLEL END ####\n",
    "    \n",
    "model.to(device)\n",
    "\n",
    "#### DATA PARALLEL START ####\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": 15,
   "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",
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 001/003 | Batch 0000/0636 | Cost: 8824.2812\n",
      "Epoch: 001/003 | Batch 0050/0636 | Cost: 0.7300\n",
      "Epoch: 001/003 | Batch 0100/0636 | Cost: 0.5690\n",
      "Epoch: 001/003 | Batch 0150/0636 | Cost: 0.4973\n",
      "Epoch: 001/003 | Batch 0200/0636 | Cost: 0.4219\n",
      "Epoch: 001/003 | Batch 0250/0636 | Cost: 0.3375\n",
      "Epoch: 001/003 | Batch 0300/0636 | Cost: 0.4227\n",
      "Epoch: 001/003 | Batch 0350/0636 | Cost: 0.2883\n",
      "Epoch: 001/003 | Batch 0400/0636 | Cost: 0.2740\n",
      "Epoch: 001/003 | Batch 0450/0636 | Cost: 0.2414\n",
      "Epoch: 001/003 | Batch 0500/0636 | Cost: 0.3492\n",
      "Epoch: 001/003 | Batch 0550/0636 | Cost: 0.2444\n",
      "Epoch: 001/003 | Batch 0600/0636 | Cost: 0.2145\n",
      "Epoch: 001/003 | Train: 92.041% | Valid: 93.149%\n",
      "Time elapsed: 6.44 min\n",
      "Epoch: 002/003 | Batch 0000/0636 | Cost: 0.2167\n",
      "Epoch: 002/003 | Batch 0050/0636 | Cost: 0.1764\n",
      "Epoch: 002/003 | Batch 0100/0636 | Cost: 0.2338\n",
      "Epoch: 002/003 | Batch 0150/0636 | Cost: 0.2053\n",
      "Epoch: 002/003 | Batch 0200/0636 | Cost: 0.1492\n",
      "Epoch: 002/003 | Batch 0250/0636 | Cost: 0.2303\n",
      "Epoch: 002/003 | Batch 0300/0636 | Cost: 0.2100\n",
      "Epoch: 002/003 | Batch 0350/0636 | Cost: 0.1400\n",
      "Epoch: 002/003 | Batch 0400/0636 | Cost: 0.1781\n",
      "Epoch: 002/003 | Batch 0450/0636 | Cost: 0.1286\n",
      "Epoch: 002/003 | Batch 0500/0636 | Cost: 0.1550\n",
      "Epoch: 002/003 | Batch 0550/0636 | Cost: 0.1845\n",
      "Epoch: 002/003 | Batch 0600/0636 | Cost: 0.1180\n",
      "Epoch: 002/003 | Train: 94.716% | Valid: 95.550%\n",
      "Time elapsed: 12.84 min\n",
      "Epoch: 003/003 | Batch 0000/0636 | Cost: 0.1429\n",
      "Epoch: 003/003 | Batch 0050/0636 | Cost: 0.1716\n",
      "Epoch: 003/003 | Batch 0100/0636 | Cost: 0.1373\n",
      "Epoch: 003/003 | Batch 0150/0636 | Cost: 0.1546\n",
      "Epoch: 003/003 | Batch 0200/0636 | Cost: 0.2527\n",
      "Epoch: 003/003 | Batch 0250/0636 | Cost: 0.1723\n",
      "Epoch: 003/003 | Batch 0300/0636 | Cost: 0.1730\n",
      "Epoch: 003/003 | Batch 0350/0636 | Cost: 0.1218\n",
      "Epoch: 003/003 | Batch 0400/0636 | Cost: 0.1303\n",
      "Epoch: 003/003 | Batch 0450/0636 | Cost: 0.1377\n",
      "Epoch: 003/003 | Batch 0500/0636 | Cost: 0.1203\n",
      "Epoch: 003/003 | Batch 0550/0636 | Cost: 0.1719\n",
      "Epoch: 003/003 | Batch 0600/0636 | Cost: 0.1307\n",
      "Epoch: 003/003 | Train: 95.134% | Valid: 95.661%\n",
      "Time elapsed: 19.24 min\n",
      "Total Training Time: 19.24 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": 16,
   "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: 94.96%\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "\n",
    "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f3a4182fa90>"
      ]
     },
     "execution_count": 17,
     "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": [
    "for batch_idx, (features, targets) in enumerate(test_loader):\n",
    "\n",
    "    features = features\n",
    "    targets = targets\n",
    "    break\n",
    "    \n",
    "plt.imshow(np.transpose(features[0], (1, 2, 0)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probability Female 97.02%\n"
     ]
    }
   ],
   "source": [
    "logits, probas = model(features.to(device)[0, None])\n",
    "print('Probability Female %.2f%%' % (probas[0][0]*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "numpy       1.15.4\n",
      "pandas      0.23.4\n",
      "torch       1.0.1.post2\n",
      "PIL.Image   5.3.0\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",
   "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.7.1"
  },
  "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": 2
}