From ed375dbaa081975849baeae14bb5d98a23458d01 Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Thu, 4 Jul 2024 16:47:28 +0100 Subject: [PATCH] update the classification solutions notebook to utilise the PenguinDataset defined within the notebook itself --- .../01_penguin_classification_solutions.ipynb | 361 ++++++------------ 1 file changed, 117 insertions(+), 244 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index fcab877..bfb814d 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -32,38 +32,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " bill_length_mm bill_depth_mm flipper_length_mm body_mass_g \\\n", - "count 342.000000 342.000000 342.000000 342.000000 \n", - "mean 43.921930 17.151170 200.915205 4201.754386 \n", - "std 5.459584 1.974793 14.061714 801.954536 \n", - "min 32.100000 13.100000 172.000000 2700.000000 \n", - "25% 39.225000 15.600000 190.000000 3550.000000 \n", - "50% 44.450000 17.300000 197.000000 4050.000000 \n", - "75% 48.500000 18.700000 213.000000 4750.000000 \n", - "max 59.600000 21.500000 231.000000 6300.000000 \n", - "\n", - " year \n", - "count 344.000000 \n", - "mean 2008.029070 \n", - "std 0.818356 \n", - "min 2007.000000 \n", - "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" - ] - } - ], + "outputs": [], "source": [ "from palmerpenguins import load_penguins\n", "\n", @@ -108,6 +79,14 @@ "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 this 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", + "\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", @@ -123,9 +102,79 @@ "- 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": null, + "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" ] }, { @@ -146,39 +195,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "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" - ] - } - ], + "outputs": [], "source": [ - "from ml_workshop import PenguinDataset\n", - "\n", "features = [\n", " \"bill_length_mm\",\n", " \"bill_depth_mm\",\n", @@ -196,16 +216,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. 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,33 +239,22 @@ "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", - "\n", - "These transforms can be very useful for mapping between file paths and tensors of images, etc.\n", - "\n", - "- Note: here we create a training and validation set.\n", + "- 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." + "- 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", + "\n", + "Note: 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." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "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" - ] - } - ], + "outputs": [], "source": [ "from torchvision.transforms import Compose\n", "\n", @@ -249,58 +263,10 @@ "# and using a lower-precision float32 is advised for performance\n", "from torch import tensor, float32, eye\n", "\n", - "\n", - "# Apply the transforms we need to the PenguinDataset to get out input\n", - "# targets as Tensors.\n", - "\n", - "\n", - "def get_input_transforms() -> Compose:\n", - " \"\"\"Return transforms which map from raw inputs to tensors.\n", - "\n", - " Returns\n", - " -------\n", - " Compose\n", - " A composition of transforms (callable functions) to map the tuple\n", - " of input features (``Tuple[float, ...]``) to a ``torch.Tensor``.\n", - "\n", - " Notes\n", - " -----\n", - " To create a ``torch.Tensor`` we can use ``torch.tensor([1.0, 2.0, ...])``\n", - "\n", - " \"\"\"\n", - " return Compose([lambda x: tensor(x, dtype=float32)])\n", - "\n", - "\n", - "def get_target_tfms() -> Compose:\n", - " \"\"\"Return transforms which map from the raw target strings to tensor.\n", - " Returns\n", - " -------\n", - " Compose\n", - " A composition of transforms (callable functions) to map the tuple\n", - " of input features (``Tuple[str]``) to a ``torch.Tensor``.\n", - "\n", - " Notes\n", - " -----\n", - " Suppose we have three labels, \"A\", \"B\" and \"C\". We want to encoder each\n", - " distinct label as a one-hot-encoded vector. A natural way to do this is:\n", - " - \"A\" — [1, 0, 0]\n", - " - \"B\" — [0, 1, 0]\n", - " - \"C\" — [0, 0, 1]\n", - "\n", - " The transforms this function produces will return these vectors as tensors.\n", - " Note also, in the example we have just given, A's vector was the first row\n", - " in the identity matrix, B's the second, etc.\n", - "\n", - " \"\"\"\n", - " return Compose([lambda x: eye(len(target_names))[target_names.index(x[0])]])\n", - "\n", - "\n", "train_set = PenguinDataset(\n", " input_keys=features,\n", " target_keys=[\"species\"],\n", " train=True,\n", - " x_tfms=get_input_transforms(),\n", - " y_tfms=get_target_tfms(),\n", ")\n", "\n", "\n", @@ -308,8 +274,6 @@ " input_keys=features,\n", " target_keys=[\"species\"],\n", " train=False,\n", - " x_tfms=get_input_transforms(),\n", - " y_tfms=get_target_tfms(),\n", ")\n", "\n", "\n", @@ -336,20 +300,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([16, 5]) torch.Size([16, 3])\n", - "torch.Size([16, 5]) torch.Size([16, 3])\n", - "torch.Size([16, 5]) torch.Size([16, 3])\n", - "torch.Size([12, 5]) torch.Size([12, 3])\n" - ] - } - ], + "outputs": [], "source": [ "from torch.utils.data import DataLoader\n", "\n", @@ -387,30 +340,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FCNet(\n", - " (_fwd_seq): Sequential(\n", - " (0): BatchNorm1d(5, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (1): Linear(in_features=5, out_features=16, bias=True)\n", - " (2): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (3): Dropout(p=0.1, inplace=False)\n", - " (4): LeakyReLU(negative_slope=0.1)\n", - " (5): Linear(in_features=16, out_features=16, bias=True)\n", - " (6): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (7): Dropout(p=0.1, inplace=False)\n", - " (8): LeakyReLU(negative_slope=0.1)\n", - " (9): Linear(in_features=16, out_features=3, bias=True)\n", - " )\n", - ")\n" - ] - } - ], + "outputs": [], "source": [ "from torch.nn import Module\n", "from torch.nn import BatchNorm1d, Linear, LeakyReLU, Dropout, Sequential\n", @@ -485,7 +417,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -507,7 +439,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -535,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -692,39 +624,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "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", - "\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", - ".. ... ... ... ...\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", - "\n", - "[200 rows x 4 columns]\n" - ] - } - ], + "outputs": [], "source": [ "from time import perf_counter\n", "\n", @@ -774,20 +676,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from numpy import linspace\n", @@ -832,27 +723,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "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([[2.4082e-05, 4.3393e-06, 9.9997e-01],\n", - " [8.5355e-01, 6.9033e-06, 1.4644e-01]])\n", - "\n", - "Predicted species:\n", - "['Gentoo', 'Adelie']\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "from torch import no_grad\n", "\n", @@ -894,7 +767,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.2" } }, "nbformat": 4,