diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb
index 4d8b931..7e79de5 100644
--- a/exercises/01_penguin_classification.ipynb
+++ b/exercises/01_penguin_classification.ipynb
@@ -23,20 +23,23 @@
     "### Task 1: look at the data\n",
     "In the following code block, we import the ``load_penguins`` function from the ``palmerpenguins`` package.\n",
     "\n",
-    "- Call this function, which returns a single object, and assign it to the variable ``data``.\n",
-    "  - Print ``data`` and recognise that ``load_penguins`` has returned a ``pandas.DataFrame``.\n",
-    "- Consider which features it might make sense to use in order to classify the species of the penguins.\n",
-    "  - You can print the column titles using ``pd.DataFrame.keys()``\n",
-    "  - You can also obtain useful information using ``pd.DataFrame.Series.describe()``"
+    "- Call this function, which returns a single object in the form of a ``pandas.DataFrame``, and assign it to the variable ``data``.\n",
+    "  - Print ``data`` and recognise that ``load_penguins`` has returned the dataframe.\n",
+    "- Analyse which features it might make sense to use in order to classify the species of the penguins.\n",
+    "  - You can print the column names using ``pd.DataFrame.keys()``\n",
+    "  - You can also obtain useful statical information on the dataset using ``pd.DataFrame.Series.describe()``"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from palmerpenguins import load_penguins"
+    "from palmerpenguins import load_penguins\n",
+    "\n",
+    "# Load the penguin data\n",
+    "penguins = load_penguins()\n"
    ]
   },
   {
@@ -402,7 +405,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -416,7 +419,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,
diff --git a/slides/slides.qmd b/slides/slides.qmd
index a8861f4..6d30874 100644
--- a/slides/slides.qmd
+++ b/slides/slides.qmd
@@ -1,6 +1,6 @@
 ---
-title: "Introduction to Machine Learning with PyTorch"
-subtitle: "NCAS & ICCS Summer Schools 2023"
+title: "Introduction to Neural Networks with PyTorch"
+subtitle: "ICCS Summer School 2024"
 format:
   revealjs:
     embed-resources: true
@@ -12,12 +12,12 @@ format:
     theme: [dark, custom.scss]
     render-on-save: true
 authors:
-  - name: Jack Atkinson
-    orcid: 0000-0001-5001-4812
+  - name: Matt Archer
+    orcid: 0009-0002-7043-6769
     affiliations: ICCS/Cambridge
-  - name: Jim Denholm
-    affiliations: Cambridge
-    orcid: 0000-0002-2389-3134
+  - name: Surbhi Goel
+    affiliations: ICCS/Cambridge
+    orcid: 0009-0005-0237-756X
 revealjs-plugins:
   - attribution
 ---
@@ -61,6 +61,17 @@ Helping Today:
 
 # Part 1: Neural-network basics -- and fun applications.
 
+## Machine learning
+
+- Machine learns underlying patterns and relations in given data to produce an output.
+
+- Machine learning is accomplished by learning a mathematical function that can represent the data. 
+
+
+## Types of Machine learning
+
+- Learning can be supervised, unsupervised, semi-supervised, self-supervised, reinforcement etc. depending on the task in hand.   
+
 
 ## Stochastic gradient descent (SGD)
 
@@ -253,6 +264,10 @@ Image source: [3Blue1Brown](https://www.3blue1brown.com/topics/neural-networks)
 :::
 
 
+## The Learning process summarised
+
+![](ModelLearning.png)
+
 # Python and PyTorch {.smaller}
 
 - In this workshop-lecture-thing, we will implement some straightforward neural networks in PyTorch, and use them for different classification and regression problems.
@@ -261,6 +276,40 @@ Image source: [3Blue1Brown](https://www.3blue1brown.com/topics/neural-networks)
 - See the PyTorch website: [https://pytorch.org/](https://pytorch.org/)
 
 
+
+## Getting to the Exercise
+ *Github Repository Cloning*
+
+- Navigate to 
+[https://tinyurl.com/ml-iccs-24](https://tinyurl.com/ml-iccs-24)
+- Go to terminal and type in the below command
+- `git clone https://github.com/Cambridge-ICCS/practical-ml-with-pytorch`
+
+## Using online platform
+*Using Colab*
+
+`https://tinyurl.com/4arrjjt5`
+
+*Using Jupyter Notebook*
+
+- Download the repo from the [https://tinyurl.com/ml-iccs-24](https://tinyurl.com/ml-iccs-24)
+- `cd <path_to_your_repo>`
+- `jupyter notebook`
+
+## Creating virtual environement
+*Installing with venv*
+
+- `python3 -m venv venv`
+- `source venv/bin/activate`
+
+*Installing with conda*
+
+- `conda create -n ml-workshop "python>=3.9.10"`
+- `conda activate ml-workshop`
+- `cd practical-ml-with-PyTorch`
+- `pip install . `
+
+
 # Exercises
 
 
diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb
index c8666eb..01277b3 100644
--- a/worked-solutions/01_penguin_classification_solutions.ipynb
+++ b/worked-solutions/01_penguin_classification_solutions.ipynb
@@ -13,6 +13,8 @@
     "\n",
     "In this exercise, we will use the python package [``palmerpenguins``](https://github.com/mcnakhaee/palmerpenguins) to supply a toy dataset containing various features and measurements of penguins.\n",
     "\n",
+    "The penguin datset is a set of real-life observations collected from a research centre called Palmer Station in Antarctica by Dr. Kristen Gorman. The dataset consists of 7 variables, out of which 4 are numerical and 3 are categorical which we will see just now. The task here is to classify penguins' species based on their physical characteristics and a few other variables that might help the classification.  \n",
+    "\n",
     "We have already created a PyTorch dataset which yields data for each of the penguins, but first we should examine the dataset and see what it contains."
    ]
   },
@@ -23,16 +25,51 @@
     "### Task 1: look at the data\n",
     "In the following code block, we import the ``load_penguins`` function from the ``palmerpenguins`` package.\n",
     "\n",
-    "- Call this function, which returns a single object, and assign it to the variable ``data``.\n",
-    "  - Print ``data`` and recognise that ``load_penguins`` has returned a ``pandas.DataFrame``.\n",
+    "- Call this function, which returns a single object in the form of a ``pandas.DataFrame``, and assign it to the variable ``data``.\n",
+    "  - Print ``data`` and recognise that ``load_penguins`` has returned the dataframe.\n",
     "- Consider which features it might make sense to use in order to classify the species of the penguins.\n",
-    "  - You can print the column titles using ``pd.DataFrame.keys()``\n",
-    "  - You can also obtain useful information using ``pd.DataFrame.Series.describe()``"
+    "  - You can print the column names using ``pd.DataFrame.keys()``\n",
+    "  - You can also obtain useful statistical information on the dataset using ``pd.DataFrame.Series.describe()``"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "  species     island  bill_length_mm  bill_depth_mm  flipper_length_mm  \\\n",
+      "0  Adelie  Torgersen            39.1           18.7              181.0   \n",
+      "1  Adelie  Torgersen            39.5           17.4              186.0   \n",
+      "2  Adelie  Torgersen            40.3           18.0              195.0   \n",
+      "3  Adelie  Torgersen             NaN            NaN                NaN   \n",
+      "4  Adelie  Torgersen            36.7           19.3              193.0   \n",
+      "\n",
+      "   body_mass_g     sex  year  \n",
+      "0       3750.0    male  2007  \n",
+      "1       3800.0  female  2007  \n",
+      "2       3250.0  female  2007  \n",
+      "3          NaN     NaN  2007  \n",
+      "4       3450.0  female  2007  \n"
+     ]
+    }
+   ],
+   "source": [
+    "from palmerpenguins import load_penguins\n",
+    "\n",
+    "data = load_penguins()\n",
+    "\n",
+    "print(data.head())\n",
+    "\n",
+    "# print(data.keys())"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 42,
    "metadata": {},
    "outputs": [
     {
@@ -57,23 +94,14 @@
       "25%    2007.000000  \n",
       "50%    2008.000000  \n",
       "75%    2009.000000  \n",
-      "max    2009.000000  \n",
-      "Index(['species', 'island', 'bill_length_mm', 'bill_depth_mm',\n",
-      "       'flipper_length_mm', 'body_mass_g', 'sex', 'year'],\n",
-      "      dtype='object')\n"
+      "max    2009.000000  \n"
      ]
     }
    ],
    "source": [
-    "from palmerpenguins import load_penguins\n",
-    "\n",
-    "data = load_penguins()\n",
-    "\n",
     "# Note: ``pd.DataFrame.describe`` is a useful function for giving an overview\n",
     "# of what a ``pd.DataFrame`` contains.\n",
-    "print(data.describe())\n",
-    "\n",
-    "print(data.keys())"
+    "print(data.describe())"
    ]
   },
   {
@@ -97,7 +125,7 @@
     "\n",
     "#### Let's reject\n",
     "- ``\"island\"``\n",
-    "    - While island is likely to be predictive, it seems potentially misleading to use this feature. One island could be heavily dominated by one species of penguin, while other species abide there in much smaller numbers. Such a situation could result in a model giving too much weight to this feature, and confounding the results.\n",
+    "    - While island is likely to be predictive, it seems potentially misleading to use this feature. One island could be heavily dominated by one species of penguin, while other species abide there in much smaller numbers. Such a situation could result in a model giving too much weight to this feature, and confounding the results. \n",
     "- ``\"year\"``\n",
     "    - This feature could also be important: then behaviour of certain species may be changing in response to time-dependent environmental factors such as melting ice. It does however seem like the least biologically-relevant feature, and the most likely source of bias, so we reject it."
    ]
