worked-solutions/04_ellipse_regression_solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regression with a CNN\n",
    "\n",
    "In the previous exercise we used a CNN model to solve a classification problem—namely MNIST handwritten digits.\n",
    "\n",
    "In this exercise we will used the same model to solve a regression problem: estimating the centroid $(x_{\\text{c}}, y_{\\text{c}})$, and the major/minor radii $r_{x}$ and $r_{y}$ of an ellipse.  \n",
    "\n",
    "Recall: an ellipse is defined by\n",
    "$$\n",
    "\\frac{(x - x_{\\text{c}})^{2}}{r_{x}^{2}} + \\frac{(y - y_{\\text{c}})^{2}}{r_{y}^{2}} = 1\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1: Accessing some data\n",
    "\n",
    "For this project, we have created a very simple dataset which yields an image of an ellipse, along with the various parameters that define it as targets.\n",
    "\n",
    "This code can be found in ``src/ml_workshop/_ellipse.py``, though understanding it is not necessary for the exercises (that said, it is very simple)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ml_workshop import EllipseDataset\n",
    "\n",
    "dataset = EllipseDataset(training=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand the data, and how they are presented to us, the easiest thing to do is to plot them. Let's obtain five input--target pairs, plot the images, and overlay the target information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pairs = []\n",
    "for idx in range(5):\n",
    "    pairs.append(dataset[idx])\n",
    "\n",
    "# If you have a list of tuples, you \"unzip\" them into individual lists this way\n",
    "imgs, targets = zip(*pairs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- What types does the image data have?\n",
    "- What types does the target data have?\n",
    "- How is the data presented to us?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The images are of type '<class 'numpy.ndarray'>'\n",
      "The targets are of type '<class 'numpy.ndarray'>'\n",
      "The images have shape '(128, 128, 3)'\n",
      "The targets have shape '(4,)'\n"
     ]
    }
   ],
   "source": [
    "print(f\"The images are of type '{type(imgs[0])}'\")\n",
    "print(f\"The targets are of type '{type(targets[0])}'\")\n",
    "\n",
    "print(f\"The images have shape '{imgs[0].shape}'\")\n",
    "print(f\"The targets have shape '{targets[0].shape}'\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The images are RGB arrays of shape ``(height, width, colour_channels)``.\n",
    "- The targets are arrays holding the coordinate information:\n",
    "  - ``(row_center, col_center, row_radius, col_radius)``.\n",
    "  - There are the four parameters required to define an ellipse.\n",
    "\n",
    "\n",
    "\n",
    "Let us now plot the images, and overlay the target information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x400 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "figure, axes = plt.subplots(1, len(pairs), figsize=(16, 4))\n",
    "\n",
    "for x, y, axis in zip(imgs, targets, axes.ravel()):\n",
    "    axis.imshow(x, extent=(0, 1, 1, 0))\n",
    "    axis.errorbar(\n",
    "        y[1],\n",
    "        y[0],\n",
    "        xerr=y[3],\n",
    "        yerr=y[2],\n",
    "        marker=\"o\",\n",
    "        color=\"k\",\n",
    "        capsize=10,\n",
    "    )\n",
    "    axis.set_title(f\"Centroid: ({y[1]:.2f}, {y[0]:.2f})\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note: The coordinate information is always expressed in fractions of the linear dimension of the images, so we don't need to worry about normalising the data, and we have natural bounds for the interval on which our predictions should lie."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 3: ``Dataset`` $\\to$ ``DataLoader``\n",
    "\n",
    "As before, wrap the ``Dataset``s in ``DataLoader``s.\n",
    "\n",
    "- First, reinstantiate the datasets, then provide ``Compose`` objects containing the transforms required to map from numpy arrays to torch tensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision.transforms import Compose, ToTensor\n",
    "from torch import from_numpy, float32\n",
    "\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "train_set = EllipseDataset(\n",
    "    training=True,\n",
    "    input_tfms=Compose([ToTensor()]),\n",
    "    target_tfms=Compose([lambda x: from_numpy(x).float()]),\n",
    ")\n",
    "valid_set = EllipseDataset(\n",
    "    training=False,\n",
    "    input_tfms=Compose([ToTensor()]),\n",
    "    target_tfms=Compose([lambda x: from_numpy(x).float()]),\n",
    ")\n",
    "\n",
    "\n",
    "batch_size = 8\n",
    "\n",
    "train_loader = DataLoader(train_set, batch_size=batch_size, shuffle=True)\n",
    "valid_loader = DataLoader(valid_set, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 4: Choose a model architecture\n",
    "\n",
    "Let's use the same CNN as we did before (``MOBILENET`` small) since it's relatively lightweight.\n",
    "\n",
    "- Instantiate the model and print it out."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MobileNetV3(\n",
      "  (features): Sequential(\n",
      "    (0): Conv2dNormActivation(\n",
      "      (0): Conv2d(3, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
      "      (1): BatchNorm2d(16, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "      (2): Hardswish()\n",
      "    )\n",
      "    (1): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(16, 16, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=16, bias=False)\n",
      "          (1): BatchNorm2d(16, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): ReLU(inplace=True)\n",
      "        )\n",
      "        (1): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(16, 8, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(8, 16, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (2): Conv2dNormActivation(\n",
      "          (0): Conv2d(16, 16, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(16, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (2): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(16, 72, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(72, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): ReLU(inplace=True)\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(72, 72, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), groups=72, bias=False)\n",
      "          (1): BatchNorm2d(72, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): ReLU(inplace=True)\n",
      "        )\n",
      "        (2): Conv2dNormActivation(\n",
      "          (0): Conv2d(72, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(24, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (3): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(24, 88, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(88, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): ReLU(inplace=True)\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(88, 88, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=88, bias=False)\n",
      "          (1): BatchNorm2d(88, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): ReLU(inplace=True)\n",
      "        )\n",
      "        (2): Conv2dNormActivation(\n",
      "          (0): Conv2d(88, 24, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(24, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (4): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(24, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(96, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(96, 96, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), groups=96, bias=False)\n",
      "          (1): BatchNorm2d(96, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(96, 24, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(24, 96, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(96, 40, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(40, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (5): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(40, 240, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(240, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(240, 240, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=240, bias=False)\n",
      "          (1): BatchNorm2d(240, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(240, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(64, 240, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(240, 40, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(40, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (6): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(40, 240, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(240, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(240, 240, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=240, bias=False)\n",
      "          (1): BatchNorm2d(240, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(240, 64, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(64, 240, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(240, 40, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(40, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (7): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(40, 120, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(120, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(120, 120, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=120, bias=False)\n",
      "          (1): BatchNorm2d(120, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(120, 32, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(32, 120, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(120, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(48, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (8): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(48, 144, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(144, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(144, 144, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=144, bias=False)\n",
      "          (1): BatchNorm2d(144, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(144, 40, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(40, 144, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(144, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(48, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (9): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(48, 288, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(288, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(288, 288, kernel_size=(5, 5), stride=(2, 2), padding=(2, 2), groups=288, bias=False)\n",
      "          (1): BatchNorm2d(288, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(288, 72, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(72, 288, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(288, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(96, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (10): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(576, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(576, 576, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=576, bias=False)\n",
      "          (1): BatchNorm2d(576, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(576, 144, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(144, 576, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(96, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (11): InvertedResidual(\n",
      "      (block): Sequential(\n",
      "        (0): Conv2dNormActivation(\n",
      "          (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(576, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (1): Conv2dNormActivation(\n",
      "          (0): Conv2d(576, 576, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), groups=576, bias=False)\n",
      "          (1): BatchNorm2d(576, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "          (2): Hardswish()\n",
      "        )\n",
      "        (2): SqueezeExcitation(\n",
      "          (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "          (fc1): Conv2d(576, 144, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (fc2): Conv2d(144, 576, kernel_size=(1, 1), stride=(1, 1))\n",
      "          (activation): ReLU()\n",
      "          (scale_activation): Hardsigmoid()\n",
      "        )\n",
      "        (3): Conv2dNormActivation(\n",
      "          (0): Conv2d(576, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "          (1): BatchNorm2d(96, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "        )\n",
      "      )\n",
      "    )\n",
      "    (12): Conv2dNormActivation(\n",
      "      (0): Conv2d(96, 576, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "      (1): BatchNorm2d(576, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)\n",
      "      (2): Hardswish()\n",
      "    )\n",
      "  )\n",
      "  (avgpool): AdaptiveAvgPool2d(output_size=1)\n",
      "  (classifier): Sequential(\n",
      "    (0): Linear(in_features=576, out_features=1024, bias=True)\n",
      "    (1): Hardswish()\n",
      "    (2): Dropout(p=0.2, inplace=True)\n",
      "    (3): Linear(in_features=1024, out_features=1000, bias=True)\n",
      "  )\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "from torchvision.models import mobilenet_v3_small\n",
    "from torchvision.models import MobileNet_V3_Small_Weights\n",
    "\n",
    "model = mobilenet_v3_small(weights=MobileNet_V3_Small_Weights.DEFAULT)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Task 5: Uh oh, we've a problem—again.\n",
    " - The model again has 1000 output features.\n",
    "   - How many do we need?\n",
    "- Modify the number of output features, as we did in the previous exercise, accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn import Linear\n",
    "\n",
    "model.classifier[3] = Linear(model.classifier[3].in_features, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 5: Set up the remaining PyTorch bits and bobs\n",
    "\n",
    "- We need to choose a loss function appropriate for _regression_.\n",
    "  - Can you remember what we chose previously?\n",
    "- We need an optimiser, too.\n",
    "  - Remember our friend, Adam?\n",
    "- Instantiate the model and loss function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.nn import MSELoss\n",
    "from torch.optim import Adam\n",
    "\n",
    "loss_func = MSELoss()\n",
    "\n",
    "optimiser = Adam(model.parameters(), lr=1e-4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 6: Set the device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mps\n"
     ]
    }
   ],
   "source": [
    "import torch.cuda as cuda\n",
    "import torch.backends.mps as mps\n",
    "\n",
    "if cuda.is_available():\n",
    "    DEVICE = \"cuda\"\n",
    "elif mps.is_available():\n",
    "    DEVICE = \"mps\"\n",
    "else:\n",
    "    DEVICE = \"cpu\"\n",
    "\n",
    "print(DEVICE)\n",
    "\n",
    "# Note: here the return/assignment to ``_`` is just to suppress the print.\n",
    "# The model is moved onto the correct device in-place.\n",
    "_ = model.to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 7: Writing our training and validation loops\n",
    "\n",
    "As before, we need to write our training and validation loops.\n",
    "\n",
    "- Complete the training loop\n",
    "- Complete the validation loop\n",
    "- What metrics can we extract in a regression problem?\n",
    "\n",
    "\n",
    "Things to consider:\n",
    "- Using the ``ReLU`` activation function to stop our outputs being negative.\n",
    "    - Since the quantities we are estimating lie on the interval [0, 1], and we are dealing with coordinates we don't want to be negative, it makes sense to apply the ``ReLU`` activation function.\n",
    "- Any other activation functions might we use to bound our outputs?\n",
    "    - Technically, we might use the Sigmoid, which would bound our inputs to (0, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict\n",
    "\n",
    "from torch import no_grad\n",
    "from torch.nn import Module\n",
    "from numpy import mean\n",
    "\n",
    "\n",
    "def train_one_epoch(\n",
    "    model: Module,\n",
    "    train_loader: DataLoader,\n",
    "    optimiser: Adam,\n",
    "    loss_func: MSELoss,\n",
    ") -> Dict[str, float]:\n",
    "    \"\"\"Train the model for a single epoch.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : Module\n",
    "        A neural network.\n",
    "    train_loader : DataLoader\n",
    "        The ``DataLoader`` for the training set.\n",
    "    optimiser : Adam\n",
    "        The optimiser to update the model's parameters with.\n",
    "    loss_func : BCELoss\n",
    "        Binary-cross-entropy loss function.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    Dict[str, float]\n",
    "        A dictionary of metrics.\n",
    "\n",
    "    \"\"\"\n",
    "    model.train()\n",
    "\n",
    "    metrics = {\"loss\": []}\n",
    "\n",
    "    for batch, targets in train_loader:\n",
    "        optimiser.zero_grad()\n",
    "\n",
    "        batch, targets = batch.to(DEVICE), targets.to(DEVICE)\n",
    "\n",
    "        preds = model(batch).relu()\n",
    "\n",
    "        loss = loss_func(preds, targets)\n",
    "\n",
    "        loss.backward()\n",
    "\n",
    "        optimiser.step()\n",
    "\n",
    "        metrics[\"loss\"].append(loss.item())\n",
    "\n",
    "    return {key: mean(val) for key, val in metrics.items()}\n",
    "\n",
    "\n",
    "@no_grad()\n",
    "def validate_one_epoch(\n",
    "    model: Module,\n",
    "    valid_loader: DataLoader,\n",
    "    loss_func: MSELoss,\n",
    ") -> Dict[str, float]:\n",
    "    \"\"\"Train the model for a single epoch.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    model : Module\n",
    "        A neural network.\n",
    "     valid_loader : DataLoader\n",
    "        The ``DataLoader`` for the validation set.\n",
    "    loss_func : BCELoss\n",
    "        Binary-cross-entropy loss function.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    Dict[str, float]\n",
    "        A dictionary of metrics.\n",
    "\n",
    "    \"\"\"\n",
    "    model.eval()\n",
    "\n",
    "    metrics = {\"loss\": []}\n",
    "\n",
    "    for batch, targets in valid_loader:\n",
    "        batch, targets = batch.to(DEVICE), targets.to(DEVICE)\n",
    "\n",
    "        preds = model(batch).relu()\n",
    "\n",
    "        loss = loss_func(preds, targets)\n",
    "\n",
    "        metrics[\"loss\"].append(loss.item())\n",
    "\n",
    "    return {key: mean(val) for key, val in metrics.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 8: Training, extracting and plotting metrics\n",
    "\n",
    "- Now we can train our model for a specified number of epochs.\n",
    "  - During each epoch the model \"sees\" each training item once.\n",
    "- Append the training and validation metrics to a list.\n",
    "- Turn them into a ``pandas.DataFrame``\n",
    "  - Note: You can turn a ``List[Dict[str, float]]``, say ``my_list`` into a ``DataFrame`` with ``DataFrame(my_list)``.\n",
    "- Use Matplotlib to plot the training and validation metrics as a function of the number of epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 \t 16.821 seconds \t Valid Loss: 0.0692\n",
      "Epoch: 1 \t 14.057 seconds \t Valid Loss: 0.0447\n",
      "Epoch: 2 \t 14.134 seconds \t Valid Loss: 0.0330\n",
      "Epoch: 3 \t 14.297 seconds \t Valid Loss: 0.0259\n",
      "Epoch: 4 \t 14.335 seconds \t Valid Loss: 0.0212\n",
      "Epoch: 5 \t 14.271 seconds \t Valid Loss: 0.0172\n",
      "Epoch: 6 \t 14.369 seconds \t Valid Loss: 0.0131\n",
      "Epoch: 7 \t 14.126 seconds \t Valid Loss: 0.0116\n",
      "Epoch: 8 \t 14.616 seconds \t Valid Loss: 0.0083\n",
      "Epoch: 9 \t 14.339 seconds \t Valid Loss: 0.0073\n",
      "Epoch: 10 \t 14.754 seconds \t Valid Loss: 0.0057\n",
      "Epoch: 11 \t 14.879 seconds \t Valid Loss: 0.0052\n",
      "Epoch: 12 \t 16.407 seconds \t Valid Loss: 0.0042\n",
      "Epoch: 13 \t 14.434 seconds \t Valid Loss: 0.0042\n",
      "Epoch: 14 \t 14.186 seconds \t Valid Loss: 0.0037\n",
      "Epoch: 15 \t 14.137 seconds \t Valid Loss: 0.0036\n",
      "Epoch: 16 \t 14.283 seconds \t Valid Loss: 0.0028\n",
      "Epoch: 17 \t 15.109 seconds \t Valid Loss: 0.0031\n",
      "Epoch: 18 \t 14.442 seconds \t Valid Loss: 0.0023\n",
      "Epoch: 19 \t 14.299 seconds \t Valid Loss: 0.0021\n",
      "Epoch: 20 \t 14.506 seconds \t Valid Loss: 0.0020\n",
      "Epoch: 21 \t 14.373 seconds \t Valid Loss: 0.0022\n",
      "Epoch: 22 \t 14.499 seconds \t Valid Loss: 0.0022\n",
      "Epoch: 23 \t 14.506 seconds \t Valid Loss: 0.0016\n",
      "Epoch: 24 \t 14.616 seconds \t Valid Loss: 0.0014\n",
      "Epoch: 25 \t 14.537 seconds \t Valid Loss: 0.0015\n",
      "Epoch: 26 \t 14.383 seconds \t Valid Loss: 0.0021\n",
      "Epoch: 27 \t 14.137 seconds \t Valid Loss: 0.0012\n",
      "Epoch: 28 \t 14.049 seconds \t Valid Loss: 0.0010\n",
      "Epoch: 29 \t 14.079 seconds \t Valid Loss: 0.0012\n",
      "Epoch: 30 \t 14.161 seconds \t Valid Loss: 0.0013\n",
      "Epoch: 31 \t 14.226 seconds \t Valid Loss: 0.0013\n",
      "Epoch: 32 \t 14.257 seconds \t Valid Loss: 0.0012\n",
      "Epoch: 33 \t 14.313 seconds \t Valid Loss: 0.0009\n",
      "Epoch: 34 \t 14.263 seconds \t Valid Loss: 0.0008\n",
      "Epoch: 35 \t 14.333 seconds \t Valid Loss: 0.0008\n",
      "Epoch: 36 \t 14.139 seconds \t Valid Loss: 0.0009\n",
      "Epoch: 37 \t 14.196 seconds \t Valid Loss: 0.0007\n",
      "Epoch: 38 \t 14.258 seconds \t Valid Loss: 0.0008\n",
      "Epoch: 39 \t 14.263 seconds \t Valid Loss: 0.0007\n",
      "Epoch: 40 \t 14.297 seconds \t Valid Loss: 0.0007\n",
      "Epoch: 41 \t 14.116 seconds \t Valid Loss: 0.0005\n",
      "Epoch: 42 \t 14.031 seconds \t Valid Loss: 0.0007\n",
      "Epoch: 43 \t 14.381 seconds \t Valid Loss: 0.0006\n",
      "Epoch: 44 \t 14.332 seconds \t Valid Loss: 0.0005\n",
      "Epoch: 45 \t 14.264 seconds \t Valid Loss: 0.0006\n",
      "Epoch: 46 \t 14.450 seconds \t Valid Loss: 0.0006\n",
      "Epoch: 47 \t 14.175 seconds \t Valid Loss: 0.0006\n",
      "Epoch: 48 \t 14.217 seconds \t Valid Loss: 0.0005\n",
      "Epoch: 49 \t 14.168 seconds \t Valid Loss: 0.0005\n",
      "    loss_train  loss_valid\n",
      "0     0.077947    0.069175\n",
      "1     0.052645    0.044654\n",
      "2     0.040534    0.033005\n",
      "3     0.034531    0.025921\n",
      "4     0.027616    0.021177\n",
      "5     0.023071    0.017218\n",
      "6     0.019110    0.013058\n",
      "7     0.016862    0.011574\n",
      "8     0.014294    0.008338\n",
      "9     0.012575    0.007320\n",
      "10    0.011072    0.005727\n",
      "11    0.009764    0.005211\n",
      "12    0.009239    0.004189\n",
      "13    0.007983    0.004179\n",
      "14    0.007931    0.003688\n",
      "15    0.007465    0.003553\n",
      "16    0.007052    0.002779\n",
      "17    0.006354    0.003119\n",
      "18    0.006300    0.002326\n",
      "19    0.005469    0.002121\n",
      "20    0.005444    0.002000\n",
      "21    0.004803    0.002246\n",
      "22    0.004903    0.002184\n",
      "23    0.004365    0.001580\n",
      "24    0.003987    0.001397\n",
      "25    0.004098    0.001515\n",
      "26    0.003522    0.002073\n",
      "27    0.003279    0.001245\n",
      "28    0.003153    0.001005\n",
      "29    0.003155    0.001179\n",
      "30    0.003105    0.001342\n",
      "31    0.002849    0.001304\n",
      "32    0.002554    0.001172\n",
      "33    0.002525    0.000918\n",
      "34    0.002358    0.000750\n",
      "35    0.002016    0.000806\n",
      "36    0.001992    0.000851\n",
      "37    0.001894    0.000697\n",
      "38    0.001824    0.000809\n",
      "39    0.001704    0.000741\n",
      "40    0.001633    0.000685\n",
      "41    0.001513    0.000547\n",
      "42    0.001305    0.000717\n",
      "43    0.001443    0.000583\n",
      "44    0.001277    0.000531\n",
      "45    0.001235    0.000586\n",
      "46    0.001210    0.000564\n",
      "47    0.001154    0.000588\n",
      "48    0.001110    0.000546\n",
      "49    0.000997    0.000538\n"
     ]
    }
   ],
   "source": [
    "from pandas import DataFrame\n",
    "from time import perf_counter\n",
    "\n",
    "\n",
    "epochs = 50\n",
    "\n",
    "train_metrics, valid_metrics = [], []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    start_time = perf_counter()\n",
    "\n",
    "    train_metrics.append(\n",
    "        train_one_epoch(\n",
    "            model,\n",
    "            train_loader,\n",
    "            optimiser,\n",
    "            loss_func,\n",
    "        )\n",
    "    )\n",
    "\n",
    "    valid_metrics.append(validate_one_epoch(model, valid_loader, loss_func))\n",
    "\n",
    "    stop_time = perf_counter()\n",
    "\n",
    "    if epoch % 1 == 0:\n",
    "        print(\n",
    "            f\"Epoch: {epoch} \\t {stop_time - start_time:.3f} seconds \\t Valid Loss: {valid_metrics[-1]['loss']:.4f}\"\n",
    "        )\n",
    "\n",
    "\n",
    "train_metrics = DataFrame(train_metrics)\n",
    "valid_metrics = DataFrame(valid_metrics)\n",
    "\n",
    "metrics = train_metrics.join(valid_metrics, lsuffix=\"_train\", rsuffix=\"_valid\")\n",
    "\n",
    "print(metrics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 9: Plotting our metrics\n",
    "\n",
    "- Plot the loss for the training and validation sets at the end of each epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'MSE Loss')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure, axis = plt.subplots(1, 1)\n",
    "\n",
    "axis.plot(metrics.loss_train, \"-o\", label=\"Training loss\")\n",
    "axis.plot(metrics.loss_valid, \"-o\", label=\"Validation loss\")\n",
    "\n",
    "axis.set_yscale(\"log\")\n",
    "\n",
    "axis.legend(fontsize=15)\n",
    "\n",
    "axis.set_xlabel(\"Epoch\", fontsize=15)\n",
    "axis.set_ylabel(\"MSE Loss\", fontsize=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 10: Visualising some results\n",
    "\n",
    "- When we first looked at the data, we plotted the images and overlayed the coordinate information.\n",
    "  - Let's do this again, now using the model's predictions rather than the ground truths.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x250 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# This simply grabs us one mini-batch of data.\n",
    "batch, targets = next(iter(valid_loader))\n",
    "\n",
    "model = model.to(\"cpu\")\n",
    "model.eval()\n",
    "\n",
    "with no_grad():\n",
    "    preds = model(batch).relu()\n",
    "\n",
    "figure, axes = plt.subplots(1, len(preds), figsize=(len(preds) * 2.5, 2.5))\n",
    "\n",
    "for image, pred, axis in zip(batch, preds, axes.ravel()):\n",
    "    axis.imshow(image.permute(1, 2, 0), extent=(0, 1, 1, 0))\n",
    "    axis.errorbar(\n",
    "        pred[1].item(),\n",
    "        pred[0].item(),\n",
    "        marker=\"o\",\n",
    "        yerr=pred[2].item(),\n",
    "        xerr=pred[3].item(),\n",
    "        color=\"k\",\n",
    "        capsize=10,\n",
    "    )\n",
    "\n",
    "    axis.set_xlim(left=0.0, right=1.0)\n",
    "    axis.set_ylim(bottom=0.0, top=1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 11\n",
    "\n",
    "- Re-run the previous cell over and over.\n",
    "- Do the results look good, or not?\n",
    "- Train the model for longer—say 50 epochs—and re-evaluate.\n",
    "- Head off into the sunset with a smile at your new-found skills in implementing machine learning.\n"
   ]
  }
 ],
 "metadata": {
  "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}