diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb
index 95eb953..cf532cb 100644
--- a/exercises/01_penguin_classification.ipynb
+++ b/exercises/01_penguin_classification.ipynb
@@ -55,9 +55,13 @@
    "source": [
     "### Task 2: creating a ``torch.utils.data.Dataset``\n",
     "\n",
+    "The penguin data reading and processing can be encapsulated in a PyTorch dataset class.\n",
+    "\n",
+    "- Why is a class representation helpful?\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",
     "\n",
-    "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\n",
+    "Spoiler alert: we've done this for you already below (see ``src/ml_workshop/_penguins.py`` for a more sophisticated implementation)\n",
     "\n",
     "- Open the file ``src/ml_workshop/_penguins.py``.\n",
     "- Let's examine, and discuss, each of the methods together.\n",
@@ -70,9 +74,118 @@
     "- Review and discuss the class arguments.\n",
     "  - ``input_keys``— ...\n",
     "  - ``target_keys``— ...\n",
-    "  - ``train``— ...\n",
-    "  - ``x_tfms``— ...\n",
-    "  - ``y_tfms``— ..."
+    "  - ``train``— ..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List, Tuple, Any\n",
+    "\n",
+    "# import some useful functions here, see https://pytorch.org/docs/stable/torch.html\n",
+    "# where `tensor` and `eye` are used for constructing tensors,\n",
+    "# and using a lower-precision float32 is advised for performance\n",
+    "# Task 4: add imports here\n",
+    "# from torch import tensor, eye, float32\n",
+    "\n",
+    "from torch.utils.data import Dataset\n",
+    "\n",
+    "from palmerpenguins import load_penguins\n",
+    "\n",
+    "\n",
+    "class PenguinDataset(Dataset):\n",
+    "    \"\"\"Penguin dataset class.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    input_keys : List[str]\n",
+    "        The column titles to use in the input feature vectors.\n",
+    "    target_keys : List[str]\n",
+    "        The column titles to use in the target feature vectors.\n",
+    "    train : bool\n",
+    "        If ``True``, this object will serve as the training set, and if\n",
+    "        ``False``, the validation set.\n",
+    "\n",
+    "    Notes\n",
+    "    -----\n",
+    "    The validation split contains 10 male and 10 female penguins of each\n",
+    "    species.\n",
+    "\n",
+    "    \"\"\"\n",
+    "\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 the length of requested split.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        int\n",
+    "            The number of items in the dataset.\n",
+    "\n",
+    "        \"\"\"\n",
+    "        return len(self.split)\n",
+    "\n",
+    "    def __getitem__(self, idx: int) -> Tuple[Any, Any]:\n",
+    "        \"\"\"Return an input-target pair.\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        idx : int\n",
+    "            Index of the input-target pair to return.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        in_feats : Any\n",
+    "            Inputs.\n",
+    "        target : Any\n",
+    "            Targets.\n",
+    "\n",
+    "        \"\"\"\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",
+    "        # Task 4 - Exercise #1: convert the features to PyTorch Tensors\n",
+    "\n",
+    "        # Task 4 - Exercise #2: convert target to a 'one-hot' vector.\n",
+    "\n",
+    "        return feats, tgts"
    ]
   },
   {
@@ -97,8 +210,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from ml_workshop import PenguinDataset\n",
-    "\n",
     "data_set = PenguinDataset(\n",
     "    input_keys=[\"bill_length_mm\", \"body_mass_g\"],\n",
     "    target_keys=[\"species\"],\n",
@@ -117,7 +228,12 @@
    "source": [
     "- Can we give these items to a neural network, or do they need to be transformed first?\n",
     "  - Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n",
-    "    - We must represent these data as ``torch.Tensor``s."
+    "    - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch; they are the PyTorch equivalent to Numpy arrays, while also providing support for GPU acceleration. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html).\n",
+    "    - The targets are tuples of strings i.e. ('Gentoo', )\n",
+    "      - One idea is to represent as ordinal values i.e.  [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n",
+    "      \"A\" — [1, 0, 0]\\\n",
+    "      \"B\" — [0, 1, 0]\\\n",
+    "      \"C\" — [0, 0, 1]"
    ]
   },
   {
@@ -126,14 +242,46 @@
    "source": [
     "### Task 4: Applying transforms to the data\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 (i.e., functions) and applies them to the incoming data.\n",
+    "Modify the `PenguinDataset` class above so that the tuples of numbers are converted to PyTorch `torch.Tensor` s and the string targets are converted to one-hot vectors.\n",
+    "\n",
+    "- Begin by importing relevant PyTorch functions.\n",
+    "- Apply transformations inside `__getitem__()` function above.\n",
+    "\n",
+    "Then create a training and validation set.\n",
+    "\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",
+    "  \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.\n",
+    "\n",
+    "- Is this solution general?\n",
     "\n",
-    "These transforms can be very useful for mapping between file paths and tensors of images, etc.\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. See how this is done more generally in the `src/ml_workshop/_penguins.py` file. \n",
+    "\n",
+    "These transforms can be very useful for mapping between file paths and tensors of images, etc.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Apply transforms we need to PenguinDataset to convert input data and target class to tensors. \n",
+    "# See Task 4 exercise comments above.\n",
+    "\n",
+    "# Create train_set\n",
+    "\n",
+    "# Create valid_set\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### (Optional) Task 4b: \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",
-    "- 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."
+    "Apply the `torchvision.transforms.Compose` transformations instead of hardcoding as above. "
    ]
   },
   {
@@ -417,7 +565,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.12.2"
   }
  },
  "nbformat": 4,
diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb
index fcab877..25b6f49 100644
--- a/worked-solutions/01_penguin_classification_solutions.ipynb
+++ b/worked-solutions/01_penguin_classification_solutions.ipynb
@@ -108,9 +108,16 @@
    "source": [
     "### Task 2: creating a ``torch.utils.data.Dataset``\n",
     "\n",
+    "The penguin data reading and processing can be encapsulated in a PyTorch dataset class.\n",
+    "\n",
+    "- Why is a class representation helpful?\n",
+    "  - Modularity - Separation of concerns makes the cde easier to understand, maintain and test.\n",
+    "  - Maintainability - Changes are localised, therefore we only need to change a single file to update. \n",
+    "  - Abstraction - Users do not need to know how the data is read or processed, they only need to know how to interact with the class. \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",
     "\n",
-    "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\n",
+    "Spoiler alert: we've done this for you already below (see ``src/ml_workshop/_penguins.py`` for a more sophisticated implementation)\n",
     "\n",
     "- Open the file ``src/ml_workshop/_penguins.py``.\n",
     "- Let's examine, and discuss, each of the methods together.\n",
@@ -123,9 +130,120 @@
     "- 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",
-    "  - ``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",
-    "  - ``y_tfms``— A ``Compose`` object with functions which will convert the raw target to a tensor. This argument is _optional_."
+    "  - ``train``— A boolean variable determining if the model returns the training or validation split (``True`` for training)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List, Tuple, Any\n",
+    "\n",
+    "# import some useful functions here, see https://pytorch.org/docs/stable/torch.html\n",
+    "# where `tensor` and `eye` are used for constructing tensors,\n",
+    "# and using a lower-precision float32 is advised for performance\n",
+    "from torch import tensor, float32, eye\n",
+    "\n",
+    "from torch.utils.data import Dataset\n",
+    "\n",
+    "from palmerpenguins import load_penguins\n",
+    "\n",
+    "\n",
+    "class PenguinDataset(Dataset):\n",
+    "    \"\"\"Penguin dataset class.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    input_keys : List[str]\n",
+    "        The column titles to use in the input feature vectors.\n",
+    "    target_keys : List[str]\n",
+    "        The column titles to use in the target feature vectors.\n",
+    "    train : bool\n",
+    "        If ``True``, this object will serve as the training set, and if\n",
+    "        ``False``, the validation set.\n",
+    "\n",
+    "    Notes\n",
+    "    -----\n",
+    "    The validation split contains 10 male and 10 female penguins of each\n",
+    "    species.\n",
+    "\n",
+    "    \"\"\"\n",
+    "\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 the length of requested split.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        int\n",
+    "            The number of items in the dataset.\n",
+    "\n",
+    "        \"\"\"\n",
+    "        return len(self.split)\n",
+    "\n",
+    "    def __getitem__(self, idx: int) -> Tuple[Any, Any]:\n",
+    "        \"\"\"Return an input-target pair.\n",
+    "\n",
+    "        Parameters\n",
+    "        ----------\n",
+    "        idx : int\n",
+    "            Index of the input-target pair to return.\n",
+    "\n",
+    "        Returns\n",
+    "        -------\n",
+    "        in_feats : Any\n",
+    "            Inputs.\n",
+    "        target : Any\n",
+    "            Targets.\n",
+    "\n",
+    "        \"\"\"\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",
+    "        # Task 4 - Exercise #1: convert the features to PyTorch Tensors\n",
+    "        feats = tensor(feats, dtype=float32)\n",
+    "\n",
+    "        # Task 4 - 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"
    ]
   },
   {
@@ -146,39 +264,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "(42.9, 13.1, 5000.0, 215.0, 0.0) ('Gentoo',)\n",
-      "(46.1, 13.2, 4500.0, 211.0, 0.0) ('Gentoo',)\n",
-      "(44.9, 13.3, 5100.0, 213.0, 0.0) ('Gentoo',)\n",
-      "(43.3, 13.4, 4400.0, 209.0, 0.0) ('Gentoo',)\n",
-      "(42.0, 13.5, 4150.0, 210.0, 0.0) ('Gentoo',)\n",
-      "(46.5, 13.5, 4550.0, 210.0, 0.0) ('Gentoo',)\n",
-      "(44.0, 13.6, 4350.0, 208.0, 0.0) ('Gentoo',)\n",
-      "(40.9, 13.7, 4650.0, 214.0, 0.0) ('Gentoo',)\n",
-      "(42.6, 13.7, 4950.0, 213.0, 0.0) ('Gentoo',)\n",
-      "(42.7, 13.7, 3950.0, 208.0, 0.0) ('Gentoo',)\n",
-      "(45.3, 13.7, 4300.0, 210.0, 0.0) ('Gentoo',)\n",
-      "(47.2, 13.7, 4925.0, 214.0, 0.0) ('Gentoo',)\n",
-      "(45.2, 13.8, 4750.0, 215.0, 0.0) ('Gentoo',)\n",
-      "(43.6, 13.9, 4900.0, 217.0, 0.0) ('Gentoo',)\n",
-      "(43.8, 13.9, 4300.0, 208.0, 0.0) ('Gentoo',)\n",
-      "(45.5, 13.9, 4200.0, 210.0, 0.0) ('Gentoo',)\n",
-      "(45.7, 13.9, 4400.0, 214.0, 0.0) ('Gentoo',)\n",
-      "(43.3, 14.0, 4575.0, 208.0, 0.0) ('Gentoo',)\n",
-      "(47.5, 14.0, 4875.0, 212.0, 0.0) ('Gentoo',)\n",
-      "(46.2, 14.1, 4375.0, 217.0, 0.0) ('Gentoo',)\n"
+      "tensor([  42.9000,   13.1000, 5000.0000,  215.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  46.1000,   13.2000, 4500.0000,  211.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  44.9000,   13.3000, 5100.0000,  213.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  43.3000,   13.4000, 4400.0000,  209.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  42.0000,   13.5000, 4150.0000,  210.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  46.5000,   13.5000, 4550.0000,  210.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  44.0000,   13.6000, 4350.0000,  208.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  40.9000,   13.7000, 4650.0000,  214.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  42.6000,   13.7000, 4950.0000,  213.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  42.7000,   13.7000, 3950.0000,  208.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  45.3000,   13.7000, 4300.0000,  210.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  47.2000,   13.7000, 4925.0000,  214.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  45.2000,   13.8000, 4750.0000,  215.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  43.6000,   13.9000, 4900.0000,  217.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  43.8000,   13.9000, 4300.0000,  208.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  45.5000,   13.9000, 4200.0000,  210.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  45.7000,   13.9000, 4400.0000,  214.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  43.3000,   14.0000, 4575.0000,  208.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  47.5000,   14.0000, 4875.0000,  212.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  46.2000,   14.1000, 4375.0000,  217.0000,    0.0000]) tensor([0., 0., 1.])\n"
      ]
     }
    ],
    "source": [
-    "from ml_workshop import PenguinDataset\n",
-    "\n",
     "features = [\n",
     "    \"bill_length_mm\",\n",
     "    \"bill_depth_mm\",\n",
@@ -196,16 +312,21 @@
     ")\n",
     "\n",
     "for _, (input_feats, target) in zip(range(20), data_set):\n",
-    "    print(input_feats, target)"
+    "    print(input_feats, target)\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "- Can we give these items to a neural network, or do they need to be transformed first?\n",
-    "  - Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n",
-    "    - We must represent these data as ``torch.Tensor``s."
+    "* Can we give these items to a neural network, or do they need to be transformed first?\n",
+    "  + Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n",
+    "    - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch; they are the PyTorch equivalent to Numpy arrays. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html) . \n",
+    "    - The targets are tuples of strings i.e. ('Gentoo', )\n",
+    "      - One idea is to represent as ordinal values i.e.  [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n",
+    "    \"A\" — [1, 0, 0]\\\n",
+    "    \"B\" — [0, 1, 0]\\\n",
+    "    \"C\" — [0, 0, 1]\n"
    ]
   },
   {
@@ -214,19 +335,77 @@
    "source": [
     "### Task 4: Applying transforms to the data\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",
+    "Modify the `PenguinDataset` class above so that the tuples of numbers are converted to PyTorch `torch.Tensor` s and the string targets are converted to one-hot vectors.\n",
+    "\n",
+    "- Begin by importing relevant PyTorch functions.\n",
+    "- Apply transformations inside `__getitem__()` function above.\n",
+    "\n",
+    "Then create a training and validation set.\n",
     "\n",
-    "These transforms can be very useful for mapping between file paths and tensors of images, etc.\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",
+    "  \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.\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",
-    "- 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."
+    "- Is this solution general?\n",
+    "  - No. The transformations have been hardcoded. A more flexible 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. See how this is done more generally in the `src/ml_workshop/_penguins.py` file. \n",
+    "\n",
+    "These transforms can be very useful for mapping between file paths and tensors of images, etc."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([  42.9000,   13.1000, 5000.0000,  215.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  46.1000,   13.2000, 4500.0000,  211.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  44.9000,   13.3000, 5100.0000,  213.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  43.3000,   13.4000, 4400.0000,  209.0000,    0.0000]) tensor([0., 0., 1.])\n",
+      "tensor([  42.0000,   13.5000, 4150.0000,  210.0000,    0.0000]) tensor([0., 0., 1.])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Apply transforms we need to PenguinDataset to convert input data and target class to tensors. \n",
+    "# See Task 4 exercise comments above.\n",
+    "\n",
+    "\n",
+    "# Create train_set\n",
+    "train_set = PenguinDataset(\n",
+    "    input_keys=features,\n",
+    "    target_keys=[\"species\"],\n",
+    "    train=True,\n",
+    ")\n",
+    "\n",
+    "# Create valid_set\n",
+    "valid_set = PenguinDataset(\n",
+    "    input_keys=features,\n",
+    "    target_keys=[\"species\"],\n",
+    "    train=False,\n",
+    ")\n",
+    "\n",
+    "\n",
+    "for _, (input_feats, target) in zip(range(5), train_set):\n",
+    "    print(input_feats, target)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### (Optional) Task 4b: \n",
+    "\n",
+    "Apply the `torchvision.transforms.Compose` transformations instead of hardcoding as above. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -244,6 +423,8 @@
    "source": [
     "from torchvision.transforms import Compose\n",
     "\n",
+    "from ml_workshop import PenguinDataset\n",
+    "\n",
     "# import some useful functions here, see https://pytorch.org/docs/stable/torch.html\n",
     "# where `tensor` and `eye` are used for constructing tensors,\n",
     "# and using a lower-precision float32 is advised for performance\n",
@@ -336,7 +517,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -387,7 +568,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -485,7 +666,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -507,7 +688,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -535,7 +716,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -692,34 +873,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 0-25 time: 1.934173 seconds\n",
-      "Epoch 25-50 time: 1.844448 seconds\n",
-      "Epoch 50-75 time: 1.831056 seconds\n",
-      "Epoch 75-100 time: 1.817979 seconds\n",
-      "Epoch 100-125 time: 1.822820 seconds\n",
-      "Epoch 125-150 time: 1.842434 seconds\n",
-      "Epoch 150-175 time: 1.967782 seconds\n",
+      "Epoch 0-25 time: 8.108920 seconds\n",
+      "Epoch 25-50 time: 8.245825 seconds\n",
+      "Epoch 50-75 time: 7.894095 seconds\n",
+      "Epoch 75-100 time: 8.292500 seconds\n",
+      "Epoch 100-125 time: 7.116918 seconds\n",
+      "Epoch 125-150 time: 6.541059 seconds\n",
+      "Epoch 150-175 time: 7.708282 seconds\n",
       "\n",
       "\n",
       "     loss_train  accuracy_train  loss_valid  accuracy_valid\n",
-      "0      0.578070        0.496324    0.586362        0.484375\n",
-      "1      0.490388        0.742647    0.495531        0.750000\n",
-      "2      0.417000        0.819853    0.406423        0.781250\n",
-      "3      0.371912        0.841912    0.356070        0.828125\n",
-      "4      0.325209        0.871324    0.310226        0.890625\n",
+      "0      0.614220        0.452206    0.668509        0.375000\n",
+      "1      0.524949        0.698529    0.527703        0.703125\n",
+      "2      0.460917        0.786765    0.463121        0.781250\n",
+      "3      0.380868        0.886029    0.396204        0.828125\n",
+      "4      0.347903        0.878676    0.337664        0.859375\n",
       "..          ...             ...         ...             ...\n",
-      "195    0.019916        0.988971    0.026766        0.984375\n",
-      "196    0.021192        0.988971    0.023146        0.984375\n",
-      "197    0.022928        0.988971    0.024764        0.984375\n",
-      "198    0.023786        0.985294    0.026085        0.984375\n",
-      "199    0.023932        0.981618    0.031793        0.984375\n",
+      "195    0.050222        0.966912    0.013005        0.984375\n",
+      "196    0.036788        0.985294    0.012601        1.000000\n",
+      "197    0.033748        0.970588    0.011316        1.000000\n",
+      "198    0.038716        0.988971    0.020271        0.984375\n",
+      "199    0.015950        0.988971    0.019603        0.984375\n",
       "\n",
       "[200 rows x 4 columns]\n"
      ]
@@ -774,12 +955,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x400 with 2 Axes>"
       ]
@@ -832,7 +1013,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -844,8 +1025,8 @@
       "        [3.3600e+01, 1.1300e+01, 2.0000e+03, 2.1100e+02, 1.0000e+00]])\n",
       "\n",
       "Raw output:\n",
-      "tensor([[2.4082e-05, 4.3393e-06, 9.9997e-01],\n",
-      "        [8.5355e-01, 6.9033e-06, 1.4644e-01]])\n",
+      "tensor([[8.2419e-07, 8.8322e-09, 1.0000e+00],\n",
+      "        [6.8586e-01, 4.3171e-06, 3.1413e-01]])\n",
       "\n",
       "Predicted species:\n",
       "['Gentoo', 'Adelie']\n",
@@ -894,7 +1075,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.9"
+   "version": "3.12.2"
   }
  },
  "nbformat": 4,