exercise_08_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch\n",
    "In this notebook you will gain some hands-on experience with [PyTorch](https://pytorch.org/), one of the major frameworks for deep learning. To install PyTorch. follow [the official installation instructions](https://pytorch.org/get-started/locally/). Make sure that you select the correct OS & select the version with CUDA if your computer supports it.\n",
    "If you do not have an Nvidia GPU, you can install the CPU version by setting `CUDA` to `None`.\n",
    "However, in this case we recommend using [Google Colab](https://colab.research.google.com/).\n",
    "Make sure that you enable GPU acceleration in `Runtime > Change runtime type`.\n",
    "\n",
    "You will start by re-implementing some common features of deep neural networks (dropout and batch normalization) and then implement a very popular modern architecture for image classification (ResNet) and improve its training loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Dropout\n",
    "Dropout is a form of regularization for neural networks. It works by randomly setting activations (values) to 0, each one with equal probability `p`. The values are then scaled by a factor $\\frac{1}{1-p}$ to conserve their mean.\n",
    "\n",
    "Dropout effectively trains a pseudo-ensemble of models with stochastic gradient descent. During evaluation we want to use the full ensemble and therefore have to turn off dropout. Use `self.training` to check if the model is in training or evaluation mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dropout(nn.Module):\n",
    "    \"\"\"\n",
    "    Dropout, as discussed in the lecture and described here:\n",
    "    https://pytorch.org/docs/stable/nn.html#torch.nn.Dropout\n",
    "    \n",
    "    Args:\n",
    "        p: float, dropout probability\n",
    "    \"\"\"\n",
    "    def __init__(self, p):\n",
    "        super().__init__()\n",
    "        self.p = p\n",
    "        \n",
    "    def forward(self, input):\n",
    "        \"\"\"\n",
    "        The module's forward pass.\n",
    "        This has to be implemented for every PyTorch module.\n",
    "        PyTorch then automatically generates the backward pass\n",
    "        by dynamically generating the computational graph during\n",
    "        execution.\n",
    "        \n",
    "        Args:\n",
    "            input: PyTorch tensor, arbitrary shape\n",
    "\n",
    "        Returns:\n",
    "            PyTorch tensor, same shape as input\n",
    "        \"\"\"\n",
    "        \n",
    "        # TODO: Set values randomly to 0.\n",
    "        if self.training:\n",
    "            mask = input.new_empty(input.shape)\n",
    "            mask.bernoulli_(1 - self.p)\n",
    "            scaling = 1 / (1 - self.p)\n",
    "            return scaling * mask * input\n",
    "        else:\n",
    "            return input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Test dropout\n",
    "test = torch.ones(10_000)\n",
    "dropout = Dropout(0.5)\n",
    "test_dropped = dropout(test)\n",
    "\n",
    "# These assertions can in principle fail due to bad luck, but\n",
    "# if implemented correctly they should almost always succeed.\n",
    "assert np.isclose(test_dropped.sum().item(), 10_000, atol=400)\n",
    "assert np.isclose((test_dropped > 0).sum().item(), 5_000, atol=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Batch normalization\n",
    "Batch normalization is a trick use to smoothen the loss landscape and improve training. It is defined as the function\n",
    "$$y = \\frac{x - \\mu_x}{\\sigma_x + \\epsilon} \\cdot \\gamma + \\beta$$,\n",
    "where $\\gamma$ and $\\beta$ and learnable parameters and $\\epsilon$ is a some small number to avoid dividing by zero. The Statistics $\\mu_x$ and $\\sigma_x$ are taken separately for each feature. In a CNN this means averaging over the batch and all pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BatchNorm(nn.Module):\n",
    "    \"\"\"\n",
    "    Batch normalization, as discussed in the lecture and similar to\n",
    "    https://pytorch.org/docs/stable/nn.html#torch.nn.BatchNorm1d\n",
    "    \n",
    "    Only uses batch statistics (no running mean for evaluation).\n",
    "    Batch statistics are calculated for a single dimension.\n",
    "    Gamma is initialized as 1, beta as 0.\n",
    "    \n",
    "    Args:\n",
    "        num_features: Number of features to calculate batch statistics for.\n",
    "    \"\"\"\n",
    "    def __init__(self, num_features):\n",
    "        super().__init__()\n",
    "        \n",
    "        # TODO: Initialize the required parameters\n",
    "        self.gamma = nn.Parameter(torch.ones(num_features))\n",
    "        self.beta = nn.Parameter(torch.zeros(num_features))\n",
    "        \n",
    "    def forward(self, input):\n",
    "        \"\"\"\n",
    "        Batch normalization over the dimension C of (N, C, L).\n",
    "        \n",
    "        Args:\n",
    "            input: PyTorch tensor, shape [N, C, L]\n",
    "            \n",
    "        Return:\n",
    "            PyTorch tensor, same shape as input\n",
    "        \"\"\"\n",
    "        eps = 1e-5\n",
    "        \n",
    "        # TODO: Implement the required transformation\n",
    "        aggregate_dims = [0, 2]\n",
    "        mean = torch.mean(input, dim=aggregate_dims, keepdim=True)\n",
    "        std = torch.std(input, dim=aggregate_dims, keepdim=True)\n",
    "        \n",
    "        input_normalized = (input - mean) / (std + eps)\n",
    "        return self.gamma[None, :, None] * input_normalized + self.beta[None, :, None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tests the batch normalization implementation\n",
    "torch.random.manual_seed(42)\n",
    "test = torch.randn(8, 2, 4)\n",
    "\n",
    "b1 = BatchNorm(2)\n",
    "test_b1 = b1(test)\n",
    "\n",
    "b2 = nn.BatchNorm1d(2, affine=False, track_running_stats=False)\n",
    "test_b2 = b2(test)\n",
    "\n",
    "assert torch.allclose(test_b1, test_b2, rtol=0.02)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. ResNet\n",
    "ResNet is the models that first introduced residual connections (a form of skip connections). It is a rather simple, but successful and very popular architecture. In this part of the exercise we will re-implement it step by step.\n",
    "\n",
    "Note that there is also an [improved version of ResNet](https://arxiv.org/abs/1603.05027) with optimized residual blocks. Here we will implement the [original version](https://arxiv.org/abs/1512.03385) for CIFAR-10. Your dropout and batchnorm implementations won't help you here. Just use PyTorch's own layers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is just a convenience function to make e.g. `nn.Sequential` more flexible. It is e.g. useful in combination with `x.squeeze()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Lambda(nn.Module):\n",
    "    def __init__(self, func):\n",
    "        super().__init__()\n",
    "        self.func = func\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.func(x)"
   ]
  },
  {
   "attachments": {
    "residual_connection.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We begin by implementing the residual blocks. The block is illustrated by this sketch:\n",
    "\n",
    "![Residual connection](attachment:residual_connection.png)\n",
    "\n",
    "Note that we use 'SAME' padding, no bias, and batch normalization after each convolution. You do not need `nn.Sequential` here. The skip connection is already implemented as `self.skip`. It can handle different strides and increases in the number of channels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualBlock(nn.Module):\n",
    "    \"\"\"\n",
    "    The residual block used by ResNet.\n",
    "    \n",
    "    Args:\n",
    "        in_channels: The number of channels (feature maps) of the incoming embedding\n",
    "        out_channels: The number of channels after the first convolution\n",
    "        stride: Stride size of the first convolution, used for downsampling\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, in_channels, out_channels, stride=1):\n",
    "        super().__init__()        \n",
    "        if stride > 1 or in_channels != out_channels:\n",
    "            # Add strides in the skip connection and zeros for the new channels.\n",
    "            self.skip = Lambda(lambda x: F.pad(x[:, :, ::stride, ::stride],\n",
    "                                               (0, 0, 0, 0, 0, out_channels - in_channels),\n",
    "                                               mode=\"constant\", value=0))\n",
    "        else:\n",
    "            self.skip = nn.Sequential()\n",
    "            \n",
    "        # TODO: Initialize the required layers\n",
    "        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, bias=False, padding=1)\n",
    "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
    "        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, bias=False, padding=1)\n",
    "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
    "        \n",
    "    def forward(self, input):\n",
    "        # TODO: Execute the required layers and functions\n",
    "        x1 = F.relu(self.bn1(self.conv1(input)))\n",
    "        x2 = self.bn2(self.conv2(x1))\n",
    "        return F.relu(x2 + self.skip(input))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we implement a stack of residual blocks for convenience. The first layer in the block is the one changing the number of channels and downsampling. You can use `nn.ModuleList` to use a list of child modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResidualStack(nn.Module):\n",
    "    \"\"\"\n",
    "    A stack of residual blocks.\n",
    "    \n",
    "    Args:\n",
    "        in_channels: The number of channels (feature maps) of the incoming embedding\n",
    "        out_channels: The number of channels after the first layer\n",
    "        stride: Stride size of the first layer, used for downsampling\n",
    "        num_blocks: Number of residual blocks\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, in_channels, out_channels, stride, num_blocks):\n",
    "        super().__init__()\n",
    "        \n",
    "        # TODO: Initialize the required layers (blocks)\n",
    "        blocks = [ResidualBlock(in_channels, out_channels, stride=stride)]\n",
    "        for _ in range(num_blocks - 1):\n",
    "            blocks.append(ResidualBlock(out_channels, out_channels))\n",
    "        self.blocks = nn.ModuleList(blocks)\n",
    "        \n",
    "    def forward(self, input):\n",
    "        # TODO: Execute the layers (blocks)\n",
    "        x = input\n",
    "        for block in self.blocks:\n",
    "            x = block(x)\n",
    "        return x"
   ]
  },
  {
   "attachments": {
    "resnet_cifar10_description.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are finally ready to implement the full model! To do this, use the `nn.Sequential` API and carefully read the following paragraph from the paper (Fig. 3 is not important):\n",
    "\n",
    "![ResNet CIFAR10 description](attachment:resnet_cifar10_description.png)\n",
    "\n",
    "Note that a convolution layer is always convolution + batch norm + activation (ReLU), that each ResidualBlock contains 2 layers, and that you might have to `squeeze` the embedding before the dense (fully-connected) layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "num_classes = 10\n",
    "\n",
    "# TODO: Implement ResNet via nn.Sequential\n",
    "resnet = nn.Sequential(\n",
    "    nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1, bias=False),\n",
    "    nn.BatchNorm2d(16),\n",
    "    nn.ReLU(),\n",
    "    ResidualStack(16, 16, stride=1, num_blocks=n),\n",
    "    ResidualStack(16, 32, stride=2, num_blocks=n),\n",
    "    ResidualStack(32, 64, stride=2, num_blocks=n),\n",
    "    nn.AdaptiveAvgPool2d(1),\n",
    "    Lambda(lambda x: x.squeeze()),\n",
    "    nn.Linear(64, num_classes)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we need to initialize the weights of our model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_weight(module):\n",
    "    if isinstance(module, (nn.Linear, nn.Conv2d)):\n",
    "        nn.init.kaiming_normal_(module.weight, nonlinearity='relu')\n",
    "    elif isinstance(module, nn.BatchNorm2d):\n",
    "        nn.init.constant_(module.weight, 1)\n",
    "        nn.init.constant_(module.bias, 0)\n",
    "        \n",
    "resnet.apply(initialize_weight);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Training\n",
    "So now we have a shiny new model, but that doesn't really help when we can't train it. So that's what we do next.\n",
    "\n",
    "First we need to load the data. Note that we split the official training data into train and validation sets, because you must not look at the test set until you are completely done developing your model and report the final results. Some people don't do this properly, but you should not copy other people's bad habits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CIFAR10Subset(torchvision.datasets.CIFAR10):\n",
    "    \"\"\"\n",
    "    Get a subset of the CIFAR10 dataset, according to the passed indices.\n",
    "    \"\"\"\n",
    "    def __init__(self, *args, idx=None, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "        \n",
    "        if idx is None:\n",
    "            return\n",
    "        \n",
    "        self.data = self.data[idx]\n",
    "        targets_np = np.array(self.targets)\n",
    "        self.targets = targets_np[idx].tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We next define transformations that change the images into PyTorch tensors, standardize the values according to the precomputed mean and standard deviation, and provide data augmentation for the training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],\n",
    "                                 std=[0.229, 0.224, 0.225])\n",
    "transform_train = transforms.Compose([\n",
    "    transforms.RandomHorizontalFlip(),\n",
    "    transforms.RandomCrop(32, 4),\n",
    "    transforms.ToTensor(),\n",
    "    normalize,\n",
    "])\n",
    "transform_eval = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    normalize\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n",
      "Files already downloaded and verified\n"
     ]
    }
   ],
   "source": [
    "ntrain = 45_000\n",
    "train_set = CIFAR10Subset(root='./data', train=True, idx=range(ntrain),\n",
    "                          download=True, transform=transform_train)\n",
    "val_set = CIFAR10Subset(root='./data', train=True, idx=range(ntrain, 50_000),\n",
    "                        download=True, transform=transform_eval)\n",
    "test_set = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
    "                                        download=True, transform=transform_eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([3, 32, 32])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set[0][0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloaders = {}\n",
    "dataloaders['train'] = torch.utils.data.DataLoader(train_set, batch_size=128,\n",
    "                                                   shuffle=True, num_workers=2,\n",
    "                                                   pin_memory=True)\n",
    "dataloaders['val'] = torch.utils.data.DataLoader(val_set, batch_size=128,\n",
    "                                                 shuffle=False, num_workers=2,\n",
    "                                                 pin_memory=True)\n",
    "dataloaders['test'] = torch.utils.data.DataLoader(test_set, batch_size=128,\n",
    "                                                  shuffle=False, num_workers=2,\n",
    "                                                  pin_memory=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we push the model to our GPU (if there is one)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
    "resnet.to(device);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we define a helper method that does one epoch of training or evaluation. We have only defined training here, so you need to implement the necessary changes for evaluation!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_epoch(model, optimizer, dataloader, train):\n",
    "    \"\"\"\n",
    "    Run one epoch of training or evaluation.\n",
    "    \n",
    "    Args:\n",
    "        model: The model used for prediction\n",
    "        optimizer: Optimization algorithm for the model\n",
    "        dataloader: Dataloader providing the data to run our model on\n",
    "        train: Whether this epoch is used for training or evaluation\n",
    "        \n",
    "    Returns:\n",
    "        Loss and accuracy in this epoch.\n",
    "    \"\"\"\n",
    "    # TODO: Change the necessary parts to work correctly during evaluation (train=False)\n",
    "    \n",
    "    device = next(model.parameters()).device\n",
    "    \n",
    "    # Set model to training mode (for e.g. batch normalization, dropout)\n",
    "    if train:\n",
    "        model.train()\n",
    "    else:\n",
    "        model.eval()\n",
    "\n",
    "    epoch_loss = 0.0\n",
    "    epoch_acc = 0.0\n",
    "\n",
    "    # Iterate over data\n",
    "    for xb, yb in dataloader:\n",
    "        xb, yb = xb.to(device), yb.to(device)\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        if train:\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "        # forward\n",
    "        with torch.set_grad_enabled(train):\n",
    "            pred = model(xb)\n",
    "            loss = F.cross_entropy(pred, yb)\n",
    "            top1 = torch.argmax(pred, dim=1)\n",
    "            ncorrect = torch.sum(top1 == yb)\n",
    "\n",
    "            # backward + optimize only if in training phase\n",
    "            if train:\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "\n",
    "        # statistics\n",
    "        epoch_loss += loss.item()\n",
    "        epoch_acc += ncorrect.item()\n",
    "    \n",
    "    epoch_loss /= len(dataloader.dataset)\n",
    "    epoch_acc /= len(dataloader.dataset)\n",
    "    return epoch_loss, epoch_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we implement a method for fitting (training) our model. For many models early stopping can save a lot of training time. Your task is to add early stopping to the loop (based on validation accuracy). Early stopping usually means exiting the training loop if the validation accuracy hasn't improved for `patience` number of steps. Don't forget to save the best model parameters according to validation accuracy. You will need `copy.deepcopy` and the `state_dict` for this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fit(model, optimizer, lr_scheduler, dataloaders, max_epochs, patience):\n",
    "    \"\"\"\n",
    "    Fit the given model on the dataset.\n",
    "    \n",
    "    Args:\n",
    "        model: The model used for prediction\n",
    "        optimizer: Optimization algorithm for the model\n",
    "        lr_scheduler: Learning rate scheduler that improves training\n",
    "                      in late epochs with learning rate decay\n",
    "        dataloaders: Dataloaders for training and validation\n",
    "        max_epochs: Maximum number of epochs for training\n",
    "        patience: Number of epochs to wait with early stopping the\n",
    "                  training if validation loss has decreased\n",
    "                  \n",
    "    Returns:\n",
    "        Loss and accuracy in this epoch.\n",
    "    \"\"\"\n",
    "    \n",
    "    best_acc = 0\n",
    "    curr_patience = 0\n",
    "    \n",
    "    for epoch in range(max_epochs):\n",
    "        train_loss, train_acc = run_epoch(model, optimizer, dataloaders['train'], train=True)\n",
    "        lr_scheduler.step()\n",
    "        print(f\"Epoch {epoch + 1: >3}/{max_epochs}, train loss: {train_loss:.2e}, accuracy: {train_acc * 100:.2f}%\")\n",
    "        \n",
    "        val_loss, val_acc = run_epoch(model, None, dataloaders['val'], train=False)\n",
    "        print(f\"Epoch {epoch + 1: >3}/{max_epochs}, val loss: {val_loss:.2e}, accuracy: {val_acc * 100:.2f}%\")\n",
    "        \n",
    "        # TODO: Add early stopping and save the best weights (in best_model_weights)\n",
    "        if val_acc >= best_acc:\n",
    "            best_epoch = epoch\n",
    "            best_acc = val_acc\n",
    "            best_model_weights = copy.deepcopy(model.state_dict())\n",
    "                \n",
    "        # Early stopping\n",
    "        if epoch - best_epoch >= patience:\n",
    "            break\n",
    "    \n",
    "    model.load_state_dict(best_model_weights)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In most cases you should just use the Adam optimizer for training, because it works well out of the box. However, a well-tuned SGD (with momentum) will in most cases outperform Adam. And since the original paper gives us a well-tuned SGD we will just use that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "Epoch   1/200, train loss: 1.44e-02, accuracy: 34.81%\n",
      "Epoch   1/200, val loss: 1.17e-02, accuracy: 45.80%\n",
      "Epoch   2/200, train loss: 1.00e-02, accuracy: 53.49%\n",
      "Epoch   2/200, val loss: 1.07e-02, accuracy: 54.28%\n",
      "Epoch   3/200, train loss: 7.91e-03, accuracy: 64.20%\n",
      "Epoch   3/200, val loss: 7.34e-03, accuracy: 68.54%\n",
      "Epoch   4/200, train loss: 6.53e-03, accuracy: 70.73%\n",
      "Epoch   4/200, val loss: 6.53e-03, accuracy: 72.42%\n",
      "Epoch   5/200, train loss: 5.73e-03, accuracy: 74.33%\n",
      "Epoch   5/200, val loss: 6.93e-03, accuracy: 72.22%\n",
      "Epoch   6/200, train loss: 5.12e-03, accuracy: 77.28%\n",
      "Epoch   6/200, val loss: 5.45e-03, accuracy: 77.32%\n",
      "Epoch   7/200, train loss: 4.67e-03, accuracy: 79.21%\n",
      "Epoch   7/200, val loss: 4.89e-03, accuracy: 79.10%\n",
      "Epoch   8/200, train loss: 4.38e-03, accuracy: 80.77%\n",
      "Epoch   8/200, val loss: 4.48e-03, accuracy: 80.58%\n",
      "Epoch   9/200, train loss: 4.11e-03, accuracy: 81.79%\n",
      "Epoch   9/200, val loss: 4.95e-03, accuracy: 79.58%\n",
      "Epoch  10/200, train loss: 3.92e-03, accuracy: 82.58%\n",
      "Epoch  10/200, val loss: 5.11e-03, accuracy: 79.46%\n",
      "Epoch  11/200, train loss: 3.75e-03, accuracy: 83.31%\n",
      "Epoch  11/200, val loss: 4.39e-03, accuracy: 82.00%\n",
      "Epoch  12/200, train loss: 3.58e-03, accuracy: 84.28%\n",
      "Epoch  12/200, val loss: 4.16e-03, accuracy: 82.78%\n",
      "Epoch  13/200, train loss: 3.41e-03, accuracy: 84.86%\n",
      "Epoch  13/200, val loss: 4.50e-03, accuracy: 82.10%\n",
      "Epoch  14/200, train loss: 3.32e-03, accuracy: 85.29%\n",
      "Epoch  14/200, val loss: 4.28e-03, accuracy: 82.30%\n",
      "Epoch  15/200, train loss: 3.24e-03, accuracy: 85.46%\n",
      "Epoch  15/200, val loss: 4.52e-03, accuracy: 81.12%\n",
      "Epoch  16/200, train loss: 3.11e-03, accuracy: 86.16%\n",
      "Epoch  16/200, val loss: 3.80e-03, accuracy: 83.78%\n",
      "Epoch  17/200, train loss: 3.05e-03, accuracy: 86.46%\n",
      "Epoch  17/200, val loss: 3.98e-03, accuracy: 83.66%\n",
      "Epoch  18/200, train loss: 2.91e-03, accuracy: 87.20%\n",
      "Epoch  18/200, val loss: 3.96e-03, accuracy: 83.46%\n",
      "Epoch  19/200, train loss: 2.87e-03, accuracy: 87.38%\n",
      "Epoch  19/200, val loss: 3.75e-03, accuracy: 84.54%\n",
      "Epoch  20/200, train loss: 2.76e-03, accuracy: 87.80%\n",
      "Epoch  20/200, val loss: 4.55e-03, accuracy: 82.00%\n",
      "Epoch  21/200, train loss: 2.72e-03, accuracy: 87.82%\n",
      "Epoch  21/200, val loss: 4.48e-03, accuracy: 83.18%\n",
      "Epoch  22/200, train loss: 2.66e-03, accuracy: 88.25%\n",
      "Epoch  22/200, val loss: 4.07e-03, accuracy: 84.42%\n",
      "Epoch  23/200, train loss: 2.55e-03, accuracy: 88.49%\n",
      "Epoch  23/200, val loss: 3.60e-03, accuracy: 85.40%\n",
      "Epoch  24/200, train loss: 2.54e-03, accuracy: 88.76%\n",
      "Epoch  24/200, val loss: 5.20e-03, accuracy: 81.68%\n",
      "Epoch  25/200, train loss: 2.51e-03, accuracy: 88.88%\n",
      "Epoch  25/200, val loss: 3.41e-03, accuracy: 86.80%\n",
      "Epoch  26/200, train loss: 2.44e-03, accuracy: 89.27%\n",
      "Epoch  26/200, val loss: 3.69e-03, accuracy: 85.08%\n",
      "Epoch  27/200, train loss: 2.38e-03, accuracy: 89.46%\n",
      "Epoch  27/200, val loss: 4.03e-03, accuracy: 83.96%\n",
      "Epoch  28/200, train loss: 2.35e-03, accuracy: 89.38%\n",
      "Epoch  28/200, val loss: 3.68e-03, accuracy: 85.56%\n",
      "Epoch  29/200, train loss: 2.33e-03, accuracy: 89.66%\n",
      "Epoch  29/200, val loss: 3.47e-03, accuracy: 85.64%\n",
      "Epoch  30/200, train loss: 2.27e-03, accuracy: 89.83%\n",
      "Epoch  30/200, val loss: 3.97e-03, accuracy: 85.04%\n",
      "Epoch  31/200, train loss: 2.25e-03, accuracy: 89.94%\n",
      "Epoch  31/200, val loss: 3.71e-03, accuracy: 86.40%\n",
      "Epoch  32/200, train loss: 2.19e-03, accuracy: 90.19%\n",
      "Epoch  32/200, val loss: 3.34e-03, accuracy: 87.44%\n",
      "Epoch  33/200, train loss: 2.16e-03, accuracy: 90.26%\n",
      "Epoch  33/200, val loss: 3.80e-03, accuracy: 85.76%\n",
      "Epoch  34/200, train loss: 2.12e-03, accuracy: 90.56%\n",
      "Epoch  34/200, val loss: 3.90e-03, accuracy: 84.64%\n",
      "Epoch  35/200, train loss: 2.07e-03, accuracy: 90.74%\n",
      "Epoch  35/200, val loss: 3.23e-03, accuracy: 87.28%\n",
      "Epoch  36/200, train loss: 2.09e-03, accuracy: 90.58%\n",
      "Epoch  36/200, val loss: 4.90e-03, accuracy: 82.30%\n",
      "Epoch  37/200, train loss: 2.01e-03, accuracy: 91.10%\n",
      "Epoch  37/200, val loss: 4.50e-03, accuracy: 83.38%\n",
      "Epoch  38/200, train loss: 2.04e-03, accuracy: 90.86%\n",
      "Epoch  38/200, val loss: 4.42e-03, accuracy: 83.62%\n",
      "Epoch  39/200, train loss: 1.99e-03, accuracy: 91.06%\n",
      "Epoch  39/200, val loss: 3.59e-03, accuracy: 86.88%\n",
      "Epoch  40/200, train loss: 1.96e-03, accuracy: 91.22%\n",
      "Epoch  40/200, val loss: 3.47e-03, accuracy: 86.54%\n",
      "Epoch  41/200, train loss: 1.96e-03, accuracy: 91.22%\n",
      "Epoch  41/200, val loss: 3.78e-03, accuracy: 85.76%\n",
      "Epoch  42/200, train loss: 1.93e-03, accuracy: 91.54%\n",
      "Epoch  42/200, val loss: 4.13e-03, accuracy: 84.58%\n",
      "Epoch  43/200, train loss: 1.90e-03, accuracy: 91.52%\n",
      "Epoch  43/200, val loss: 3.60e-03, accuracy: 86.24%\n",
      "Epoch  44/200, train loss: 1.91e-03, accuracy: 91.43%\n",
      "Epoch  44/200, val loss: 4.09e-03, accuracy: 84.98%\n",
      "Epoch  45/200, train loss: 1.91e-03, accuracy: 91.45%\n",
      "Epoch  45/200, val loss: 4.04e-03, accuracy: 85.16%\n",
      "Epoch  46/200, train loss: 1.82e-03, accuracy: 91.75%\n",
      "Epoch  46/200, val loss: 3.56e-03, accuracy: 86.60%\n",
      "Epoch  47/200, train loss: 1.83e-03, accuracy: 91.69%\n",
      "Epoch  47/200, val loss: 4.03e-03, accuracy: 84.90%\n",
      "Epoch  48/200, train loss: 1.80e-03, accuracy: 91.93%\n",
      "Epoch  48/200, val loss: 3.56e-03, accuracy: 87.20%\n",
      "Epoch  49/200, train loss: 1.80e-03, accuracy: 91.94%\n",
      "Epoch  49/200, val loss: 3.31e-03, accuracy: 87.12%\n",
      "Epoch  50/200, train loss: 1.77e-03, accuracy: 92.05%\n",
      "Epoch  50/200, val loss: 3.39e-03, accuracy: 87.32%\n",
      "Epoch  51/200, train loss: 1.73e-03, accuracy: 92.16%\n",
      "Epoch  51/200, val loss: 3.72e-03, accuracy: 85.74%\n",
      "Epoch  52/200, train loss: 1.74e-03, accuracy: 92.25%\n",
      "Epoch  52/200, val loss: 4.90e-03, accuracy: 83.52%\n",
      "Epoch  53/200, train loss: 1.78e-03, accuracy: 92.06%\n",
      "Epoch  53/200, val loss: 3.38e-03, accuracy: 87.56%\n",
      "Epoch  54/200, train loss: 1.73e-03, accuracy: 92.19%\n",
      "Epoch  54/200, val loss: 3.36e-03, accuracy: 87.24%\n",
      "Epoch  55/200, train loss: 1.70e-03, accuracy: 92.30%\n",
      "Epoch  55/200, val loss: 3.03e-03, accuracy: 89.18%\n",
      "Epoch  56/200, train loss: 1.73e-03, accuracy: 92.24%\n",
      "Epoch  56/200, val loss: 3.71e-03, accuracy: 86.00%\n",
      "Epoch  57/200, train loss: 1.69e-03, accuracy: 92.41%\n",
      "Epoch  57/200, val loss: 3.68e-03, accuracy: 86.84%\n",
      "Epoch  58/200, train loss: 1.73e-03, accuracy: 92.07%\n",
      "Epoch  58/200, val loss: 3.48e-03, accuracy: 87.58%\n",
      "Epoch  59/200, train loss: 1.70e-03, accuracy: 92.48%\n",
      "Epoch  59/200, val loss: 3.84e-03, accuracy: 85.52%\n",
      "Epoch  60/200, train loss: 1.67e-03, accuracy: 92.51%\n",
      "Epoch  60/200, val loss: 3.49e-03, accuracy: 87.84%\n",
      "Epoch  61/200, train loss: 1.66e-03, accuracy: 92.51%\n",
      "Epoch  61/200, val loss: 2.92e-03, accuracy: 88.28%\n",
      "Epoch  62/200, train loss: 1.64e-03, accuracy: 92.65%\n",
      "Epoch  62/200, val loss: 3.20e-03, accuracy: 87.72%\n",
      "Epoch  63/200, train loss: 1.65e-03, accuracy: 92.54%\n",
      "Epoch  63/200, val loss: 3.54e-03, accuracy: 87.18%\n",
      "Epoch  64/200, train loss: 1.64e-03, accuracy: 92.52%\n",
      "Epoch  64/200, val loss: 3.72e-03, accuracy: 86.12%\n",
      "Epoch  65/200, train loss: 1.60e-03, accuracy: 92.79%\n",
      "Epoch  65/200, val loss: 3.43e-03, accuracy: 87.58%\n",
      "Epoch  66/200, train loss: 1.62e-03, accuracy: 92.67%\n",
      "Epoch  66/200, val loss: 4.36e-03, accuracy: 85.10%\n",
      "Epoch  67/200, train loss: 1.60e-03, accuracy: 92.74%\n",
      "Epoch  67/200, val loss: 3.14e-03, accuracy: 88.24%\n",
      "Epoch  68/200, train loss: 1.58e-03, accuracy: 92.99%\n",
      "Epoch  68/200, val loss: 3.21e-03, accuracy: 87.74%\n",
      "Epoch  69/200, train loss: 1.61e-03, accuracy: 92.78%\n",
      "Epoch  69/200, val loss: 3.94e-03, accuracy: 86.84%\n",
      "Epoch  70/200, train loss: 1.57e-03, accuracy: 92.92%\n",
      "Epoch  70/200, val loss: 3.77e-03, accuracy: 86.20%\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-41d6a0615e44>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# Fit model\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresnet\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlr_scheduler\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataloaders\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmax_epochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m200\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpatience\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-17-18cfb536aa13>\u001b[0m in \u001b[0;36mfit\u001b[0;34m(model, optimizer, lr_scheduler, dataloaders, max_epochs, patience)\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmax_epochs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m         \u001b[0mtrain_loss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain_acc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrun_epoch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptimizer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdataloaders\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'train'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtrain\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m         \u001b[0mlr_scheduler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Epoch {epoch + 1: >3}/{max_epochs}, train loss: {train_loss:.2e}, accuracy: {train_acc * 100:.2f}%\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-16-3d8ea17d717c>\u001b[0m in \u001b[0;36mrun_epoch\u001b[0;34m(model, optimizer, dataloader, train)\u001b[0m\n\u001b[1;32m     46\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     47\u001b[0m         \u001b[0;31m# statistics\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 48\u001b[0;31m         \u001b[0mepoch_loss\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     49\u001b[0m         \u001b[0mepoch_acc\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mncorrect\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "optimizer = torch.optim.SGD(resnet.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4)\n",
    "lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[100, 150], gamma=0.1)\n",
    "\n",
    "# Fit model\n",
    "fit(resnet, optimizer, lr_scheduler, dataloaders, max_epochs=200, patience=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the model is trained we run it on the test set to obtain our final accuracy.\n",
    "Note that we can only look at the test set once, everything else would lead to overfitting. So you _must_ ignore the test set while developing your model!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 3.9e-03, accuracy: 85.76%\n"
     ]
    }
   ],
   "source": [
    "test_loss, test_acc = run_epoch(resnet, None, dataloaders['test'], train=False)\n",
    "print(f\"Test loss: {test_loss:.1e}, accuracy: {test_acc * 100:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's almost what was reported in the paper (92.49%) and we didn't even train on the full training set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optional task: Squeeze out all the juice!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you do even better? Have a look at [A Recipe for Training Neural Networks](https://karpathy.github.io/2019/04/25/recipe/) and at the [EfficientNet architecture](https://ai.googleblog.com/2019/05/efficientnet-improving-accuracy-and.html) we discussed in the lecture. Play around with the possibilities PyTorch offers you and see how close you can get to the [state of the art on CIFAR-10](https://paperswithcode.com/sota/image-classification-on-cifar-10).\n",
    "\n",
    "Hint: You can use [Google Colab](https://colab.research.google.com/) to access some free GPUs for your experiments."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}