@@ -108,34 +136,108 @@
    "source": [
     "### Task 2: creating a ``torch.utils.data.Dataset``\n",
     "\n",
-    "All PyTorch dataset objects are subclasses of the ``torch.utils.data.Dataset`` class. To make a custom dataset, create a class which inherits from the ``Dataset`` class, implement some methods (the Python magic (or dunder) methods ``__len__`` and ``__getitem__``) and supply some data.\n",
+    "To be able to use Pytorch functionalities, we need to make the dataset compatible with Pytorch. We do it using PyTorch's Dataset class called ``torch.utils.data.Dataset``. \n",
+    "\n",
+    "To make a custom dataset, create a new class which inherits from the ``Dataset`` class, implement some methods (the Python magic (or dunder) like ``__len__`` and ``__getitem__``) and supply data.\n",
     "\n",
     "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\n",
     "\n",
-    "- Open the file ``src/ml_workshop/_penguins.py``.\n",
+    "- Open the above mentioned file.\n",
     "- Let's examine, and discuss, each of the methods together.\n",
     "  - ``__len__``\n",
     "    - What does the ``__len__`` method do?\n",
-    "      - The ``__len__`` method is a so-called \"magic method\", which tells python to do if the ``len`` function is called on the object containing it.\n",
+    "      - The ``__len__`` method is a so-called \"magic method\" in python, that defines what happens when the ``len`` function is called on an object.\n",
     "  - ``__getitem__``\n",
     "    - What does the ``__getitem__`` method do?\n",
     "      - The ``__getitem__`` method is another magic method which tells python what to do if we try and index the object containing it (i.e. ``my_object[idx]``).\n",
     "- Review and discuss the class arguments.\n",
-    "  - ``input_keys``— A sequence of strings telling the data set which objects to return as inputs to the model.\n",
-    "  - ``target_keys``— Same as ``input_keys`` but specifying the targets.\n",
+    "  - ``input_keys``— A sequence of strings telling the data set which objects to return as inputs to the model. These are basically the input column names.\n",
+    "  - ``target_keys``— Same as ``input_keys`` but specifying the targets columns.\n",
     "  - ``train``— A boolean variable determining if the model returns the training or validation split (``True`` for training).\n",
-    "  - ``x_tfms``— A ``Compose`` object with functions which will convert the raw input to a tensor. This argument is _optional_.\n",
+    "  - ``x_tfms``— A ``Compose`` object with functions which will convert the raw input to a tensor. This argument is _optional_. Recall that Pytorch deals with `torch.Tensors` only.\n",
     "  - ``y_tfms``— A ``Compose`` object with functions which will convert the raw target to a tensor. This argument is _optional_."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import Optional, List, Dict, Tuple, Any\n",
+    "\n",
+    "# import pytorch functions necessary for transformations:\n",
+    "from torch import tensor, float32, eye\n",
+    "\n",
+    "from torch.utils.data import Dataset\n",
+    "from torchvision.transforms import Compose\n",
+    "\n",
+    "from pandas import DataFrame\n",
+    "\n",
+    "from palmerpenguins import load_penguins\n",
+    "\n",
+    "\n",
+    "class PenguinDataset(Dataset):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        input_keys: List[str],\n",
+    "        target_keys: List[str],\n",
+    "        train: bool,\n",
+    "    ):\n",
+    "        \"\"\"Build ``PenguinDataset``.\"\"\"\n",
+    "        self.input_keys = input_keys\n",
+    "        self.target_keys = target_keys\n",
+    "\n",
+    "        data = load_penguins()\n",
+    "        data = (\n",
+    "            data.loc[~data.isna().any(axis=1)]\n",
+    "            .sort_values(by=sorted(data.keys()))\n",
+    "            .reset_index(drop=True)\n",
+    "        )\n",
+    "        # Transform the sex field into a float, with male represented by 1.0, female by 0.0\n",
+    "        data.sex = (data.sex == \"male\").astype(float)\n",
+    "        self.full_df = data\n",
+    "\n",
+    "        valid_df = self.full_df.groupby(by=[\"species\", \"sex\"]).sample(\n",
+    "            n=10,\n",
+    "            random_state=123,\n",
+    "        )\n",
+    "        # The training items are simply the items *not* in the valid split\n",
+    "        train_df = self.full_df.loc[~self.full_df.index.isin(valid_df.index)]\n",
+    "\n",
+    "        self.split = {\"train\": train_df, \"valid\": valid_df}[\n",
+    "            \"train\" if train is True else \"valid\"\n",
+    "        ]\n",
+    "\n",
+    "    def __len__(self) -> int:\n",
+    "        return len(self.split)\n",
+    "\n",
+    "    def __getitem__(self, idx: int) -> Tuple[Any, Any]:\n",
+    "        # get the row index (idx) from the dataframe and\n",
+    "        # select relevant column features (provided as input_keys)\n",
+    "        feats = tuple(self.split.iloc[idx][self.input_keys])\n",
+    "\n",
+    "        # this gives a 'species' i.e. one of ('Gentoo',), ('Chinstrap',), or ('Adelie',)\n",
+    "        tgts = tuple(self.split.iloc[idx][self.target_keys])\n",
+    "\n",
+    "        # Exercise #1: convert the feats (Series) to PyTorch Tensors\n",
+    "        feats = tensor(feats, dtype=float32)\n",
+    "\n",
+    "        # Exercise #2: convert target to a 'one-hot' vector.\n",
+    "        target_names = sorted(self.full_df.species.unique())\n",
+    "        tgts = eye(len(target_names))[target_names.index(tgts[0])]\n",
+    "\n",
+    "        return feats, tgts"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Task 3: obtaining training and validation datasets\n",
+    "### Task 3: Obtaining features and targets from data\n",
     "\n",
     "- Instantiate the penguin dataloader.\n",
-    "  - Make sure you supply the correct column titles for the features and the targets.\n",
+    "  - Make sure you pass the correct column names for the input features and the targets.\n",
     "- Iterate over the dataset\n",
     "    - Hint:\n",
     "        ```python\n",
@@ -146,38 +248,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n",
-      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] ('Gentoo',)\n"
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n",
+      "['bill_length_mm', 'bill_depth_mm', 'body_mass_g', 'flipper_length_mm', 'sex'] tensor([0., 0., 1.])\n"
      ]
     }
    ],
    "source": [
-    "from ml_workshop import PenguinDataset\n",
+    "# from ml_workshop import PenguinDataset\n",
     "\n",
     "features = [\n",
     "    \"bill_length_mm\",\n",
@@ -187,6 +289,7 @@
     "    \"sex\",\n",
     "]\n",
     "\n",
+    "# Remove duplicate observations w.r.t a column of choice and then sort them alphabetically \n",
     "target_names = sorted(data.species.unique())\n",
     "\n",
     "data_set = PenguinDataset(\n",
@@ -212,21 +315,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Task 4: Applying transforms to the data\n",
+    "### Task 4: Transforming Input Data for Neural Networks \n",
+    "\n",
+    "The purpose of transforming the data before passing it to the model is to apply optimally preprocessing to the input data. The preprocessing can include tasks such as normalization, reshaping, extrapolation etc.\n",
     "\n",
-    "A common way of transforming inputs to neural networks is to apply a series of transforms using ``torchvision.transforms.Compose``. The [``Compose``](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects and applies them to the incoming data.\n",
+    "A common way of transforming inputs to neural networks is to apply transforms using ``torchvision.transforms.Compose``. The [``Compose``](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects (preprocessing tasks) and applies them sequentially to the incoming data.\n",
     "\n",
-    "These transforms can be very useful for mapping between file paths and tensors of images, etc.\n",
+    "These transforms are very useful for converting file paths to tensors of images and for performing other necessary preprocessing tasks.\n",
     "\n",
-    "- Note: here we create a training and validation set.\n",
-    "    - We allow the model to learn directly from the training set—i.e. we fit the function to these data.\n",
-    "    - During training, we monitor the model's performance on the validation set in order to check how it's doing on unseen data. Normally, people use the validation performance to determine when to stop the training process.\n",
+    "- Note: Here we create a training and validation set.\n",
+    "    - We allow the model to learn from the training setn i.e. we fit the function to these data.\n",
+    "    - During training, we monitor the model's performance on the validation set in order to check how it's doing on unseen data. Normally, people use the validation performance to determine when to stop the training process (earlystopping).\n",
     "- For the validation set, we choose ten males and ten females of each species. This means the validation set is less likely to be biased by sex and species, and is potentially a more reliable measure of performance. You should always be _very_ careful when choosing metrics and splitting data."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 45,
    "metadata": {},
    "outputs": [
     {
@@ -298,8 +403,8 @@
     "    input_keys=features,\n",
     "    target_keys=[\"species\"],\n",
     "    train=True,\n",
-    "    x_tfms=get_input_transforms(),\n",
-    "    y_tfms=get_target_tfms(),\n",
+    "    # x_tfms=get_input_transforms(),\n",
+    "    # y_tfms=get_target_tfms(),\n",
     ")\n",
     "\n",
     "\n",
@@ -307,8 +412,8 @@
     "    input_keys=features,\n",
     "    target_keys=[\"species\"],\n",
     "    train=False,\n",
-    "    x_tfms=get_input_transforms(),\n",
-    "    y_tfms=get_target_tfms(),\n",
+    "    # x_tfms=get_input_transforms(),\n",
+    "    # y_tfms=get_target_tfms(),\n",
     ")\n",
     "\n",
     "\n",
@@ -323,19 +428,19 @@
     "### Task 5: Creating ``DataLoaders``—and why\n",
     "\n",
     "- Once we have created a ``Dataset`` object, we wrap it in a ``DataLoader``.\n",
-    "  - The ``DataLoader`` object allows us to put our inputs and targets in mini-batches, which makes for more efficient training.\n",
+    "  - The ``DataLoader`` object allows us to put our inputs and targets in mini-batches, which makes for more efficient training.\\n\".\n",
     "    - Note: rather than supplying one input-target pair to the model at a time, we supply \"mini-batches\" of these data at once (typically a small power of 2, like 16 or 32).\n",
     "    - The number of items we supply at once is called the batch size.\n",
-    "  - The ``DataLoader`` can also randomly shuffle the data each epoch (when training).\n",
-    "  - It allows us to load different mini-batches in parallel, which can be very useful for larger datasets and images that can't all fit in memory at once.\n",
+    "  - The ``DataLoader`` can also randomly shuffle and re-batch the data each epoch (when training). It prevents the model from learning any order-specific patterns in the data.\n",
+    "  - It also allows us to load the mini-batches in parallel, which can be very useful for larger datasets and images that can't all fit in memory at once.\n",
     "\n",
     "\n",
-    "Note: we are going to use batch normalisation layers in our network, which don't work if the batch size is one. This can happen on the last batch, if we don't choose a batch size that evenly divides the number of items in the data set. To avoid this, we can set the ``drop_last`` argument to ``True``. The last batch, which will be of size ``len(data_set) % batch_size`` gets dropped, and the data are reshuffled. This is only relevant during the training process - validation will use population statistics."
+    "Note: we are going to use batch normalisation in our network, which doesn't work if the batch size is one. This can happen on the last batch, if we don't choose a batch size that evenly divides the number of items in the data set. To avoid this, we can set the ``drop_last`` argument to ``True``. The last batch, which will be of size ``len(data_set) % batch_size`` gets dropped, and the data are reshuffled. This is only relevant during the training process - validation will use population statistics."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 46,
    "metadata": {},
    "outputs": [
     {
@@ -380,13 +485,14 @@
     "Here we will create our neural network in PyTorch, and have a general discussion on clean and messy ways of going about it.\n",
     "\n",
     "- First, we will create quite an ugly network to highlight how to make a neural network in PyTorch on a very basic level.\n",
+    "- The class will have an instance of the network defining layers and activation functions, and a forward layer which will define the way input flows through the layers and activations defined in __init__ to produce an output.\n",
     "- We will then discuss a trick for making the print-out nicer.\n",
     "- Finally, we will discuss how the best approach would be to write a class where various parameters (e.g. number of layers, dropout probabilities, etc.) are passed as arguments."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 47,
    "metadata": {},
    "outputs": [
     {
@@ -473,14 +579,14 @@
    "source": [
     "### Task 7: Selecting a loss function\n",
     "\n",
-    "- Binary cross-entropy is about the most common loss function for classification.\n",
+    "- Binary cross-entropy is the most common loss function for classification. \n",
     "  - Details on this loss function are available in the [PyTorch docs](https://pytorch.org/docs/stable/generated/torch.nn.BCELoss.html).\n",
     "- Let's instantiate it together."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 48,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -495,14 +601,18 @@
    "source": [
     "### Task 8: Selecting an optimiser\n",
     "\n",
+    "The optimiser updates the model's weights and biases on the basis of the gradient of the loss function w.r.t each weight. The aim of weight update process is to reach an optimal weight value until the loss is minimised subject to some stopping criterion. \n",
+    "\n",
+    "Note: Gradient is computed during backpropagation. \n",
+    "\n",
     "While we talked about stochastic gradient descent in the slides, most people use the so-called [Adam optimiser](https://pytorch.org/docs/stable/generated/torch.optim.Adam.html).\n",
     "\n",
-    "You can think of it as a more complex and improved implementation of SGD."
+    "You can think of it as a more complex and improved implementation of SGD.\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -520,17 +630,21 @@
     "\n",
     "- Before we jump in and write these loops, we must first choose an activation function to apply to the model's outputs.\n",
     "  - Here we are going to use the softmax activation function: see [the PyTorch docs](https://pytorch.org/docs/stable/generated/torch.nn.Softmax.html).\n",
-    "  - For those of you who've studied physics, you may be remininded of the partition function in thermodynamics.\n",
+    "  - For those of you who've studied physics, you may be remininded of the partition function in thermodynamics.\\n,\n",
     "  - This activation function is good for classifcation when the result is one of ``A or B or C``.\n",
     "    - It's bad if you even want to assign two classification to one images—say a photo of a dog _and_ a cat.\n",
     "  - It turns the raw outputs, or logits, into \"psuedo probabilities\", and we take our prediction to be the most probable class.\n",
     "\n",
+    "\n",
+    "- The purpose of the training loop is that for each epoch, all the mini-batches are sequentially passed through the model to make predictions, compute the loss, and update the model parameters. This is repeated it until we receive a satisfactory performance.\n",
+    "- The validation loop works similarly, but the purpose is to validate the model training's performance without any weight updates. Hence, we are not calculating any gradient during validation. This is made sure using the ``no_grad`` decorator which disables gradient tracking in the function. Using ``no_grad`` is an optional practice.\n",
+    "- ``batch_level_accuracy`` is also calculated to track the model performance. We also don't need gradients in the batch_level_accuracy() function.\n",
     "- We will write the training loop together, then you can go ahead and write the (simpler) validation loop."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 50,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -668,6 +782,28 @@
     "    return (preds.argmax(dim=1) == targets.argmax(dim=1)).float().mean()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<span style='color:orange'>\n",
+    "\n",
+    "### How this works step by step:\n",
+    "1. Load Dataet\n",
+    "2. Select Features\n",
+    "3. Build pytorch Dataset\n",
+    "4. Transform the dataset\n",
+    "5. Build a DataLoader\n",
+    "6. Build a neural net\n",
+    "7. Define a loss function\n",
+    "8. Define an optimiser\n",
+    "9. Build Train/Val loops\n",
+    "10. Training the net\n",
+    "11. Plotting\n",
+    "\n",
+    "<span>\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -687,62 +823,86 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 51,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 0 time: 0.146 seconds.\n",
-      "Epoch 1 time: 0.096 seconds.\n",
-      "Epoch 2 time: 0.093 seconds.\n",
-      "Epoch 3 time: 0.092 seconds.\n",
-      "Epoch 4 time: 0.093 seconds.\n",
-      "Epoch 5 time: 0.093 seconds.\n",
-      "Epoch 6 time: 0.092 seconds.\n",
-      "Epoch 7 time: 0.093 seconds.\n",
-      "Epoch 8 time: 0.093 seconds.\n",
-      "Epoch 9 time: 0.094 seconds.\n",
-      "Epoch 10 time: 0.097 seconds.\n",
-      "Epoch 11 time: 0.097 seconds.\n",
-      "Epoch 12 time: 0.094 seconds.\n",
-      "Epoch 13 time: 0.094 seconds.\n",
-      "Epoch 14 time: 0.093 seconds.\n",
-      "Epoch 15 time: 0.092 seconds.\n",
-      "Epoch 16 time: 0.096 seconds.\n",
-      "Epoch 17 time: 0.098 seconds.\n",
-      "Epoch 18 time: 0.096 seconds.\n",
-      "Epoch 19 time: 0.093 seconds.\n",
+      "Epoch 0: Time: 0.136 seconds \n",
+      " Train Loss: 0.4514, Val Loss: 0.3982, Train Accuracy: 0.6912000179290771, Val Accuracy: 0.7968999743461609\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1: Time: 0.097 seconds \n",
+      " Train Loss: 0.337, Val Loss: 0.2835, Train Accuracy: 0.8603000044822693, Val Accuracy: 0.9688000082969666\n",
+      "\n",
+      "Epoch 2: Time: 0.085 seconds \n",
+      " Train Loss: 0.2711, Val Loss: 0.2226, Train Accuracy: 0.9154000282287598, Val Accuracy: 0.9688000082969666\n",
+      "\n",
+      "Epoch 3: Time: 0.086 seconds \n",
+      " Train Loss: 0.2212, Val Loss: 0.184, Train Accuracy: 0.9521999955177307, Val Accuracy: 0.9688000082969666\n",
+      "\n",
+      "Epoch 4: Time: 0.089 seconds \n",
+      " Train Loss: 0.182, Val Loss: 0.1509, Train Accuracy: 0.9484999775886536, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 5: Time: 0.082 seconds \n",
+      " Train Loss: 0.1631, Val Loss: 0.1332, Train Accuracy: 0.9484999775886536, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 6: Time: 0.088 seconds \n",
+      " Train Loss: 0.1332, Val Loss: 0.109, Train Accuracy: 0.9815999865531921, Val Accuracy: 0.9843999743461609\n",
       "\n",
+      "Epoch 7: Time: 0.099 seconds \n",
+      " Train Loss: 0.1212, Val Loss: 0.0965, Train Accuracy: 0.9706000089645386, Val Accuracy: 0.9843999743461609\n",
       "\n",
-      "    loss_train  accuracy_train  loss_valid  accuracy_valid\n",
-      "0     0.759151        0.279412    0.711391        0.375000\n",
-      "1     0.531332        0.584559    0.468364        0.609375\n",
-      "2     0.393045        0.779412    0.365031        0.796875\n",
-      "3     0.304282        0.915441    0.293924        0.890625\n",
-      "4     0.261206        0.937500    0.252864        0.937500\n",
-      "5     0.221856        0.937500    0.210456        0.937500\n",
-      "6     0.190321        0.963235    0.171965        0.968750\n",
-      "7     0.151137        0.966912    0.161003        0.968750\n",
-      "8     0.134465        0.974265    0.139327        0.968750\n",
-      "9     0.127652        0.963235    0.123636        0.968750\n",
-      "10    0.133551        0.959559    0.103402        0.968750\n",
-      "11    0.116820        0.985294    0.095507        0.968750\n",
-      "12    0.114006        0.970588    0.084369        0.984375\n",
-      "13    0.114615        0.955882    0.079413        0.984375\n",
-      "14    0.076280        0.985294    0.074852        0.984375\n",
-      "15    0.088352        0.981618    0.068665        0.984375\n",
-      "16    0.111566        0.955882    0.064788        0.984375\n",
-      "17    0.083331        0.966912    0.060488        0.984375\n",
-      "18    0.084988        0.977941    0.057387        0.984375\n",
-      "19    0.065010        0.985294    0.055872        0.984375\n"
+      "Epoch 8: Time: 0.082 seconds \n",
+      " Train Loss: 0.1104, Val Loss: 0.0896, Train Accuracy: 0.9706000089645386, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 9: Time: 0.084 seconds \n",
+      " Train Loss: 0.1056, Val Loss: 0.0759, Train Accuracy: 0.9743000268936157, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 10: Time: 0.085 seconds \n",
+      " Train Loss: 0.0869, Val Loss: 0.0746, Train Accuracy: 0.9743000268936157, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 11: Time: 0.090 seconds \n",
+      " Train Loss: 0.0782, Val Loss: 0.0701, Train Accuracy: 0.9815999865531921, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 12: Time: 0.095 seconds \n",
+      " Train Loss: 0.0937, Val Loss: 0.0619, Train Accuracy: 0.9668999910354614, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 13: Time: 0.088 seconds \n",
+      " Train Loss: 0.0661, Val Loss: 0.0637, Train Accuracy: 0.9890000224113464, Val Accuracy: 0.9688000082969666\n",
+      "\n",
+      "Epoch 14: Time: 0.084 seconds \n",
+      " Train Loss: 0.0778, Val Loss: 0.0607, Train Accuracy: 0.9706000089645386, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 15: Time: 0.087 seconds \n",
+      " Train Loss: 0.0698, Val Loss: 0.058, Train Accuracy: 0.9815999865531921, Val Accuracy: 0.9688000082969666\n",
+      "\n",
+      "Epoch 16: Time: 0.098 seconds \n",
+      " Train Loss: 0.0782, Val Loss: 0.0493, Train Accuracy: 0.9631999731063843, Val Accuracy: 1.0\n",
+      "\n",
+      "Epoch 17: Time: 0.090 seconds \n",
+      " Train Loss: 0.0564, Val Loss: 0.0503, Train Accuracy: 0.9779000282287598, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 18: Time: 0.090 seconds \n",
+      " Train Loss: 0.0529, Val Loss: 0.0479, Train Accuracy: 0.9743000268936157, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "Epoch 19: Time: 0.095 seconds \n",
+      " Train Loss: 0.0483, Val Loss: 0.047, Train Accuracy: 0.9890000224113464, Val Accuracy: 0.9843999743461609\n",
+      "\n",
+      "\n",
+      "\n"
      ]
     }
    ],
    "source": [
     "from time import perf_counter\n",
-    "\n",
     "from pandas import DataFrame\n",
     "\n",
     "epochs = 20\n",
@@ -752,22 +912,238 @@
     "for epoch in range(epochs):\n",
     "    start_time = perf_counter()\n",
     "\n",
-    "    train_metrics.append(train_one_epoch(model, train_loader, optimiser, loss_func))\n",
+    "    train_loss = train_one_epoch(model, train_loader, optimiser, loss_func)\n",
+    "    train_metrics.append(train_loss)\n",
     "\n",
-    "    valid_metrics.append(validate_one_epoch(model, valid_loader, loss_func))\n",
+    "    valid_loss = validate_one_epoch(model, valid_loader, loss_func)\n",
+    "    valid_metrics.append(valid_loss)\n",
     "\n",
     "    stop_time = perf_counter()\n",
     "\n",
-    "    print(f\"Epoch {epoch} time: {stop_time - start_time:.3f} seconds.\")\n",
-    "\n",
+    "    print(f\"Epoch {epoch}: Time: {stop_time - start_time:.3f} seconds \\n Train Loss: {round(train_loss['loss'],4)}, Val Loss: {round(valid_loss['loss'],4)}, Train Accuracy: {round(train_loss['accuracy'],4)}, Val Accuracy: {round(valid_loss['accuracy'],4)}\\n\")\n",
+    "    \n",
     "print(\"\\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",
+    "metrics.index = range(0,epochs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   loss_train  accuracy_train  loss_valid  accuracy_valid\n",
+      "0    0.451392        0.691176    0.398212        0.796875\n",
+      "1    0.337014        0.860294    0.283476        0.968750\n",
+      "2    0.271069        0.915441    0.222645        0.968750\n",
+      "3    0.221187        0.952206    0.183997        0.968750\n",
+      "4    0.181975        0.948529    0.150913        0.984375\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(metrics.head())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Task 11: Visualise some results\n",
     "\n",
-    "print(metrics)"
+    "Let's do this part together—though feel free to make a start on your own if you have completed the previous exercises."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Loss plot\n",
+    "plt.figure(figsize=(6, 4))\n",
+    "plt.plot(metrics.index, metrics['loss_train'], label='Training Loss')\n",
+    "plt.plot(metrics.index, metrics['loss_valid'], label='Validation Loss')\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.title('Loss vs. Epochs')\n",
+    "plt.xticks(range(epochs)) \n",
+    "plt.legend()\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 600x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Accuracy plot\n",
+    "plt.figure(figsize=(6, 4))\n",
+    "plt.plot(metrics.index, metrics['accuracy_train'], label='Training Accuracy')\n",
+    "plt.plot(metrics.index, metrics['accuracy_valid'], label='Validation Accuracy')\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.title('Accuracy vs. Epochs')\n",
+    "plt.xticks(range(epochs))  \n",
+    "plt.legend()\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bonus: Run the net on 'new' inputs\n",
+    "\n",
+    "We have built and trained a net, and evaluated and visualised its performance. However, how do we now utilise it going forward?\n",
+    "\n",
+    "Here we construct some 'new' input data and use our trained net to infer the species. Whilst this is relatively straightforward there is still some work required to transform the outputs from the net to a meaningful result."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Raw input:\n",
+      "tensor([[4.2900e+01, 1.3100e+01, 5.0000e+03, 2.1500e+02, 0.0000e+00],\n",
+      "        [3.3600e+01, 1.1300e+01, 2.0000e+03, 2.1100e+02, 1.0000e+00]])\n",
+      "\n",
+      "Raw output:\n",
+      "tensor([[1.1300e-03, 8.3503e-04, 9.9804e-01],\n",
+      "        [7.4916e-01, 1.5521e-03, 2.4928e-01]])\n",
+      "\n",
+      "Predicted species:\n",
+      "['Gentoo', 'Adelie']\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from torch import no_grad\n",
+    "\n",
+    "# Construct a tensor of inputs to run the model over\n",
+    "demo_input = tensor(\n",
+    "    [\n",
+    "        [42.9, 13.1, 5000.0, 215.0, 0.0],\n",
+    "        [33.6, 11.3, 2000.0, 211.0, 1.0],\n",
+    "    ]\n",
+    ")\n",
+    "print(f\"Raw input:\\n{demo_input}\\n\")\n",
+    "\n",
+    "# Place model in eval mode and run over inputs with no_grad\n",
+    "model.eval()\n",
+    "with no_grad():\n",
+    "    demo_output = model(demo_input).softmax(dim=1)\n",
+    "\n",
+    "# Print the raw output from the net\n",
+    "print(f\"Raw output:\\n{demo_output}\\n\")\n",
+    "\n",
+    "# Transform the raw output back to human-readable format\n",
+    "print(f\"Predicted species:\\n{[target_names[val.argmax()] for val in demo_output]}\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0 time: 0.119 seconds Train Loss: 0.0571 Val Loss: 0.0467\n",
+      "Epoch 1 time: 0.093 seconds Train Loss: 0.0549 Val Loss: 0.0406\n",
+      "Epoch 2 time: 0.092 seconds Train Loss: 0.0544 Val Loss: 0.042\n",
+      "Epoch 3 time: 0.098 seconds Train Loss: 0.0632 Val Loss: 0.04\n",
+      "Epoch 4 time: 0.094 seconds Train Loss: 0.0536 Val Loss: 0.0374\n",
+      "Epoch 5 time: 0.084 seconds Train Loss: 0.0718 Val Loss: 0.0367\n",
+      "Epoch 6 time: 0.083 seconds Train Loss: 0.0422 Val Loss: 0.0394\n",
+      "Epoch 7 time: 0.090 seconds Train Loss: 0.0461 Val Loss: 0.0347\n",
+      "Epoch 8 time: 0.095 seconds Train Loss: 0.0415 Val Loss: 0.0341\n",
+      "Epoch 9 time: 0.092 seconds Train Loss: 0.0421 Val Loss: 0.0342\n",
+      "Epoch 10 time: 0.091 seconds Train Loss: 0.0294 Val Loss: 0.0359\n",
+      "Epoch 11 time: 0.095 seconds Train Loss: 0.0417 Val Loss: 0.0335\n",
+      "Epoch 12 time: 0.087 seconds Train Loss: 0.0599 Val Loss: 0.0332\n",
+      "Epoch 13 time: 0.085 seconds Train Loss: 0.0321 Val Loss: 0.0333\n",
+      "Epoch 14 time: 0.083 seconds Train Loss: 0.0489 Val Loss: 0.031\n",
+      "Epoch 15 time: 0.089 seconds Train Loss: 0.0362 Val Loss: 0.0284\n",
+      "Epoch 16 time: 0.088 seconds Train Loss: 0.0431 Val Loss: 0.0278\n",
+      "Epoch 17 time: 0.088 seconds Train Loss: 0.0291 Val Loss: 0.0304\n",
+      "Epoch 18 time: 0.094 seconds Train Loss: 0.0354 Val Loss: 0.0339\n",
+      "Epoch 19 time: 0.083 seconds Train Loss: 0.0452 Val Loss: 0.0286\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from time import perf_counter\n",
+    "\n",
+    "from pandas import DataFrame\n",
+    "\n",
+    "epochs = 20\n",
+    "\n",
+    "train_metrics, valid_metrics = [], []\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "    start_time = perf_counter()\n",
+    "\n",
+    "    train_loss = train_one_epoch(model, train_loader, optimiser, loss_func)\n",
+    "    train_metrics.append(train_loss)\n",
+    "\n",
+    "    valid_loss = validate_one_epoch(model, valid_loader, loss_func)\n",
+    "    valid_metrics.append(valid_loss)\n",
+    "\n",
+    "    stop_time = perf_counter()\n",
+    "\n",
+    "    print(f\"Epoch {epoch} time: {stop_time - start_time:.3f} seconds Train Loss: {round(train_loss['loss'],4)} Val Loss: {round(valid_loss['loss'],4)}\")\n",
+    "\n",
+    "print(\"\\n\")\n",
+    "\n",
+    "train_metrics = DataFrame(train_metrics)\n",
+    "valid_metrics = DataFrame(valid_metrics)\n",
+    "metrics = train_metrics.join(valid_metrics, lsuffix=\"_train\", rsuffix=\"_valid\")\n"
    ]
   },
   {
@@ -781,12 +1157,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x400 with 2 Axes>"
       ]
@@ -822,7 +1198,8 @@
     "    axis.set_xlim(left=1, right=epochs)\n",
     "    axis.set_xlabel(\"Epoch\", fontsize=15)\n",
     "\n",
-    "fig.tight_layout()"
+    "fig.tight_layout()\n",
+    "\n"
    ]
   },
   {
@@ -838,7 +1215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [
     {
@@ -850,8 +1227,8 @@
       "        [3.3600e+01, 1.1300e+01, 2.0000e+03, 2.1100e+02, 1.0000e+00]])\n",
       "\n",
       "Raw output:\n",
-      "tensor([[0.0035, 0.0021, 0.9943],\n",
-      "        [0.9547, 0.0013, 0.0440]])\n",
+      "tensor([[9.8420e-05, 6.0667e-05, 9.9984e-01],\n",
+      "        [6.3560e-01, 5.4130e-04, 3.6386e-01]])\n",
       "\n",
       "Predicted species:\n",
       "['Gentoo', 'Adelie']\n",
@@ -900,7 +1277,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.12.4"
   }
  },
  "nbformat": 4,