{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tutorial 1 - Neural network intro\n",
    "\n",
    "In this tutorial, we'll introduce the **Python** programming language and some of its libraries, most notably [PyTorch](https://pytorch.org/).\n",
    "\n",
    "The approaches used by PyTorch are broadly applicable to other frameworks as well, such as [TensorFlow](https://www.tensorflow.org/), [JAX](https://docs.jax.dev/en/latest/), [Flux.jl](https://fluxml.ai/) or [Deep Learning Toolbox](https://www.mathworks.com/products/deep-learning.html).\n",
    "\n",
    "For a more detailed overview of PyTorch you can also go through the [oficial tutorials](https://pytorch.org/tutorials/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Package installation with uv and Jupyter\n",
    "\n",
    "We'll first install the [uv](https://docs.astral.sh/uv/) package manager. We can install Jupyter system-wide with uv by running:\n",
    "\n",
    "```bash\n",
    "$ uv tool install jupyterlab\n",
    "```\n",
    "\n",
    "We need to create a uv project and connect it to Jupyter:\n",
    "```bash\n",
    "$ uv init\n",
    "$ uv add --dev ipykernel\n",
    "$ uv run ipython kernel install --user --env VIRTUAL_ENV $(pwd)/.venv --name=tzn\n",
    "```\n",
    "\n",
    "In order for the newly installed Jupyter kernel to be available, we need to restart Jupyter.\n",
    "\n",
    "Finally, we can install the required packages:\n",
    "```bash\n",
    "$ uv add matplotlib numpy scikit-learn torch torch-geometric torchvision\n",
    "$ uv add torch-cluster -f https://data.pyg.org/whl/torch-2.8.0+cpu.html\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 1\n",
    "\n",
    "Run the aforementioned steps to create a package and have the next cell run without errors. It should print something like `Torch version: 2.8.0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Torch version: 2.8.0+cu128\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "\n",
    "print(\"Torch version:\", torch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tensors and working with them in PyTorch\n",
    "\n",
    "Let's first take a look at how to create and manipulate tensors and what is happening in the background in order to automatically compute gradients. \n",
    "\n",
    "A tensor is in essence a name for an array with $n$ dimentisons - i. e. like the `ndarray` in numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create a PyTorch tensor by converting from python or numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1, 2],\n",
      "        [3, 4]])\n"
     ]
    }
   ],
   "source": [
    "a = torch.tensor([[1, 2], [3,4]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also convert it back to numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "print(a.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tensor always has the attributes `shape` and `dtype`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape: torch.Size([2, 2])\n",
      "Element data type: torch.int64\n"
     ]
    }
   ],
   "source": [
    "print('Shape:', a.shape)\n",
    "print('Element data type:', a.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other ways of constructing a tensor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1.]])\n",
      "tensor([[0., 0., 0.]])\n",
      "tensor([[1.1132, 2.5485, 1.5703, 0.0552]])\n",
      "tensor([[0.0648, 0.4012, 0.1246, 0.3300]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.ones((1, 3)))\n",
    "print(torch.zeros((1, 3)))\n",
    "print(torch.randn((1, 4))) # Normal distribution\n",
    "print(torch.rand((1, 4))) # Uniform distribution on [0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do basic operations with PyTorch tensors. Let's construct three tensors with the same dtype:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 2.],\n",
      "        [3., 4.]])\n",
      "tensor([[1.],\n",
      "        [1.]])\n",
      "tensor([[1.2934],\n",
      "        [0.4699]])\n"
     ]
    }
   ],
   "source": [
    "a = torch.tensor([[1, 2], [3,4]], dtype = torch.float32)\n",
    "b = torch.ones((2, 1))\n",
    "c = torch.randn((2, 1))\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix multiplication:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[3.],\n",
      "        [7.]])\n"
     ]
    }
   ],
   "source": [
    "print(a.matmul(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Element-wise addition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[2.2934],\n",
      "        [1.4699]])\n"
     ]
    }
   ],
   "source": [
    "print(b.add(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Element-wise square:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  4.],\n",
      "        [ 9., 16.]])\n"
     ]
    }
   ],
   "source": [
    "print(a.square())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Euclidean norm of a vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.4142)\n"
     ]
    }
   ],
   "source": [
    "print(b.norm())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix rank:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(2)\n"
     ]
    }
   ],
   "source": [
    "print(torch.linalg.matrix_rank(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Element-wise application of the sine function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.8415,  0.9093],\n",
      "        [ 0.1411, -0.7568]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.sin(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean indicator of whether each element is greater than 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[False,  True],\n",
      "        [ True,  True]])\n"
     ]
    }
   ],
   "source": [
    "print(a.greater(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 2 - basics of working with data\n",
    "\n",
    "Let's load the [MNIST](https://en.wikipedia.org/wiki/MNIST_database) dataset and calculate the average value of each feature. Running the next cell for the first time downloads the dataset and may take a while."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = datasets.MNIST(\n",
    "    root = \"data\",\n",
    "    download = True,\n",
    "    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(0, 1)])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've loaded images from the MNIST dataset. Now try to calculate the average value of each feature accross all images. Use the [`DataLoader`](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solution\n",
    "\n",
    "Our data have the following shape and data type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dataset MNIST\n",
       "    Number of datapoints: 60000\n",
       "    Root location: data\n",
       "    Split: Train\n",
       "    StandardTransform\n",
       "Transform: Compose(\n",
       "               ToTensor()\n",
       "               Normalize(mean=0, std=1)\n",
       "           )"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 28, 28])\n",
      "torch.float32\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "print(data[0][0].shape)\n",
    "print(data[0][0].dtype)\n",
    "print(data[0][1]) # Label"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make working with the data easier, let's load it with the `DataLoader` helper class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloader = DataLoader(data, batch_size = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's calculate the average of all images:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_image = torch.zeros(data[0][0].shape, dtype = data[0][0].dtype)\n",
    "\n",
    "for image, _label in dataloader:\n",
    "    mean_image += image[0, :, :, :] # First dimension is the batch, here of size 1\n",
    "\n",
    "mean_image /= len(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's plot this with `matplotlib`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x77ca18070dd0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 10))\n",
    "plt.xticks([])\n",
    "plt.yticks([])\n",
    "plt.grid(False)\n",
    "plt.imshow(torch.reshape(mean_image, [mean_image.shape[1], mean_image.shape[2]]), cmap = plt.cm.bone)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Automatic gradient calculation\n",
    "\n",
    "To automatically calculate gradients, we use the regular `torch.Tensor`. To calculate gradients with respect to some variable, we need to set it to `requires_grad = True`. This will make PyTorch track all operations which depend on this variable. To actually calculate the gradient, we need to call the `fun.backward()` method, which will calculate th derivative of `fun` with respect to all the input variables. If `fun` is of greater dimension than 1, we need to pass to `backward` a tensor with repspect to which to calculate the Jacobian."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1., 2., 3.], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([1, 2, 3], dtype = torch.float32, requires_grad = True)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Derivative of x^2: tensor([2., 4., 6.])\n",
      "2*x: tensor([2., 4., 6.])\n"
     ]
    }
   ],
   "source": [
    "f = torch.square(x)\n",
    "f.backward(torch.ones_like(f))\n",
    "\n",
    "print('Derivative of x^2:', x.grad)\n",
    "with torch.no_grad():\n",
    "    print('2*x:', 2*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1., 2., 3.], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor([1, 2, 3], dtype = torch.float32, requires_grad = True)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Derivative of sin(x): tensor([ 0.5403, -0.4161, -0.9900])\n",
      "cos(x): tensor([ 0.5403, -0.4161, -0.9900])\n"
     ]
    }
   ],
   "source": [
    "f = torch.sin(x)\n",
    "f.backward(torch.ones_like(f))\n",
    "    \n",
    "print('Derivative of sin(x):', x.grad)\n",
    "with torch.no_grad():\n",
    "    print('cos(x):', torch.cos(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic neural net on the MNIST dataset\n",
    "\n",
    "Let's define the basic parameters of the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 50\n",
    "hidden_layer_width = 100\n",
    "output_width = 10\n",
    "learning_rate = 0.01"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's load the training and testing data and create a `DataLoader` for each:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train = datasets.MNIST(\n",
    "    root = \"data\",\n",
    "    train = True,\n",
    "    download = True,\n",
    "    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(0, 1)])\n",
    ")\n",
    "data_test = datasets.MNIST(\n",
    "    root = \"data\",\n",
    "    train = False,\n",
    "    download = True,\n",
    "    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(0, 1)])\n",
    ")\n",
    "\n",
    "dataloader_train = DataLoader(data_train, batch_size = batch_size, shuffle = True)\n",
    "dataloader_test = DataLoader(data_test, batch_size = batch_size, shuffle = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll create a simple neural network using `torch.nn.Sequential`, which is a class to put several layers into sequentially in the order of their insertion.\n",
    "\n",
    "The input layer will be a `torch.nn.Flatten`, which will convert the 2D images into vectors.\n",
    "\n",
    "`torch.nn.Sequential` is a specialization of the more general [`tf.nn.Module`](https://pytorch.org/docs/main/generated/torch.nn.Module.html) class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Flatten(start_dim=1, end_dim=-1)\n",
       ")"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = nn.Sequential()\n",
    "model.append(nn.Flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's add one hidden layer with the `tanh` activation function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Flatten(start_dim=1, end_dim=-1)\n",
       "  (1): Linear(in_features=784, out_features=100, bias=True)\n",
       "  (2): Tanh()\n",
       ")"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.append(nn.Linear(data_train.data.shape[1] * data_train.data.shape[2], hidden_layer_width))\n",
    "model.append(nn.Tanh())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, let's add an output layer with 10 neurons (= number of classes) and the softmax activation function: \n",
    "$$ \\sigma \\left( \\vec{z} \\right)_i = \\frac{e^{\\vec{z}_i}}{\\sum_{j = 1}^K e^{\\vec{z}_j}} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Flatten(start_dim=1, end_dim=-1)\n",
       "  (1): Linear(in_features=784, out_features=100, bias=True)\n",
       "  (2): Tanh()\n",
       "  (3): Linear(in_features=100, out_features=10, bias=True)\n",
       "  (4): Softmax(dim=1)\n",
       ")"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.append(nn.Linear(hidden_layer_width, output_width))\n",
    "model.append(nn.Softmax(dim=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing a model will also give us a summary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Flatten(start_dim=1, end_dim=-1)\n",
       "  (1): Linear(in_features=784, out_features=100, bias=True)\n",
       "  (2): Tanh()\n",
       "  (3): Linear(in_features=100, out_features=10, bias=True)\n",
       "  (4): Softmax(dim=1)\n",
       ")"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Such a model may also be directly applied to data liek a function.\n",
    "\n",
    "Its outputs will be probability vectors. Because we haven't trained the model yet, the results will be random."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.1104, 0.1071, 0.0940, 0.1080, 0.0916, 0.0981, 0.0999, 0.1083, 0.0959,\n",
       "         0.0866]], grad_fn=<SoftmaxBackward0>)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(data_train[0][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final prediction of the model could be realized e.g. as the element with the highest probability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 24 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 7))\n",
    "for i in range(24):\n",
    "    plt.subplot(4, 6, i + 1)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.grid(False)\n",
    "    plt.imshow(data_train[i][0].reshape(28, 28), cmap = plt.cm.bone)\n",
    "    plt.title(model(data_train[i][0]).detach().argmax(axis = 1).item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training the model\n",
    "\n",
    "Now we can actually train the model. We'll need two things for that:\n",
    "* The *loss* function - the function that we want to minimize\n",
    "* The *optimizer* - a function that uses the gradient to make one optimization step\n",
    "\n",
    "Note:\n",
    "* `torch.nn.NLLLoss` is the cross-entropy loss function which takes as input a probability distribution\n",
    "* `torch.nn.CrossEntropyLoss` is the cross-netropy loss function, which only takes as inputs class weights (i. e. they don't need to sum up to 1)\n",
    "\n",
    "In other words, `CrossEntropyLoss` combines `NLLLoss` and `Softmax`.\n",
    "\n",
    "We will use the ADAM optimizer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.NLLLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters())\n",
    "epochs = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To train the model we will use the `DataLoader`. We will train in mini-batches, which means that we will split the datset into smaller batches, calculate the average loss function for the whole batch and then use it to make one optimization step. One epoch then means using the whole training dataset once (which includes many optimization steps).\n",
    "\n",
    "Let us define 3 functions needed to train the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_accuracy(model, dataloader):\n",
    "    num_correct = 0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for (X, y) in dataloader:\n",
    "            pred = model(X)\n",
    "            num_correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
    "\n",
    "    accuracy = num_correct / len(dataloader.dataset)\n",
    "    return accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_loss_accuracy(model, dataloader, loss_fn):\n",
    "    loss = 0\n",
    "    num_correct = 0\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for (X, y) in dataloader:\n",
    "            pred = model(X)\n",
    "            loss += loss_fn(pred, y).item()\n",
    "            num_correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
    "\n",
    "    loss /= len(dataloader)\n",
    "    accuracy = num_correct / len(dataloader.dataset)\n",
    "    return loss, accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, loss_fn, optimizer, epochs, dataloader_train, dataloader_test, early_stopper = None, log_period = 10000):\n",
    "    for epoch in range(epochs):\n",
    "        processed_since_log = 0\n",
    "        for batch, (X, y) in enumerate(dataloader_train):\n",
    "            model.train()\n",
    "            pred = model(X)\n",
    "            loss = loss_fn(pred, y)\n",
    "\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            processed_since_log += dataloader_train.batch_size\n",
    "\n",
    "            if processed_since_log >= log_period:\n",
    "                current = min((batch + 1) * dataloader_train.batch_size, len(data_train))\n",
    "                loss = loss.item()\n",
    "                model.eval()\n",
    "                train_acc = calculate_accuracy(model, dataloader_train)\n",
    "                test_loss, test_acc = calculate_loss_accuracy(model, dataloader_test, loss_fn)\n",
    "                print(f\"train loss: {loss:>7f}  test loss: {test_loss:>7f}  train accuracy: {train_acc:>3f}  test accuracy: {test_acc:>3f}  [sample {current:>5d}/{len(data_train):>5d}] [epoch {epoch+1:>2d}/{epochs:>2d}]\")\n",
    "                processed_since_log -= log_period"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: -0.820598  test loss: -0.843690  train accuracy: 0.888167  test accuracy: 0.891600  [sample 10000/60000] [epoch  1/10]\n",
      "train loss: -0.832420  test loss: -0.884470  train accuracy: 0.907317  test accuracy: 0.910700  [sample 20000/60000] [epoch  1/10]\n",
      "train loss: -0.942341  test loss: -0.903585  train accuracy: 0.920800  test accuracy: 0.922700  [sample 30000/60000] [epoch  1/10]\n",
      "train loss: -0.896142  test loss: -0.909049  train accuracy: 0.923617  test accuracy: 0.927000  [sample 40000/60000] [epoch  1/10]\n",
      "train loss: -0.855220  test loss: -0.919209  train accuracy: 0.933467  test accuracy: 0.931700  [sample 50000/60000] [epoch  1/10]\n",
      "train loss: -0.908602  test loss: -0.924429  train accuracy: 0.937567  test accuracy: 0.936400  [sample 60000/60000] [epoch  1/10]\n",
      "train loss: -0.952947  test loss: -0.927400  train accuracy: 0.940683  test accuracy: 0.939500  [sample 10000/60000] [epoch  2/10]\n",
      "train loss: -0.889976  test loss: -0.929792  train accuracy: 0.944050  test accuracy: 0.939800  [sample 20000/60000] [epoch  2/10]\n",
      "train loss: -0.941520  test loss: -0.933448  train accuracy: 0.947717  test accuracy: 0.943400  [sample 30000/60000] [epoch  2/10]\n",
      "train loss: -0.912947  test loss: -0.933694  train accuracy: 0.945933  test accuracy: 0.941900  [sample 40000/60000] [epoch  2/10]\n",
      "train loss: -0.934356  test loss: -0.937146  train accuracy: 0.950800  test accuracy: 0.945200  [sample 50000/60000] [epoch  2/10]\n",
      "train loss: -0.949432  test loss: -0.940291  train accuracy: 0.954750  test accuracy: 0.948700  [sample 60000/60000] [epoch  2/10]\n",
      "train loss: -0.968520  test loss: -0.942768  train accuracy: 0.955800  test accuracy: 0.951600  [sample 10000/60000] [epoch  3/10]\n",
      "train loss: -0.842655  test loss: -0.942926  train accuracy: 0.957600  test accuracy: 0.951400  [sample 20000/60000] [epoch  3/10]\n",
      "train loss: -0.948031  test loss: -0.945985  train accuracy: 0.960167  test accuracy: 0.953500  [sample 30000/60000] [epoch  3/10]\n",
      "train loss: -0.958068  test loss: -0.947471  train accuracy: 0.961200  test accuracy: 0.954600  [sample 40000/60000] [epoch  3/10]\n",
      "train loss: -0.942413  test loss: -0.948012  train accuracy: 0.962133  test accuracy: 0.954300  [sample 50000/60000] [epoch  3/10]\n",
      "train loss: -0.977822  test loss: -0.947553  train accuracy: 0.962183  test accuracy: 0.954600  [sample 60000/60000] [epoch  3/10]\n",
      "train loss: -0.972020  test loss: -0.951133  train accuracy: 0.964833  test accuracy: 0.956400  [sample 10000/60000] [epoch  4/10]\n",
      "train loss: -0.932808  test loss: -0.950659  train accuracy: 0.964050  test accuracy: 0.957100  [sample 20000/60000] [epoch  4/10]\n",
      "train loss: -0.922266  test loss: -0.951467  train accuracy: 0.965067  test accuracy: 0.958000  [sample 30000/60000] [epoch  4/10]\n",
      "train loss: -0.973530  test loss: -0.952922  train accuracy: 0.966883  test accuracy: 0.959400  [sample 40000/60000] [epoch  4/10]\n",
      "train loss: -0.925118  test loss: -0.953170  train accuracy: 0.968633  test accuracy: 0.960200  [sample 50000/60000] [epoch  4/10]\n",
      "train loss: -0.982253  test loss: -0.953557  train accuracy: 0.967617  test accuracy: 0.958000  [sample 60000/60000] [epoch  4/10]\n",
      "train loss: -0.934518  test loss: -0.955605  train accuracy: 0.968933  test accuracy: 0.961900  [sample 10000/60000] [epoch  5/10]\n",
      "train loss: -0.976122  test loss: -0.955757  train accuracy: 0.970867  test accuracy: 0.961800  [sample 20000/60000] [epoch  5/10]\n",
      "train loss: -0.969543  test loss: -0.955600  train accuracy: 0.970667  test accuracy: 0.960200  [sample 30000/60000] [epoch  5/10]\n",
      "train loss: -0.965334  test loss: -0.957749  train accuracy: 0.972383  test accuracy: 0.963600  [sample 40000/60000] [epoch  5/10]\n",
      "train loss: -0.978506  test loss: -0.958509  train accuracy: 0.973000  test accuracy: 0.962100  [sample 50000/60000] [epoch  5/10]\n",
      "train loss: -0.970919  test loss: -0.957209  train accuracy: 0.971917  test accuracy: 0.961500  [sample 60000/60000] [epoch  5/10]\n",
      "train loss: -0.940808  test loss: -0.958402  train accuracy: 0.973550  test accuracy: 0.963300  [sample 10000/60000] [epoch  6/10]\n",
      "train loss: -0.977686  test loss: -0.959094  train accuracy: 0.974483  test accuracy: 0.964500  [sample 20000/60000] [epoch  6/10]\n",
      "train loss: -0.971051  test loss: -0.960832  train accuracy: 0.975167  test accuracy: 0.966300  [sample 30000/60000] [epoch  6/10]\n",
      "train loss: -0.957253  test loss: -0.960939  train accuracy: 0.975350  test accuracy: 0.966500  [sample 40000/60000] [epoch  6/10]\n",
      "train loss: -0.975108  test loss: -0.961516  train accuracy: 0.976350  test accuracy: 0.965700  [sample 50000/60000] [epoch  6/10]\n",
      "train loss: -0.963710  test loss: -0.960772  train accuracy: 0.976000  test accuracy: 0.965300  [sample 60000/60000] [epoch  6/10]\n",
      "train loss: -0.976358  test loss: -0.962625  train accuracy: 0.977117  test accuracy: 0.967400  [sample 10000/60000] [epoch  7/10]\n",
      "train loss: -0.955902  test loss: -0.961913  train accuracy: 0.977617  test accuracy: 0.966400  [sample 20000/60000] [epoch  7/10]\n",
      "train loss: -0.990845  test loss: -0.961703  train accuracy: 0.977417  test accuracy: 0.967200  [sample 30000/60000] [epoch  7/10]\n",
      "train loss: -0.985156  test loss: -0.962024  train accuracy: 0.977600  test accuracy: 0.966600  [sample 40000/60000] [epoch  7/10]\n",
      "train loss: -0.996521  test loss: -0.961770  train accuracy: 0.976650  test accuracy: 0.965600  [sample 50000/60000] [epoch  7/10]\n",
      "train loss: -0.974827  test loss: -0.963190  train accuracy: 0.978483  test accuracy: 0.967700  [sample 60000/60000] [epoch  7/10]\n",
      "train loss: -0.977217  test loss: -0.965046  train accuracy: 0.979533  test accuracy: 0.969900  [sample 10000/60000] [epoch  8/10]\n",
      "train loss: -0.942722  test loss: -0.964446  train accuracy: 0.980267  test accuracy: 0.969100  [sample 20000/60000] [epoch  8/10]\n",
      "train loss: -0.997627  test loss: -0.964629  train accuracy: 0.980600  test accuracy: 0.968400  [sample 30000/60000] [epoch  8/10]\n",
      "train loss: -0.996055  test loss: -0.963120  train accuracy: 0.978900  test accuracy: 0.967100  [sample 40000/60000] [epoch  8/10]\n",
      "train loss: -0.961388  test loss: -0.964039  train accuracy: 0.980600  test accuracy: 0.969000  [sample 50000/60000] [epoch  8/10]\n",
      "train loss: -0.997933  test loss: -0.965529  train accuracy: 0.981733  test accuracy: 0.969100  [sample 60000/60000] [epoch  8/10]\n",
      "train loss: -0.994425  test loss: -0.964844  train accuracy: 0.981417  test accuracy: 0.969200  [sample 10000/60000] [epoch  9/10]\n",
      "train loss: -0.984238  test loss: -0.966191  train accuracy: 0.981817  test accuracy: 0.969600  [sample 20000/60000] [epoch  9/10]\n",
      "train loss: -0.998545  test loss: -0.964662  train accuracy: 0.981867  test accuracy: 0.968700  [sample 30000/60000] [epoch  9/10]\n",
      "train loss: -0.998586  test loss: -0.965080  train accuracy: 0.982350  test accuracy: 0.968900  [sample 40000/60000] [epoch  9/10]\n",
      "train loss: -0.995847  test loss: -0.966215  train accuracy: 0.982533  test accuracy: 0.970300  [sample 50000/60000] [epoch  9/10]\n",
      "train loss: -0.986746  test loss: -0.966561  train accuracy: 0.983117  test accuracy: 0.970200  [sample 60000/60000] [epoch  9/10]\n",
      "train loss: -0.978370  test loss: -0.966528  train accuracy: 0.983067  test accuracy: 0.970300  [sample 10000/60000] [epoch 10/10]\n",
      "train loss: -0.998893  test loss: -0.965804  train accuracy: 0.983283  test accuracy: 0.968700  [sample 20000/60000] [epoch 10/10]\n",
      "train loss: -0.979688  test loss: -0.967541  train accuracy: 0.983600  test accuracy: 0.972000  [sample 30000/60000] [epoch 10/10]\n",
      "train loss: -0.972301  test loss: -0.965842  train accuracy: 0.983283  test accuracy: 0.969400  [sample 40000/60000] [epoch 10/10]\n",
      "train loss: -0.971841  test loss: -0.967633  train accuracy: 0.984383  test accuracy: 0.971500  [sample 50000/60000] [epoch 10/10]\n",
      "train loss: -0.916915  test loss: -0.967196  train accuracy: 0.984250  test accuracy: 0.970300  [sample 60000/60000] [epoch 10/10]\n"
     ]
    }
   ],
   "source": [
    "train_model(model, loss_fn, optimizer, epochs, dataloader_train, dataloader_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluating the model\n",
    "\n",
    "To evaluate the model on the test set, we can reuse the previously defined functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: -0.9671957495808602\n",
      "Test accuracy: 0.9703\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "test_loss, test_acc = calculate_loss_accuracy(model, dataloader_test, loss_fn)\n",
    "print('Test loss:', test_loss)\n",
    "print('Test accuracy:', test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we need the \"raw\" output values, we may again just use the model as a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction shape: torch.Size([1, 10])\n",
      "Probablity of the first image being a zero: 1.321598608328145e-09\n"
     ]
    }
   ],
   "source": [
    "predictions = model(data_test[0][0])\n",
    "print('Prediction shape:', predictions.shape)\n",
    "print('Probablity of the first image being a zero:', predictions[0, 0].item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain actual class predictions, we will use the `torch.argmax` function to find out which digit has the highest probability:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Probabilities for the first image: tensor([[1.3216e-09, 1.0896e-13, 1.1279e-09, 1.2137e-07, 6.7669e-13, 1.9098e-09,\n",
      "         7.4296e-17, 1.0000e+00, 5.7948e-09, 5.8476e-08]])\n",
      "Most likely label for the first image: 7\n"
     ]
    }
   ],
   "source": [
    "Y_pred = predictions.detach().argmax(dim = 1)\n",
    "print('Probabilities for the first image:', predictions.detach())\n",
    "print('Most likely label for the first image:', Y_pred[0].item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 24 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 7))\n",
    "for i in range(24):\n",
    "    plt.subplot(4, 6, i + 1)\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.grid(False)\n",
    "    plt.imshow(data_test[i][0].reshape(28, 28), cmap = plt.cm.bone)\n",
    "    plt.title(model(data_test[i][0]).detach().argmax(axis = 1).item())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3 - Creating the model manually\n",
    "\n",
    "Let's again define the basic properties of the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 50\n",
    "hidden_layer_width = 100\n",
    "output_width = 10\n",
    "learning_rate = 0.01\n",
    "epochs = 10\n",
    "loss_fn = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the parameters we will need for a neural network with one hidden layer with 100 neurons:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "W1 = (0.1 * torch.randn((data_train[0][0].shape[1] * data_train[0][0].shape[2], hidden_layer_width))).clone().requires_grad_(True)\n",
    "b1 = torch.zeros((hidden_layer_width,), requires_grad = True)\n",
    "W2 = (0.1 * torch.randn((hidden_layer_width, output_width))).clone().requires_grad_(True)\n",
    "b2 = torch.zeros((output_width,), requires_grad = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the forward pass of the neural net in a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(inputs):\n",
    "    inputs_flat = torch.nn.Flatten()(inputs)\n",
    "    output_1 = torch.tanh(inputs_flat.matmul(W1).add(b1))\n",
    "    output_2 = torch.nn.Softmax(dim = 1)(output_1.matmul(W2).add(b2))\n",
    "    return output_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's train the model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 2.296718  test loss: 2.281255  train accuracy: 0.212183  test accuracy: 0.218000  [sample 10000/60000] [epoch  1/10]\n",
      "train loss: 2.235213  test loss: 2.240589  train accuracy: 0.289083  test accuracy: 0.292900  [sample 20000/60000] [epoch  1/10]\n",
      "train loss: 2.133105  test loss: 2.191676  train accuracy: 0.339917  test accuracy: 0.341000  [sample 30000/60000] [epoch  1/10]\n",
      "train loss: 2.149016  test loss: 2.138944  train accuracy: 0.407983  test accuracy: 0.407000  [sample 40000/60000] [epoch  1/10]\n",
      "train loss: 2.047685  test loss: 2.085823  train accuracy: 0.477417  test accuracy: 0.480200  [sample 50000/60000] [epoch  1/10]\n",
      "train loss: 2.132239  test loss: 2.036835  train accuracy: 0.555750  test accuracy: 0.562200  [sample 60000/60000] [epoch  1/10]\n",
      "train loss: 2.002693  test loss: 1.986402  train accuracy: 0.603283  test accuracy: 0.611100  [sample 10000/60000] [epoch  2/10]\n",
      "train loss: 1.884218  test loss: 1.942651  train accuracy: 0.631283  test accuracy: 0.637600  [sample 20000/60000] [epoch  2/10]\n",
      "train loss: 1.911905  test loss: 1.908594  train accuracy: 0.653650  test accuracy: 0.661700  [sample 30000/60000] [epoch  2/10]\n",
      "train loss: 1.857115  test loss: 1.881546  train accuracy: 0.673383  test accuracy: 0.682700  [sample 40000/60000] [epoch  2/10]\n",
      "train loss: 1.796279  test loss: 1.859548  train accuracy: 0.690150  test accuracy: 0.696000  [sample 50000/60000] [epoch  2/10]\n",
      "train loss: 1.820460  test loss: 1.842638  train accuracy: 0.697750  test accuracy: 0.704100  [sample 60000/60000] [epoch  2/10]\n",
      "train loss: 1.842507  test loss: 1.828558  train accuracy: 0.704317  test accuracy: 0.709200  [sample 10000/60000] [epoch  3/10]\n",
      "train loss: 1.820534  test loss: 1.817110  train accuracy: 0.708833  test accuracy: 0.714300  [sample 20000/60000] [epoch  3/10]\n",
      "train loss: 1.810934  test loss: 1.807305  train accuracy: 0.712850  test accuracy: 0.718500  [sample 30000/60000] [epoch  3/10]\n",
      "train loss: 1.777778  test loss: 1.798765  train accuracy: 0.716300  test accuracy: 0.721600  [sample 40000/60000] [epoch  3/10]\n",
      "train loss: 1.817558  test loss: 1.791631  train accuracy: 0.718883  test accuracy: 0.725700  [sample 50000/60000] [epoch  3/10]\n",
      "train loss: 1.830445  test loss: 1.785376  train accuracy: 0.721550  test accuracy: 0.727800  [sample 60000/60000] [epoch  3/10]\n",
      "train loss: 1.854921  test loss: 1.779688  train accuracy: 0.723867  test accuracy: 0.730000  [sample 10000/60000] [epoch  4/10]\n",
      "train loss: 1.712324  test loss: 1.774630  train accuracy: 0.726050  test accuracy: 0.732800  [sample 20000/60000] [epoch  4/10]\n",
      "train loss: 1.826169  test loss: 1.770267  train accuracy: 0.727700  test accuracy: 0.734700  [sample 30000/60000] [epoch  4/10]\n",
      "train loss: 1.760154  test loss: 1.766265  train accuracy: 0.729483  test accuracy: 0.736200  [sample 40000/60000] [epoch  4/10]\n",
      "train loss: 1.787283  test loss: 1.762570  train accuracy: 0.730833  test accuracy: 0.737800  [sample 50000/60000] [epoch  4/10]\n",
      "train loss: 1.805315  test loss: 1.759014  train accuracy: 0.732167  test accuracy: 0.738300  [sample 60000/60000] [epoch  4/10]\n",
      "train loss: 1.775497  test loss: 1.755804  train accuracy: 0.733633  test accuracy: 0.740000  [sample 10000/60000] [epoch  5/10]\n",
      "train loss: 1.774476  test loss: 1.752591  train accuracy: 0.735050  test accuracy: 0.742000  [sample 20000/60000] [epoch  5/10]\n",
      "train loss: 1.804462  test loss: 1.749154  train accuracy: 0.736450  test accuracy: 0.743200  [sample 30000/60000] [epoch  5/10]\n",
      "train loss: 1.846274  test loss: 1.745635  train accuracy: 0.738583  test accuracy: 0.745200  [sample 40000/60000] [epoch  5/10]\n",
      "train loss: 1.768980  test loss: 1.740857  train accuracy: 0.745933  test accuracy: 0.753100  [sample 50000/60000] [epoch  5/10]\n",
      "train loss: 1.701784  test loss: 1.733454  train accuracy: 0.759033  test accuracy: 0.764800  [sample 60000/60000] [epoch  5/10]\n",
      "train loss: 1.791699  test loss: 1.721477  train accuracy: 0.780033  test accuracy: 0.786800  [sample 10000/60000] [epoch  6/10]\n",
      "train loss: 1.682472  test loss: 1.711732  train accuracy: 0.794583  test accuracy: 0.800800  [sample 20000/60000] [epoch  6/10]\n",
      "train loss: 1.693087  test loss: 1.704976  train accuracy: 0.801150  test accuracy: 0.809200  [sample 30000/60000] [epoch  6/10]\n",
      "train loss: 1.732892  test loss: 1.699952  train accuracy: 0.805167  test accuracy: 0.813400  [sample 40000/60000] [epoch  6/10]\n",
      "train loss: 1.684066  test loss: 1.695412  train accuracy: 0.807583  test accuracy: 0.816100  [sample 50000/60000] [epoch  6/10]\n",
      "train loss: 1.657826  test loss: 1.691365  train accuracy: 0.809950  test accuracy: 0.819300  [sample 60000/60000] [epoch  6/10]\n",
      "train loss: 1.677475  test loss: 1.687462  train accuracy: 0.812167  test accuracy: 0.821700  [sample 10000/60000] [epoch  7/10]\n",
      "train loss: 1.660038  test loss: 1.684098  train accuracy: 0.814133  test accuracy: 0.822800  [sample 20000/60000] [epoch  7/10]\n",
      "train loss: 1.675954  test loss: 1.680863  train accuracy: 0.816367  test accuracy: 0.824800  [sample 30000/60000] [epoch  7/10]\n",
      "train loss: 1.650251  test loss: 1.677770  train accuracy: 0.818900  test accuracy: 0.827500  [sample 40000/60000] [epoch  7/10]\n",
      "train loss: 1.638899  test loss: 1.674902  train accuracy: 0.820917  test accuracy: 0.829400  [sample 50000/60000] [epoch  7/10]\n",
      "train loss: 1.651246  test loss: 1.671887  train accuracy: 0.823483  test accuracy: 0.832300  [sample 60000/60000] [epoch  7/10]\n",
      "train loss: 1.633412  test loss: 1.669132  train accuracy: 0.826367  test accuracy: 0.834400  [sample 10000/60000] [epoch  8/10]\n",
      "train loss: 1.616749  test loss: 1.666226  train accuracy: 0.828717  test accuracy: 0.835900  [sample 20000/60000] [epoch  8/10]\n",
      "train loss: 1.662524  test loss: 1.663574  train accuracy: 0.831133  test accuracy: 0.837400  [sample 30000/60000] [epoch  8/10]\n",
      "train loss: 1.757873  test loss: 1.660922  train accuracy: 0.833083  test accuracy: 0.839600  [sample 40000/60000] [epoch  8/10]\n",
      "train loss: 1.721488  test loss: 1.658270  train accuracy: 0.835883  test accuracy: 0.842400  [sample 50000/60000] [epoch  8/10]\n",
      "train loss: 1.661590  test loss: 1.655721  train accuracy: 0.838700  test accuracy: 0.843900  [sample 60000/60000] [epoch  8/10]\n",
      "train loss: 1.682901  test loss: 1.653103  train accuracy: 0.840333  test accuracy: 0.846600  [sample 10000/60000] [epoch  9/10]\n",
      "train loss: 1.586237  test loss: 1.650445  train accuracy: 0.842483  test accuracy: 0.848300  [sample 20000/60000] [epoch  9/10]\n",
      "train loss: 1.655205  test loss: 1.648098  train accuracy: 0.844117  test accuracy: 0.848800  [sample 30000/60000] [epoch  9/10]\n",
      "train loss: 1.683561  test loss: 1.645708  train accuracy: 0.845983  test accuracy: 0.851900  [sample 40000/60000] [epoch  9/10]\n",
      "train loss: 1.668509  test loss: 1.643480  train accuracy: 0.848333  test accuracy: 0.853100  [sample 50000/60000] [epoch  9/10]\n",
      "train loss: 1.677410  test loss: 1.641158  train accuracy: 0.850500  test accuracy: 0.855400  [sample 60000/60000] [epoch  9/10]\n",
      "train loss: 1.676691  test loss: 1.638900  train accuracy: 0.851667  test accuracy: 0.856700  [sample 10000/60000] [epoch 10/10]\n",
      "train loss: 1.618951  test loss: 1.636327  train accuracy: 0.854267  test accuracy: 0.859200  [sample 20000/60000] [epoch 10/10]\n",
      "train loss: 1.706837  test loss: 1.633838  train accuracy: 0.855633  test accuracy: 0.861900  [sample 30000/60000] [epoch 10/10]\n",
      "train loss: 1.625005  test loss: 1.630942  train accuracy: 0.859317  test accuracy: 0.865200  [sample 40000/60000] [epoch 10/10]\n",
      "train loss: 1.679452  test loss: 1.627561  train accuracy: 0.864067  test accuracy: 0.870000  [sample 50000/60000] [epoch 10/10]\n",
      "train loss: 1.704710  test loss: 1.624331  train accuracy: 0.867017  test accuracy: 0.875100  [sample 60000/60000] [epoch 10/10]\n"
     ]
    }
   ],
   "source": [
    "log_period = 10000\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    processed_since_log = 0\n",
    "    for batch, (X, y) in enumerate(dataloader_train):\n",
    "        pred = predict(X)\n",
    "        loss = loss_fn(pred, y)\n",
    "        loss.backward()\n",
    "\n",
    "        for variable in [W1, b1, W2, b2]:\n",
    "            with torch.no_grad():\n",
    "                variable -= variable.grad * learning_rate\n",
    "            variable.grad = None\n",
    "\n",
    "        processed_since_log += dataloader_train.batch_size\n",
    "\n",
    "        if processed_since_log >= log_period:\n",
    "            current = min((batch + 1) * dataloader_train.batch_size, len(data_train))\n",
    "            loss = loss.item()\n",
    "            train_acc = calculate_accuracy(predict, dataloader_train)\n",
    "            test_loss, test_acc = calculate_loss_accuracy(predict, dataloader_test, loss_fn)\n",
    "            print(f\"train loss: {loss:>7f}  test loss: {test_loss:>7f}  train accuracy: {train_acc:>3f}  test accuracy: {test_acc:>3f}  [sample {current:>5d}/{len(data_train):>5d}] [epoch {epoch+1:>2d}/{epochs:>2d}]\")\n",
    "            processed_since_log -= log_period"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training (hyper-)parameters\n",
    "\n",
    "In the previous examples we just set the various hyper-parameters of the network semi-randomly. Let's now take a look at them and their possible values.\n",
    "\n",
    "### Network architecture\n",
    "\n",
    "- Number of layers\n",
    "- Layer widths\n",
    "- activation functions\n",
    "    - linear\n",
    "    - tanh\n",
    "    - sigmoid\n",
    "    - hard sigmoid\n",
    "    - relu\n",
    "    - selu\n",
    "    - softmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x2000 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 20))\n",
    "i = 1\n",
    "for activationFunction in [nn.Tanh(), nn.Hardtanh(), nn.Sigmoid(), nn.Hardsigmoid(), nn.ReLU(), nn.LeakyReLU(), nn.SELU(), nn.ELU()]:\n",
    "    plt.subplot(4, 4, i)\n",
    "    i += 1\n",
    "    plt.grid(True)\n",
    "    xs = torch.linspace(-5, 5, 100);\n",
    "    ys = activationFunction(xs)\n",
    "    plt.plot(xs, ys)\n",
    "    plt.title(type(activationFunction).__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loss functions\n",
    "\n",
    "- Mean square error\n",
    "    $$ \\operatorname{MSE}=\\frac{1}{n}\\sum_{i=1}^n(Y_i-\\hat{Y_i})^2. $$\n",
    "- Hinge\n",
    "    $$ \\operatorname{Hinge} = \\sum_{i=1}^K \\max(0, 1- Y_i \\cdot \\hat{Y_i}) $$\n",
    "- Cross-entropy\n",
    "    $$ \\operatorname{crossentropy} = - \\sum_{i=1}^K Y_i \\cdot \\log(\\hat{Y_i}) $$\n",
    "\n",
    "## Optimization algorithms\n",
    "\n",
    "- SGD\n",
    "- RMSProp\n",
    "- Adagrad\n",
    "- Adam\n",
    "- Adadelta\n",
    "- Adamax\n",
    "- Nadam\n",
    "- AdamW\n",
    "\n",
    "### Learning schedule\n",
    "\n",
    "We may optionally add a so-called weight decay to the optimization algorithm. This means that the learning rate will become smaller as we train. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_learning_rate = 0.01\n",
    "batch_count = 64\n",
    "optimizer = torch.optim.SGD(model.parameters(), weight_decay=0.001)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More advanced algorithms such as AdamW have weight decay built-in.\n",
    "\n",
    "## Using the training dataset\n",
    "\n",
    "We can set 2 ways in which the training dataset is used:\n",
    "- Epochs: How many times we loop over the whole dataset\n",
    "- Batching: Using the dataset not sample-by-sample but in batches\n",
    "\n",
    "# Task 4\n",
    "\n",
    "Try to modify the previously defined model on MNIST to obtain the best possible results by tuning its hyper-parameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Solution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Sequential(\n",
       "  (0): Flatten(start_dim=1, end_dim=-1)\n",
       "  (1): Linear(in_features=784, out_features=256, bias=True)\n",
       "  (2): Tanh()\n",
       "  (3): Linear(in_features=256, out_features=128, bias=True)\n",
       "  (4): Tanh()\n",
       "  (5): Linear(in_features=128, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = nn.Sequential()\n",
    "model.append(nn.Flatten())\n",
    "model.append(nn.Linear(data_train.data.shape[1] * data_train.data.shape[2], 256))\n",
    "model.append(nn.Tanh())\n",
    "model.append(nn.Linear(256, 128))\n",
    "model.append(nn.Tanh())\n",
    "model.append(nn.Linear(128, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters())\n",
    "epochs = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train loss: 0.242106  test loss: 0.288315  train accuracy: 0.910733  test accuracy: 0.914600  [sample 10000/60000] [epoch  1/10]\n",
      "train loss: 0.433957  test loss: 0.235900  train accuracy: 0.930700  test accuracy: 0.930000  [sample 20000/60000] [epoch  1/10]\n",
      "train loss: 0.243737  test loss: 0.218875  train accuracy: 0.937583  test accuracy: 0.936200  [sample 30000/60000] [epoch  1/10]\n",
      "train loss: 0.196528  test loss: 0.200857  train accuracy: 0.939083  test accuracy: 0.938900  [sample 40000/60000] [epoch  1/10]\n",
      "train loss: 0.113291  test loss: 0.175792  train accuracy: 0.949967  test accuracy: 0.948400  [sample 50000/60000] [epoch  1/10]\n",
      "train loss: 0.275778  test loss: 0.152720  train accuracy: 0.958117  test accuracy: 0.953900  [sample 60000/60000] [epoch  1/10]\n",
      "train loss: 0.231096  test loss: 0.157614  train accuracy: 0.955917  test accuracy: 0.953000  [sample 10000/60000] [epoch  2/10]\n",
      "train loss: 0.217140  test loss: 0.139104  train accuracy: 0.962317  test accuracy: 0.958000  [sample 20000/60000] [epoch  2/10]\n",
      "train loss: 0.125904  test loss: 0.132288  train accuracy: 0.965667  test accuracy: 0.959200  [sample 30000/60000] [epoch  2/10]\n",
      "train loss: 0.331618  test loss: 0.126847  train accuracy: 0.968183  test accuracy: 0.960900  [sample 40000/60000] [epoch  2/10]\n",
      "train loss: 0.082282  test loss: 0.107668  train accuracy: 0.973833  test accuracy: 0.965700  [sample 50000/60000] [epoch  2/10]\n",
      "train loss: 0.028868  test loss: 0.114370  train accuracy: 0.970200  test accuracy: 0.963000  [sample 60000/60000] [epoch  2/10]\n",
      "train loss: 0.034837  test loss: 0.099670  train accuracy: 0.977650  test accuracy: 0.970200  [sample 10000/60000] [epoch  3/10]\n",
      "train loss: 0.029587  test loss: 0.100728  train accuracy: 0.976533  test accuracy: 0.969100  [sample 20000/60000] [epoch  3/10]\n",
      "train loss: 0.070860  test loss: 0.098429  train accuracy: 0.978483  test accuracy: 0.971000  [sample 30000/60000] [epoch  3/10]\n",
      "train loss: 0.035885  test loss: 0.098365  train accuracy: 0.978850  test accuracy: 0.968900  [sample 40000/60000] [epoch  3/10]\n",
      "train loss: 0.019817  test loss: 0.089632  train accuracy: 0.981633  test accuracy: 0.972700  [sample 50000/60000] [epoch  3/10]\n",
      "train loss: 0.006865  test loss: 0.091970  train accuracy: 0.980933  test accuracy: 0.970100  [sample 60000/60000] [epoch  3/10]\n",
      "train loss: 0.059525  test loss: 0.089925  train accuracy: 0.982567  test accuracy: 0.972700  [sample 10000/60000] [epoch  4/10]\n",
      "train loss: 0.049477  test loss: 0.091656  train accuracy: 0.982950  test accuracy: 0.970500  [sample 20000/60000] [epoch  4/10]\n",
      "train loss: 0.031085  test loss: 0.079345  train accuracy: 0.987017  test accuracy: 0.974900  [sample 30000/60000] [epoch  4/10]\n",
      "train loss: 0.005525  test loss: 0.083468  train accuracy: 0.985250  test accuracy: 0.973300  [sample 40000/60000] [epoch  4/10]\n",
      "train loss: 0.105612  test loss: 0.088583  train accuracy: 0.986200  test accuracy: 0.972300  [sample 50000/60000] [epoch  4/10]\n",
      "train loss: 0.014671  test loss: 0.086942  train accuracy: 0.986983  test accuracy: 0.973800  [sample 60000/60000] [epoch  4/10]\n",
      "train loss: 0.008204  test loss: 0.072533  train accuracy: 0.990217  test accuracy: 0.977100  [sample 10000/60000] [epoch  5/10]\n",
      "train loss: 0.136517  test loss: 0.076970  train accuracy: 0.989067  test accuracy: 0.975200  [sample 20000/60000] [epoch  5/10]\n",
      "train loss: 0.007765  test loss: 0.082994  train accuracy: 0.989783  test accuracy: 0.974800  [sample 30000/60000] [epoch  5/10]\n",
      "train loss: 0.059781  test loss: 0.086102  train accuracy: 0.987767  test accuracy: 0.974000  [sample 40000/60000] [epoch  5/10]\n",
      "train loss: 0.018445  test loss: 0.083210  train accuracy: 0.989133  test accuracy: 0.973400  [sample 50000/60000] [epoch  5/10]\n",
      "train loss: 0.014533  test loss: 0.066828  train accuracy: 0.992583  test accuracy: 0.979100  [sample 60000/60000] [epoch  5/10]\n",
      "train loss: 0.004009  test loss: 0.065409  train accuracy: 0.993417  test accuracy: 0.978400  [sample 10000/60000] [epoch  6/10]\n",
      "train loss: 0.006749  test loss: 0.069601  train accuracy: 0.992567  test accuracy: 0.978100  [sample 20000/60000] [epoch  6/10]\n",
      "train loss: 0.016706  test loss: 0.070230  train accuracy: 0.993650  test accuracy: 0.978700  [sample 30000/60000] [epoch  6/10]\n",
      "train loss: 0.156764  test loss: 0.068251  train accuracy: 0.993583  test accuracy: 0.977900  [sample 40000/60000] [epoch  6/10]\n",
      "train loss: 0.001384  test loss: 0.070784  train accuracy: 0.993233  test accuracy: 0.977800  [sample 50000/60000] [epoch  6/10]\n",
      "train loss: 0.017609  test loss: 0.083095  train accuracy: 0.990850  test accuracy: 0.974100  [sample 60000/60000] [epoch  6/10]\n",
      "train loss: 0.018191  test loss: 0.072381  train accuracy: 0.993550  test accuracy: 0.977300  [sample 10000/60000] [epoch  7/10]\n",
      "train loss: 0.066941  test loss: 0.074140  train accuracy: 0.992783  test accuracy: 0.977100  [sample 20000/60000] [epoch  7/10]\n",
      "train loss: 0.014150  test loss: 0.086506  train accuracy: 0.992150  test accuracy: 0.975000  [sample 30000/60000] [epoch  7/10]\n",
      "train loss: 0.001392  test loss: 0.070228  train accuracy: 0.994083  test accuracy: 0.978500  [sample 40000/60000] [epoch  7/10]\n",
      "train loss: 0.026056  test loss: 0.074122  train accuracy: 0.994500  test accuracy: 0.976900  [sample 50000/60000] [epoch  7/10]\n",
      "train loss: 0.005724  test loss: 0.072038  train accuracy: 0.994650  test accuracy: 0.979300  [sample 60000/60000] [epoch  7/10]\n",
      "train loss: 0.009192  test loss: 0.069742  train accuracy: 0.996350  test accuracy: 0.978700  [sample 10000/60000] [epoch  8/10]\n",
      "train loss: 0.066010  test loss: 0.084485  train accuracy: 0.992450  test accuracy: 0.974200  [sample 20000/60000] [epoch  8/10]\n",
      "train loss: 0.086464  test loss: 0.075701  train accuracy: 0.996117  test accuracy: 0.978000  [sample 30000/60000] [epoch  8/10]\n",
      "train loss: 0.056634  test loss: 0.070191  train accuracy: 0.995317  test accuracy: 0.978800  [sample 40000/60000] [epoch  8/10]\n",
      "train loss: 0.004379  test loss: 0.083310  train accuracy: 0.994083  test accuracy: 0.976700  [sample 50000/60000] [epoch  8/10]\n",
      "train loss: 0.069258  test loss: 0.077481  train accuracy: 0.996100  test accuracy: 0.978700  [sample 60000/60000] [epoch  8/10]\n",
      "train loss: 0.008323  test loss: 0.070026  train accuracy: 0.996233  test accuracy: 0.979300  [sample 10000/60000] [epoch  9/10]\n",
      "train loss: 0.051625  test loss: 0.086244  train accuracy: 0.993600  test accuracy: 0.975100  [sample 20000/60000] [epoch  9/10]\n",
      "train loss: 0.005635  test loss: 0.073325  train accuracy: 0.996917  test accuracy: 0.978200  [sample 30000/60000] [epoch  9/10]\n",
      "train loss: 0.004709  test loss: 0.077314  train accuracy: 0.996950  test accuracy: 0.978700  [sample 40000/60000] [epoch  9/10]\n",
      "train loss: 0.001350  test loss: 0.073149  train accuracy: 0.998033  test accuracy: 0.979200  [sample 50000/60000] [epoch  9/10]\n",
      "train loss: 0.009086  test loss: 0.079903  train accuracy: 0.995217  test accuracy: 0.977100  [sample 60000/60000] [epoch  9/10]\n",
      "train loss: 0.010898  test loss: 0.086404  train accuracy: 0.994883  test accuracy: 0.974900  [sample 10000/60000] [epoch 10/10]\n",
      "train loss: 0.007411  test loss: 0.074912  train accuracy: 0.997433  test accuracy: 0.979300  [sample 20000/60000] [epoch 10/10]\n",
      "train loss: 0.007560  test loss: 0.077453  train accuracy: 0.997300  test accuracy: 0.977800  [sample 30000/60000] [epoch 10/10]\n",
      "train loss: 0.003517  test loss: 0.078122  train accuracy: 0.995883  test accuracy: 0.978800  [sample 40000/60000] [epoch 10/10]\n",
      "train loss: 0.001369  test loss: 0.091328  train accuracy: 0.995400  test accuracy: 0.975100  [sample 50000/60000] [epoch 10/10]\n",
      "train loss: 0.019159  test loss: 0.083107  train accuracy: 0.996967  test accuracy: 0.976600  [sample 60000/60000] [epoch 10/10]\n"
     ]
    }
   ],
   "source": [
    "train_model(model, loss_fn, optimizer, epochs, dataloader_train, dataloader_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.08310719113709637\n",
      "Test accuracy: 0.9766\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "test_loss, test_acc = calculate_loss_accuracy(model, dataloader_test, loss_fn)\n",
    "print('Test loss:', test_loss)\n",
    "print('Test accuracy:', test_acc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tzn",
   "language": "python",
   "name": "tzn"
  },
  "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}