5.0-tl-pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Please Note**: We updated the requirements.txt\n",
    "\n",
    "Please install the new requirements before editing this exercise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "from vll.utils.download import download_mnist\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import skimage\n",
    "import skimage.io\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torchvision import transforms\n",
    "\n",
    "from models.mnist.simple_cnn import Net"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1\n",
    "(2 points)\n",
    "\n",
    "In this task, you will learn some basic tensor operations using the PyTorch library.\n",
    "\n",
    "Reference for torch: https://pytorch.org/docs/stable/torch.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a numpy array that looks like this: [0, 1, 2, ..., 19]\n",
    "arr = \n",
    "\n",
    "# Convert the numpy array to a torch tensor\n",
    "tensor = \n",
    "print(tensor)\n",
    "\n",
    "# Create a tensor that contains random numbers.\n",
    "# It should have the same size like the numpy array.\n",
    "# Multiply it with the previous tensor.\n",
    "rand_tensor = \n",
    "tensor = \n",
    "print(tensor)\n",
    "\n",
    "# Create a tensor that contains only 1s.\n",
    "# It should have the same size like the numpy array.\n",
    "# Substract it from the previous tensor.\n",
    "tensor = \n",
    "print(tensor)\n",
    "\n",
    "# Get the 5th element using a index.\n",
    "element = \n",
    "print(element)\n",
    "\n",
    "# Create a tensor that contains only 0s.\n",
    "# It should have the same size like the numpy array.\n",
    "# Multiply it with the previous tensor without any assignment (in place).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the image from the last exercise as RGB image.\n",
    "image = \n",
    "\n",
    "# Convert the image to a tensor\n",
    "image = \n",
    "\n",
    "# Print its shape\n",
    "print(image.shape)\n",
    "\n",
    "# Flatten the image\n",
    "image = \n",
    "print(len(image))\n",
    "\n",
    "# Add another dimension resulting in a 1x78643 tensor\n",
    "\n",
    "print(image.shape)\n",
    "\n",
    "# Revert the last action\n",
    "\n",
    "print(image.shape)\n",
    "\n",
    "# Reshape the tensor, so that it has the original 2D dimensions\n",
    "image = \n",
    "print(image.shape)\n",
    "\n",
    "# Calculate the sum, mean and max of the tensor\n",
    "print(torch.sum(image))\n",
    "print(torch.mean(image))\n",
    "print(torch.max(image))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2\n",
    "(2 points)\n",
    "\n",
    "Use Autograd to perform operations on a tensor and output then gradients."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random 2x2 tensor which requires gradients\n",
    "x = \n",
    "print(x)\n",
    "\n",
    "# Create another tensor by adding 2.0\n",
    "y = \n",
    "print(y)\n",
    "\n",
    "# Create a third tensor z = y^2\n",
    "z = \n",
    "print(z)\n",
    "\n",
    "# Compute out as the mean of values in z\n",
    "out = \n",
    "print(out)\n",
    "\n",
    "# Perform back propagation on out\n",
    "\n",
    "\n",
    "# Print the gradients dout/dx\n",
    "\n",
    "\n",
    "# Create a copy of y whithout gradients\n",
    "y2 = \n",
    "print(y2.requires_grad)\n",
    "\n",
    "# Perform the mean operation on z\n",
    "# with gradients globally disabled\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3\n",
    "(3 points)\n",
    "\n",
    "Implement a Dataset class for MNIST."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We first download the MNIST dataset\n",
    "download_mnist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MNIST:\n",
    "    \"\"\"\n",
    "    Dataset class for MNIST\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, root, transform=None):\n",
    "        \"\"\"\n",
    "        root -- path to either \"training\" or \"testing\"\n",
    "        \n",
    "        transform -- transform (from torchvision.transforms)\n",
    "                     to be applied to the data\n",
    "        \"\"\"\n",
    "        # save transforms\n",
    "        self.transform = transform\n",
    "        \n",
    "        # TODO: create a list of all subdirectories (named like the classes) \n",
    "        #       within the dataset root\n",
    "        \n",
    "        \n",
    "        # TODO: create a list of paths to all images\n",
    "        #       with the ground truth label\n",
    "        \n",
    "    \n",
    "    def __len__(self):\n",
    "        \"\"\"\n",
    "        Returns the lenght of the dataset (number of images)\n",
    "        \"\"\"\n",
    "        # TODO: return the length (number of images) of the dataset\n",
    "        \n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        \"\"\"\n",
    "        Loads and returns one image as floating point numpy array\n",
    "        \n",
    "        index -- image index in [0, self.__len__() - 1]\n",
    "        \"\"\"\n",
    "        # TODO: load the ith image as an numpy array (dtype=float32)\n",
    "        \n",
    "        \n",
    "        # TODO: apply transforms to the image (if there are any)\n",
    "        \n",
    "        \n",
    "        # TODO: return a tuple (transformed image, ground truth)\n",
    "       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 4\n",
    "(3 points)\n",
    "\n",
    "You can now load a pretrained neural network model we provide.\n",
    "Your last task is to run the model on the MNIST test dataset, plot some example images with the predicted labels and compute the prediction accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validate(model, data_loader):\n",
    "    # TODO: Create a 10x10 grid of subplots\n",
    "   \n",
    "    \n",
    "    model.eval()\n",
    "    correct = 0 # count for correct predictions\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for i, item in enumerate(data_loader):\n",
    "            # TODO: unpack item into image and ground truth\n",
    "            #       and run network on them\n",
    "            \n",
    "            \n",
    "            # TODO: get class with highest probability\n",
    "            \n",
    "            \n",
    "            # TODO: check if prediction is correct\n",
    "            #       and add it to correct count\n",
    "            \n",
    "            \n",
    "            # plot the first 100 images\n",
    "            if i < 100:\n",
    "                # TODO: compute position of ith image in the grid\n",
    "                \n",
    "                \n",
    "                # TODO: convert image tensor to numpy array\n",
    "                #       and normalize to [0, 1]\n",
    "                \n",
    "                \n",
    "                # TODO: make wrongly predicted images red\n",
    "                \n",
    "                \n",
    "                # TODO: disable axis and show image\n",
    "                \n",
    "                \n",
    "                # TODO: show the predicted class next to each image\n",
    "                \n",
    "            \n",
    "            elif i == 100:\n",
    "                plt.show()\n",
    "    \n",
    "    # TODO: compute and print the prediction accuracy in percent\n",
    "    \n",
    "\n",
    "# create a DataLoader using the implemented MNIST dataset class\n",
    "data_loader = torch.utils.data.DataLoader(\n",
    "    MNIST('data/mnist/testing',\n",
    "    transform=transforms.Compose([\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize((0.1307,), (0.3081,))\n",
    "    ])),\n",
    "    batch_size=1, shuffle=True)\n",
    "\n",
    "# create the neural network\n",
    "model = Net()\n",
    "\n",
    "# load the statedict from 'models/mnist/simple_cnn.pt'\n",
    "model.load_state_dict(torch.load('models/mnist/simple_cnn.pt'))\n",
    "\n",
    "# validate the model\n",
    "validate(model, data_loader)"
   ]
  }
 ],
 "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
}