From e7de0a7d1802dc29b088ab00ef1f69f865a5f477 Mon Sep 17 00:00:00 2001 From: Matthew Archer <36638242+ma595@users.noreply.github.com> Date: Tue, 9 Jul 2024 14:54:31 +0100 Subject: [PATCH 1/2] Define a simpler PenguinDataset in Exercise 1 notebook (#73) * Update the classification solutions notebook to utilise the PenguinDataset defined within the notebook itself * Add solution outputs * Add 'task 4' to exercises * Add docstrings to class and re-add the Compose object approach as an n optional exercise * Add e * Improve task 2 text * Improve task 3 text and remove x_tfms and y_tfms comments * Fix Task 4 comment * Fix Task 3 comment with more on PyTorch Tensors --- exercises/01_penguin_classification.ipynb | 176 +++++++++- .../01_penguin_classification_solutions.ipynb | 315 ++++++++++++++---- 2 files changed, 410 insertions(+), 81 deletions(-) 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": [ "
" ] @@ -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, From 88fdb653b8ec5a03c14fa1589f774fe190745705 Mon Sep 17 00:00:00 2001 From: Matthew Archer <36638242+ma595@users.noreply.github.com> Date: Wed, 10 Jul 2024 19:38:08 +0100 Subject: [PATCH 2/2] More helper comments to make exercises easier to complete in a self directed way. (#75) * Additional helper comments and content throughout * Comment on the softmax function * Fix solution comment * More content * Fix formatting * Fix comment on output format * Forward modification * Updated autograd comment * Small changes --- exercises/01_penguin_classification.ipynb | 125 ++++++++++++++++-- .../01_penguin_classification_solutions.ipynb | 2 +- 2 files changed, 113 insertions(+), 14 deletions(-) diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb index cf532cb..05adb52 100644 --- a/exercises/01_penguin_classification.ipynb +++ b/exercises/01_penguin_classification.ipynb @@ -311,8 +311,11 @@ " - The ``DataLoader`` object allows us to put our inputs and targets in mini-batches, which makes for more efficient training.\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", + " - Q. What number should we choose for the batch size?\n", + " - The ``DataLoader`` can also randomly shuffle the data each epoch (when training). This avoids accidental patterns in the data harming the fitting process. Consider providing lots of the positive class followed by the negative class,\n", + "the network will only learn by saying yes all the time. Therefore need to intersperse positives and negatives.\n", + "\n", + " - The ``DataLoader`` also 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", "\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." @@ -337,23 +340,48 @@ "\n", "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", + "  The module `torch.nn` contains different classes that help you build neural network models. All models in PyTorch inherit from the subclass `nn.Module`, which has useful methods like `parameters()`, `__call__()` and others.\n", + "\n", + "  `torch.nn` also has various layers that you can use to build your neural network. For example, we will use `nn.Linear` in our code below, which constructs a fully connected layer. `torch.nn.Linear` is a subclass of `torch.nn.Module`. \n", + "\n", + "  What exactly is a \"layer\"? It is essentially a step in the neural network computation. i.e. The `nn.Linear` layer computes the linear transformation of the input vector `$x$`: `$y$ = $W^T x + b$`. Where `W` is the matrix of tunable parameters and `b` is a bias vector.\n", + "\n", + "We can also think of the ReLU activation as a \"layer\". However, there are no tunable parameters associated with the ReLU activation function.\n", + "\n", + "  The `__init__()` method is where we typically define the attributes of a class. In our case, all the \"sub-components\" of our model should be defined here.\n", + "\n", + "  The `forward` method is called when we use the neural network to make a prediction. Another term for \"making a prediction\" is running the forward pass, because information flows forward from the input through the hidden layers to the output. This builds a computational graph. To compute parameter updates, we run the backward pass by calling the function `loss.backward()`. During the backward pass, `autograd` traverses this graph to compute the gradients, which are then used to update the model's parameters.\n", + "\n", + "  The `forward` method is called from the `__call__()` function of `nn.Module`, so that when we run `model(batch)`, the `forward` method is called. \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", - "- We will then discuss a trick for making the print-out nicer.\n", + "- We will then utilise `torch.nn.Sequential` as a neater approach.\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": null, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "from torch.nn import Module\n", "from torch.nn import BatchNorm1d, Linear, ReLU, Dropout\n", + "from torch import Tensor\n", "\n", "\n", "class FCNet(Module):\n", - " \"\"\"Fully-connected neural network.\"\"\"" + " \"\"\"Fully-connected neural network.\"\"\"\n", + "\n", + " # define __init__ function - model defined here.\n", + " def __init__(self):\n", + " pass\n", + "\n", + " # define forward function which calls network\n", + " def forward(self, batch: Tensor) -> Tensor:\n", + " pass\n", + "\n", + "\n", + "# define a model and print and test (try with torch.rand() function)" ] }, { @@ -384,7 +412,9 @@ "\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", + "\n", + "Here we will tell the optimiser what parameters to fit in order to minimise the loss. " ] }, { @@ -397,20 +427,58 @@ "from torch.optim import Adam" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Have a go at importing the model weights for a large model like ResNet50" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 9: Writing basic training and validation loops\n", "\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", - " - 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", + "- Before we jump in and write these loops, we must first choose an activation function to apply to the model's outputs so that they compared to our targets i.e. `[0, 0, 1]`. We chose not to include this in the network itself.\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). It can be seen as a generalization of both the logits and sigmoid functions to handle multi-class classification tasks\n", + " - For those of you who've studied physics, you may be reminded of the partition function in thermodynamics.\n", + " - This activation function is good for classification when the result is one of ``A or B or C``.\n", + " - It's bad if you even want to assign two classification to a single image—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", - "- We will write the training loop together, then you can go ahead and write the (simpler) validation loop." + "- Have a go at writing these loops. Read the comments below for help.\n", + "\n", + "TIPS:\n", + "\n", + "- The model needs to be configured for training and validation.\n", + "- We need to tell the softmax function over what dimension we should sum the probabilities over in order to equal 1. This should be along the column axis. \n", + "- The automatic behaviour of the optimiser is to accumulate gradients during training.\n", + "\n", + "- Extracting metrics: \n", + " - Define a dictionary `metrics = {\"loss\": [], \"accuracy\" : []}`\n", + " - Append the loss `loss.item()` which is a 1x1 tensor. We do not need gradients.\n", + " - Get the accuracy by writing a function `get_batch_accuracy(preds: Tensor, targets: Tensor)`.\n", + " - A decision can be computed as follows: `decision = preds.argmax(dim=1)`\n", + " - We need to supply the metrics as `means` over each epoch.\n", + " - The metrics should be a dictionary containing \"loss\" and \"accuracy\" as keys and lists as values which we append to each iteration. We can then use dictionary comprehension to get epoch statistics. \n", + " ```\n", + " metrics = {\"loss \" : [1.0, 2.0, 3.0], \"accuracy\" : [0.7, 0.8, 0.9]}\n", + " return {k : mean(v) for k, v in metrics.items() }\n", + " ```\n", + " - If the validation performance gets really poor this is a sign that we have possibly overfit. \n", + "\n", + "- Utilise `@no_grad` where possible. It temporarily disables gradient calculation, which is beneficial during evaluation phases when gradient updates are not required. \n", + "\n", + "\n", + "NOTE: In PyTorch, `requires_grad=True` is set automatically for the parameters of layers defined using `torch.nn.Module` subclasses. Examine the following example:\n", + "```\n", + "x = ones(10, requires_grad=True)\n", + "y = 2*x.exp()\n", + "print(y)\n", + "```\n", + "- Why use BCELoss?\n", + " - It may seem odd to be using BCELoss for a multi-class classification problem. In this case, BCELoss treats each element of the prediction vector as an independent binary classification problem. For each class, it compares the predicted probability against the target and computes the loss. It might be better to use `CrossEntropyLoss` instead (ground truth does not need to be one-hot encoded). `CrossEntropyLoss` combines softmax and negative log likelihood. \n" ] }, { @@ -448,6 +516,27 @@ "\n", " \"\"\"\n", "\n", + " # setup the model for training. IMPORTANT!\n", + "\n", + " # setup loss and accuracy metrics dictionary\n", + "\n", + " # iterate over the batch, targets in the train_loader\n", + " for batch, targets in train_loader:\n", + " pass\n", + "\n", + " # zero the gradients (otherwise gradients accumulate)\n", + "\n", + " # run forward model and compute proxy probabilities over dimension 1 (columns of tensor).\n", + "\n", + " # compute loss\n", + " # e.g. pred = [0.2, 0.7, 0.1] and target = [0, 1, 0]\n", + "\n", + " # compute gradients\n", + "\n", + " # nudge parameters in direction of steepest descent c\n", + "\n", + " # append metrics\n", + "\n", "\n", "def validate_one_epoch(\n", " model: Module,\n", @@ -470,7 +559,10 @@ " Dict[str, float]\n", " Metrics of interest.\n", "\n", - " \"\"\"" + " \"\"\"\n", + "\n", + " for batch, targets in valid_loader:\n", + " pass" ] }, { @@ -498,7 +590,14 @@ "source": [ "epochs = 3\n", "\n", + "# define train_metrics and valid_metrics lists. \n", + "\n", "for _ in range(epochs):\n", + "\n", + " # append output of train_one_epoch() to train_metrics\n", + "\n", + " # append output of valid_one_epoch() to valid_metrics\n", + "\n", " pass" ] }, diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 25b6f49..04c51d2 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -810,7 +810,7 @@ " and to instead use the stats it has built up from the training set.\n", " The model should not \"remember\" anything from the validation set.\n", " - We also protect this function with ``torch.no_grad()``, because having\n", - " gradients enable while validating is a pointless waste of\n", + " gradients enabled while validating is a pointless waste of\n", " resources — they are only needed for training.\n", "\n", " \"\"\"\n",