From 4d198d8d37ba4d65969c04b2ddbf2cc103a59258 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Mon, 1 Jul 2024 10:21:34 +0100 Subject: [PATCH 01/19] Updated the markdown for Task1 in Exercise1 penguin --- exercises/01_penguin_classification.ipynb | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) 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, From 6f39653c499f0034ef1a1e20be46620509af1dc2 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Mon, 1 Jul 2024 10:29:48 +0100 Subject: [PATCH 02/19] Updated Task1 markdown in Exercise1 solutions --- .../01_penguin_classification_solutions.ipynb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index c8666eb..5aa4806 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -23,11 +23,11 @@ "### 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 statistical information on the dataset using ``pd.DataFrame.Series.describe()``" ] }, { @@ -900,7 +900,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.12.4" } }, "nbformat": 4, From 224d3cd17397fb4ee74160adac4cbb8b002d38b3 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Mon, 1 Jul 2024 11:11:36 +0100 Subject: [PATCH 03/19] Updated Task2 markdown in Exercise1 solutions --- .../01_penguin_classification_solutions.ipynb | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 5aa4806..3c41bf9 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -108,23 +108,25 @@ "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", - "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\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", - "- Open the file ``src/ml_workshop/_penguins.py``.\n", + "Spoiler alert: we've done this for you already in ``worked-solutions/01_penguin_classification_solutions.ipynb``.\n", + "\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_. Remember Pytorch deals with tensors only.\n", " - ``y_tfms``— A ``Compose`` object with functions which will convert the raw target to a tensor. This argument is _optional_." ] }, From dcee528d971b7c6def6031f58e81a174fb26f4ff Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Mon, 1 Jul 2024 13:35:08 +0100 Subject: [PATCH 04/19] Updated Task3 markdown in Exercise1 solutions --- worked-solutions/01_penguin_classification_solutions.ipynb | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 3c41bf9..913d33d 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -134,10 +134,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Task 3: obtaining training and validation datasets\n", + "### Task 3: obtaining training and validation subsets 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", @@ -189,6 +189,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", From 74bb0c6f4ab6ec92aa6866aa5ed1cce20339f655 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Mon, 1 Jul 2024 15:41:05 +0100 Subject: [PATCH 05/19] Updated Task3 and Task4 markdown in Exercise1 solutions --- .../01_penguin_classification_solutions.ipynb | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 913d33d..01df8af 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -134,7 +134,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Task 3: obtaining training and validation subsets from data\n", + "### Task 3: Obtaining features and targets from data\n", "\n", "- Instantiate the penguin dataloader.\n", " - Make sure you pass the correct column names for the input features and the targets.\n", @@ -215,15 +215,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Task 4: Applying transforms to the data\n", + "### Task 4: Transforming Input Data for Neural Networks \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", + "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", - "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 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", - "- 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", + "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 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." ] }, From 5ebca662aa4386227e2842d26fc37fb81264b2d7 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Tue, 2 Jul 2024 11:19:58 +0100 Subject: [PATCH 06/19] Updated Task5 markdown in Exercise1 solutions --- .../01_penguin_classification_solutions.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 01df8af..90d4ad0 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -328,14 +328,14 @@ "### 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`` utility allows us to load and put inputs and targets in mini-batches, which makes iterating over the dataset during training more efficient.\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 number of observations we pass at once is called the batch size.\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." ] }, { From 97ef68d290501b809ae80c4795a45321d856a99f Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Tue, 2 Jul 2024 11:36:43 +0100 Subject: [PATCH 07/19] Updated Task6 markdown in Exercise1 solutions --- worked-solutions/01_penguin_classification_solutions.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 90d4ad0..e7ee376 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -385,6 +385,7 @@ "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." ] From 7d4a8c27dfd4607788a88a2857c9c652d5178592 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Tue, 2 Jul 2024 11:40:50 +0100 Subject: [PATCH 08/19] Updated Task7 markdown in Exercise1 solutions --- worked-solutions/01_penguin_classification_solutions.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index e7ee376..9feda37 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -479,7 +479,9 @@ "source": [ "### Task 7: Selecting a loss function\n", "\n", - "- Binary cross-entropy is about the most common loss function for classification.\n", + "- Loss function drives the learning process and plays a crucial role. \n", + "- Most commonly used loss fucntions are MSE, MAPE, RMSE for regression.\n", + "- For classification, Binary cross-entropy is the most common loss function.\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." ] From 4cddfee975cdd48eee690c58aa4f4bc458bff809 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Tue, 2 Jul 2024 12:02:14 +0100 Subject: [PATCH 09/19] Updated Task8 markdown in Exercise1 solutions --- worked-solutions/01_penguin_classification_solutions.ipynb | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 9feda37..a964fce 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -503,9 +503,13 @@ "source": [ "### Task 8: Selecting an optimiser\n", "\n", + "Optimiser updates the model's weights and biases on the basis of the gradient of the loss function w.r.t each weight and bias. The aim of weight updation is to reduce the loss. The weight updation goes on until the loss is minimised as much as possible. \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 slightly more complex and improved implementation of SGD." ] }, { From 16534f62f368ca56d0aa1d2ff4a4c3cde1e17d2a Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Tue, 2 Jul 2024 13:24:43 +0100 Subject: [PATCH 10/19] Updated Task9 markdown in Exercise1 solutions --- worked-solutions/01_penguin_classification_solutions.ipynb | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index a964fce..13fba9a 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -532,11 +532,13 @@ "\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", " - 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 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 and repeat it until we receive a satisfactory performance.\n", + "- The validation loop works similarly, but the purpose is to validate the model training's performance.\n", "- We will write the training loop together, then you can go ahead and write the (simpler) validation loop." ] }, From acb9039361db74700c0d62e14d8f672cd3d36bf1 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Tue, 2 Jul 2024 16:23:08 +0100 Subject: [PATCH 11/19] Updated Task9 and 10 markdown in Exercise1 solutions --- worked-solutions/01_penguin_classification_solutions.ipynb | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 13fba9a..2dbe533 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -538,7 +538,8 @@ "\n", "\n", "- The purpose of 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 and repeat it until we receive a satisfactory performance.\n", - "- The validation loop works similarly, but the purpose is to validate the model training's 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 with validation loop.\n", + "- ``batch_level_accuracy`` is also calculated to track the model performance.\n", "- We will write the training loop together, then you can go ahead and write the (simpler) validation loop." ] }, From a772685acb188d275d7a251435af0ec3ebfa5562 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Wed, 3 Jul 2024 08:19:00 +0100 Subject: [PATCH 12/19] Updated introduction of dataset markdown in Exercise1 solutions --- worked-solutions/01_penguin_classification_solutions.ipynb | 2 ++ 1 file changed, 2 insertions(+) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 2dbe533..d1374cc 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." ] }, From ce19a720238a84ac94943f00260a13da103a149f Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Wed, 3 Jul 2024 08:56:57 +0100 Subject: [PATCH 13/19] Updated Task1 code in Exercise1 solutions --- .../01_penguin_classification_solutions.ipynb | 53 ++++++++++++++----- 1 file changed, 41 insertions(+), 12 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index d1374cc..785aba4 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -34,7 +34,45 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, + "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", + "Index(['species', 'island', 'bill_length_mm', 'bill_depth_mm',\n", + " 'flipper_length_mm', 'body_mass_g', 'sex', 'year'],\n", + " dtype='object')\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": 2, "metadata": {}, "outputs": [ { @@ -59,23 +97,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())" ] }, { From 525602c153a6f6b8e5eeee26b06ee97c9fb3c394 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Wed, 3 Jul 2024 10:46:30 +0100 Subject: [PATCH 14/19] Updated location of pytorch dataset for penguins code in Exercise1 solutions --- .../01_penguin_classification_solutions.ipynb | 119 +++++++++--------- 1 file changed, 63 insertions(+), 56 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 785aba4..f943a26 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -65,7 +65,7 @@ "\n", "data = load_penguins()\n", "\n", - "print (data.head())\n", + "print(data.head())\n", "\n", "# print(data.keys())" ] @@ -128,7 +128,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." ] @@ -143,7 +143,7 @@ "\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 ``worked-solutions/01_penguin_classification_solutions.ipynb``.\n", + "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\n", "\n", "- Open the above mentioned file.\n", "- Let's examine, and discuss, each of the methods together.\n", @@ -179,7 +179,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -262,7 +262,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -371,7 +371,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -423,7 +423,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -519,7 +519,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -545,7 +545,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -576,7 +576,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -733,56 +733,56 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "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.166 seconds.\n", + "Epoch 1 time: 0.077 seconds.\n", + "Epoch 2 time: 0.081 seconds.\n", + "Epoch 3 time: 0.077 seconds.\n", + "Epoch 4 time: 0.076 seconds.\n", + "Epoch 5 time: 0.077 seconds.\n", + "Epoch 6 time: 0.078 seconds.\n", + "Epoch 7 time: 0.075 seconds.\n", + "Epoch 8 time: 0.072 seconds.\n", + "Epoch 9 time: 0.092 seconds.\n", + "Epoch 10 time: 0.095 seconds.\n", + "Epoch 11 time: 0.074 seconds.\n", + "Epoch 12 time: 0.074 seconds.\n", + "Epoch 13 time: 0.072 seconds.\n", + "Epoch 14 time: 0.072 seconds.\n", + "Epoch 15 time: 0.072 seconds.\n", + "Epoch 16 time: 0.073 seconds.\n", + "Epoch 17 time: 0.074 seconds.\n", + "Epoch 18 time: 0.074 seconds.\n", + "Epoch 19 time: 0.073 seconds.\n", "\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" + "0 0.891852 0.091912 0.689194 0.416667\n", + "1 0.594595 0.481618 0.505639 0.718750\n", + "2 0.433962 0.779412 0.370413 0.843750\n", + "3 0.339859 0.911765 0.294670 0.921875\n", + "4 0.282734 0.937500 0.246412 0.968750\n", + "5 0.238807 0.922794 0.210190 0.968750\n", + "6 0.193892 0.959559 0.172594 0.968750\n", + "7 0.166585 0.974265 0.163018 0.968750\n", + "8 0.166698 0.952206 0.139888 0.968750\n", + "9 0.140420 0.966912 0.126394 0.968750\n", + "10 0.126446 0.974265 0.110936 0.968750\n", + "11 0.151546 0.955882 0.101456 0.968750\n", + "12 0.139596 0.930147 0.095308 0.968750\n", + "13 0.111534 0.981618 0.084280 0.984375\n", + "14 0.085713 0.985294 0.085504 0.968750\n", + "15 0.096706 0.959559 0.079379 0.968750\n", + "16 0.097048 0.963235 0.071572 0.968750\n", + "17 0.075431 0.988971 0.068198 0.984375\n", + "18 0.081767 0.970588 0.064556 0.968750\n", + "19 0.084336 0.970588 0.065786 0.968750\n" ] } ], @@ -827,12 +827,19 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 13, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Matplotlib is building the font cache; this may take a moment.\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -884,7 +891,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -896,8 +903,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([[0.0038, 0.0024, 0.9938],\n", + " [0.8717, 0.0015, 0.1268]])\n", "\n", "Predicted species:\n", "['Gentoo', 'Adelie']\n", From 937d2ba0cdfea3e6491e2d889a33bb40eee6bc45 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Fri, 5 Jul 2024 15:07:28 +0100 Subject: [PATCH 15/19] Made the changes requested in the PR review for penguins code in Exercise1 solutions --- .../01_penguin_classification_solutions.ipynb | 142 ++++++++---------- 1 file changed, 65 insertions(+), 77 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index f943a26..15ea3b5 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -27,14 +27,14 @@ "\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", - "- Analyse which features it might make sense to use in order to classify the species of the penguins.\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 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": 3, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -53,10 +53,7 @@ "1 3800.0 female 2007 \n", "2 3250.0 female 2007 \n", "3 NaN NaN 2007 \n", - "4 3450.0 female 2007 \n", - "Index(['species', 'island', 'bill_length_mm', 'bill_depth_mm',\n", - " 'flipper_length_mm', 'body_mass_g', 'sex', 'year'],\n", - " dtype='object')\n" + "4 3450.0 female 2007 \n" ] } ], @@ -72,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -157,7 +154,7 @@ " - ``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_. Remember Pytorch deals with tensors only.\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_." ] }, @@ -179,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -262,7 +259,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -359,9 +356,9 @@ "### Task 5: Creating ``DataLoaders``—and why\n", "\n", "- Once we have created a ``Dataset`` object, we wrap it in a ``DataLoader``.\n", - " - The ``DataLoader`` utility allows us to load and put inputs and targets in mini-batches, which makes iterating over the dataset during training more efficient.\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 observations we pass at once is called the batch size.\n", + " - The number of items we supply at once is called the batch size.\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", @@ -371,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -423,7 +420,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -510,16 +507,14 @@ "source": [ "### Task 7: Selecting a loss function\n", "\n", - "- Loss function drives the learning process and plays a crucial role. \n", - "- Most commonly used loss fucntions are MSE, MAPE, RMSE for regression.\n", - "- For classification, Binary cross-entropy is the most common loss function.\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": 9, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -534,18 +529,18 @@ "source": [ "### Task 8: Selecting an optimiser\n", "\n", - "Optimiser updates the model's weights and biases on the basis of the gradient of the loss function w.r.t each weight and bias. The aim of weight updation is to reduce the loss. The weight updation goes on until the loss is minimised as much as possible. \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 slightly 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": 10, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -568,15 +563,15 @@ " - 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 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 and repeat 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 with validation loop.\n", - "- ``batch_level_accuracy`` is also calculated to track the model performance.\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": 11, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -733,56 +728,56 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0 time: 0.166 seconds.\n", - "Epoch 1 time: 0.077 seconds.\n", - "Epoch 2 time: 0.081 seconds.\n", - "Epoch 3 time: 0.077 seconds.\n", - "Epoch 4 time: 0.076 seconds.\n", - "Epoch 5 time: 0.077 seconds.\n", - "Epoch 6 time: 0.078 seconds.\n", - "Epoch 7 time: 0.075 seconds.\n", - "Epoch 8 time: 0.072 seconds.\n", - "Epoch 9 time: 0.092 seconds.\n", - "Epoch 10 time: 0.095 seconds.\n", - "Epoch 11 time: 0.074 seconds.\n", - "Epoch 12 time: 0.074 seconds.\n", + "Epoch 0 time: 0.112 seconds.\n", + "Epoch 1 time: 0.073 seconds.\n", + "Epoch 2 time: 0.072 seconds.\n", + "Epoch 3 time: 0.071 seconds.\n", + "Epoch 4 time: 0.069 seconds.\n", + "Epoch 5 time: 0.071 seconds.\n", + "Epoch 6 time: 0.068 seconds.\n", + "Epoch 7 time: 0.072 seconds.\n", + "Epoch 8 time: 0.076 seconds.\n", + "Epoch 9 time: 0.071 seconds.\n", + "Epoch 10 time: 0.073 seconds.\n", + "Epoch 11 time: 0.071 seconds.\n", + "Epoch 12 time: 0.067 seconds.\n", "Epoch 13 time: 0.072 seconds.\n", - "Epoch 14 time: 0.072 seconds.\n", - "Epoch 15 time: 0.072 seconds.\n", - "Epoch 16 time: 0.073 seconds.\n", - "Epoch 17 time: 0.074 seconds.\n", - "Epoch 18 time: 0.074 seconds.\n", - "Epoch 19 time: 0.073 seconds.\n", + "Epoch 14 time: 0.068 seconds.\n", + "Epoch 15 time: 0.068 seconds.\n", + "Epoch 16 time: 0.070 seconds.\n", + "Epoch 17 time: 0.071 seconds.\n", + "Epoch 18 time: 0.069 seconds.\n", + "Epoch 19 time: 0.069 seconds.\n", "\n", "\n", " loss_train accuracy_train loss_valid accuracy_valid\n", - "0 0.891852 0.091912 0.689194 0.416667\n", - "1 0.594595 0.481618 0.505639 0.718750\n", - "2 0.433962 0.779412 0.370413 0.843750\n", - "3 0.339859 0.911765 0.294670 0.921875\n", - "4 0.282734 0.937500 0.246412 0.968750\n", - "5 0.238807 0.922794 0.210190 0.968750\n", - "6 0.193892 0.959559 0.172594 0.968750\n", - "7 0.166585 0.974265 0.163018 0.968750\n", - "8 0.166698 0.952206 0.139888 0.968750\n", - "9 0.140420 0.966912 0.126394 0.968750\n", - "10 0.126446 0.974265 0.110936 0.968750\n", - "11 0.151546 0.955882 0.101456 0.968750\n", - "12 0.139596 0.930147 0.095308 0.968750\n", - "13 0.111534 0.981618 0.084280 0.984375\n", - "14 0.085713 0.985294 0.085504 0.968750\n", - "15 0.096706 0.959559 0.079379 0.968750\n", - "16 0.097048 0.963235 0.071572 0.968750\n", - "17 0.075431 0.988971 0.068198 0.984375\n", - "18 0.081767 0.970588 0.064556 0.968750\n", - "19 0.084336 0.970588 0.065786 0.968750\n" + "0 0.527726 0.610294 0.456206 0.859375\n", + "1 0.358156 0.915441 0.294527 0.984375\n", + "2 0.258904 0.937500 0.215179 1.000000\n", + "3 0.211985 0.970588 0.166647 1.000000\n", + "4 0.160413 0.981618 0.141760 0.984375\n", + "5 0.152303 0.977941 0.121987 0.984375\n", + "6 0.131642 0.970588 0.106669 0.984375\n", + "7 0.117759 0.974265 0.098318 0.984375\n", + "8 0.113611 0.981618 0.089592 0.984375\n", + "9 0.080194 0.988971 0.085228 0.984375\n", + "10 0.090383 0.977941 0.078351 0.984375\n", + "11 0.086436 0.974265 0.068474 0.984375\n", + "12 0.070517 0.988971 0.065900 0.984375\n", + "13 0.061423 0.992647 0.062842 0.984375\n", + "14 0.074861 0.981618 0.059400 0.984375\n", + "15 0.080182 0.970588 0.051717 0.984375\n", + "16 0.086207 0.970588 0.054224 0.968750\n", + "17 0.059919 0.985294 0.057170 0.968750\n", + "18 0.053037 0.988971 0.051295 0.984375\n", + "19 0.104912 0.963235 0.046237 0.984375\n" ] } ], @@ -827,19 +822,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 25, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Matplotlib is building the font cache; this may take a moment.\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -891,7 +879,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -903,8 +891,8 @@ " [3.3600e+01, 1.1300e+01, 2.0000e+03, 2.1100e+02, 1.0000e+00]])\n", "\n", "Raw output:\n", - "tensor([[0.0038, 0.0024, 0.9938],\n", - " [0.8717, 0.0015, 0.1268]])\n", + "tensor([[1.2761e-03, 5.2205e-04, 9.9820e-01],\n", + " [9.6627e-01, 1.6535e-03, 3.2073e-02]])\n", "\n", "Predicted species:\n", "['Gentoo', 'Adelie']\n", From 71c17a64b7fc8b1f214164c9f32834801cd02da4 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Tue, 9 Jul 2024 10:24:37 +0100 Subject: [PATCH 16/19] Corrected the markdown in Task5. --- worked-solutions/01_penguin_classification_solutions.ipynb | 1 + 1 file changed, 1 insertion(+) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 15ea3b5..3cea181 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -558,6 +558,7 @@ "\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,\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", From bf82e32b37cd30d8ad82783a9fd0a3a0b2905404 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Wed, 10 Jul 2024 17:35:06 +0100 Subject: [PATCH 17/19] Added Repo access intsructions, virtual env creation and a summary slide --- slides/slides.qmd | 63 +++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 56 insertions(+), 7 deletions(-) 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 ` +- `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 From 5a2501293d25d62b16ee23dd4326e6e5752f3399 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Wed, 10 Jul 2024 20:42:39 +0100 Subject: [PATCH 18/19] Updated Task10 and Task11 --- .../01_penguin_classification_solutions.ipynb | 515 +++++++++++++++--- 1 file changed, 426 insertions(+), 89 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 3cea181..9be6439 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -34,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 41, "metadata": {}, "outputs": [ { @@ -69,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -158,6 +158,78 @@ " - ``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": {}, @@ -176,38 +248,38 @@ }, { "cell_type": "code", - "execution_count": 17, + "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", @@ -259,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -331,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", @@ -340,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", @@ -368,7 +440,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -420,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -514,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 48, "metadata": {}, "outputs": [], "source": [ @@ -540,7 +612,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -572,7 +644,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ @@ -710,6 +782,28 @@ " return (preds.argmax(dim=1) == targets.argmax(dim=1)).float().mean()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\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", + "\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -729,62 +823,86 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0 time: 0.112 seconds.\n", - "Epoch 1 time: 0.073 seconds.\n", - "Epoch 2 time: 0.072 seconds.\n", - "Epoch 3 time: 0.071 seconds.\n", - "Epoch 4 time: 0.069 seconds.\n", - "Epoch 5 time: 0.071 seconds.\n", - "Epoch 6 time: 0.068 seconds.\n", - "Epoch 7 time: 0.072 seconds.\n", - "Epoch 8 time: 0.076 seconds.\n", - "Epoch 9 time: 0.071 seconds.\n", - "Epoch 10 time: 0.073 seconds.\n", - "Epoch 11 time: 0.071 seconds.\n", - "Epoch 12 time: 0.067 seconds.\n", - "Epoch 13 time: 0.072 seconds.\n", - "Epoch 14 time: 0.068 seconds.\n", - "Epoch 15 time: 0.068 seconds.\n", - "Epoch 16 time: 0.070 seconds.\n", - "Epoch 17 time: 0.071 seconds.\n", - "Epoch 18 time: 0.069 seconds.\n", - "Epoch 19 time: 0.069 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", + "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", - " loss_train accuracy_train loss_valid accuracy_valid\n", - "0 0.527726 0.610294 0.456206 0.859375\n", - "1 0.358156 0.915441 0.294527 0.984375\n", - "2 0.258904 0.937500 0.215179 1.000000\n", - "3 0.211985 0.970588 0.166647 1.000000\n", - "4 0.160413 0.981618 0.141760 0.984375\n", - "5 0.152303 0.977941 0.121987 0.984375\n", - "6 0.131642 0.970588 0.106669 0.984375\n", - "7 0.117759 0.974265 0.098318 0.984375\n", - "8 0.113611 0.981618 0.089592 0.984375\n", - "9 0.080194 0.988971 0.085228 0.984375\n", - "10 0.090383 0.977941 0.078351 0.984375\n", - "11 0.086436 0.974265 0.068474 0.984375\n", - "12 0.070517 0.988971 0.065900 0.984375\n", - "13 0.061423 0.992647 0.062842 0.984375\n", - "14 0.074861 0.981618 0.059400 0.984375\n", - "15 0.080182 0.970588 0.051717 0.984375\n", - "16 0.086207 0.970588 0.054224 0.968750\n", - "17 0.059919 0.985294 0.057170 0.968750\n", - "18 0.053037 0.988971 0.051295 0.984375\n", - "19 0.104912 0.963235 0.046237 0.984375\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", @@ -794,22 +912,240 @@ "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", + "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": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Loss plot\n", + "plt.figure(figsize=(6, 4))\n", + "\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": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Accuracy plot\n", + "plt.figure(figsize=(6, 4))\n", + "\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", - "print(metrics)" + "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" ] }, { @@ -823,12 +1159,12 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 58, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAGGCAYAAADmRxfNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABlh0lEQVR4nO3deVhUZf8G8PvMAIMIjAKyL+KeoqioiOYaCVZu5b6b+mvR14z3TdNyy8qst7K3LMsyNc01l8zcQjFNTHMnXBFF2RQRhp1h5vz+QCaRGQc4AzPA/bkuLuXMWb7nDDPP3POc5xxBFEURREREREREEsjMXQAREREREdV8DBZERERERCQZgwUREREREUnGYEFERERERJIxWBARERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZAwWREREREQkmUUGi99//x0DBgyAp6cnBEHAjh07jC4TFRWFjh07QqFQoFmzZli9enWV10lERNWPbQQRkWWyyGCRk5ODwMBALF++vFzzx8fH49lnn0WfPn1w9uxZzJw5E1OmTMG+ffuquFIiIqpubCOIiCyTIIqiaO4iHkcQBGzfvh2DBw82OM/s2bOxe/duxMTE6KaNHDkSGRkZ2Lt3bzVUSURE5sA2gojIclhkj0VFRUdHIzQ0tNS0sLAwREdHm6kiIiKyFGwjiIiqh5W5CzCFlJQUuLm5lZrm5uYGlUqFvLw81KtXr8wyBQUFKCgo0P2u1WqRnp4OZ2dnCIJQ5TUTEVUXURSRlZUFT09PyGS14vukCmEbQUSkn6nbh1oRLCpjyZIlWLRokbnLICKqNrdu3YK3t7e5y6gR2EYQUV1iqvahVgQLd3d3pKamlpqWmpoKR0dHvd9EAcCcOXMQERGh+z0zMxO+vr64desWHB0dq7ReIqLqpFKp4OPjAwcHB3OXYhYmbSNet4e9TXGPxYUuHyIwdLTB7Z777Ue0PTELACB7qJND+2Bko7HlAQCXfgW2vwQRIh7uJxEhFP8+5Gug1TN6F9VoRbzz3/9iQdFnBmtYZPUa5v/nP5DLDPTCSNj+o+sAHh3S+WCNxtZx6VeID2p4+PtULQABAoRy1iBlHVKfy/Is36zHcFxMUuF8YgZiEjNxIVGF5Mx83bxPyU7hU+svDa7jdfWriNQGGayhPMuPGfcyujRx0r8Cqc8jTPCakPj3aMrXRGWOw4nr6Vj/wwqjz8NZ265wVdqiQT0bONazgrKete7H3tYKp/f/iHfFz02yD6oCET6fZpusfagVwSIkJAS//vprqWkHDhxASEiIwWUUCgUUCkWZ6Y6OjgwWRFQr1dVTeEzaRigEOCoEaEWgxfkPUT98FORWZZtSTVERWp5fCkeFAH1tu7Hli2fSAEcWQlSg5GNTKSIECEcXAe2eAWTy0o+JInadvYVZ8h/gKDdcwyysw5WkFxHczNWk2390HVAA0LMOQAAetw6tBvkH58HGBpDp+fvVikDBofmoZ6QGKeuQ+lyWZ/lm55bi6RPO0Dwy9NXeVoZmjezh4WCFhbc3whGG1/G+YhPODZyExo2UyMgthCpPjYw8NTLzinDm5l3Mu2l8+VPqiXC01f88SHoey3kcHvuakPj3WFikxbZTCeV8TUxGcLNGBmuo6HEQRRGXUrKx7XQ83rc3/jyEFgQhIV2DBOSUmUcGLX5TrH/sOiqzD6ZqHyzyqlDZ2dm4du0aAKBDhw745JNP0KdPHzg5OcHX1xdz5sxBYmIi1q5dC6D4UoIBAQGYNm0aXnzxRRw8eBAzZszA7t27ERYWVq5tqlQqKJVKZGZmMlgQUa1S297fzNpGvOkAR0XdDGhEVPuoCkQoP8gyWftgkaP4/vrrL3To0AEdOnQAAERERKBDhw6YP38+ACA5ORkJCQm6+f39/bF7924cOHAAgYGB+Pjjj/Htt9+Wu8EgIqKag20EEZFlssgeC3Oobd/oERGV4PubdIZ6LA53/hLu7Z4qM3/K+Uj0Ovmq0fVO1czGUXVLvY91ll3CWpsPja5jfOEs/CW2QhMXe7TzVqKtlxJtvRqged55KDYPN7r85dDvcULbChduZ+BCogo37uVUaPuxfVahdUi4/gdvHgPWDzW6DozZCvh10/2q1Yq4mJKFQ/u3Y3rSHKOLjy+chZPaVnofK+9+vCS+iVsOHXTnsjeoZw1lPRu4pP+FqQmzjC4v9W+hKo5jRZcvOY5PNnPBggFt4N2wnuTtF2m0+DUmGQf37cSyoneNrmKSejaOa8q+JiryejipbQUbKxlaeziirZcS7byVaOfdAF6ZpyHfYPw18V+Xd7E+1Rv5aq1umlwmYKTrbbydMa/cNQgC0NXfGc+29UBoazco75yU9jwC0MT/AfmGYUZXMaFwFk48eE3IBCCkiTOea+eJfvZxsNsyUjefqXssasUYCyIiouqkFYE7gjOeDBuh93zwZh4jkHpyHhqJ9wyeB31HcMZX899AZoEWN+7l4ua9nH/+TcvBqVRbJIlOcEe6wXWkwBmBPQfji94t4Ghr/cgMrsir5w5FborB5Qvs3NGy2yC0fOh88IzcQpy7nYnNf/og6dq3Rre/LN4LQ12y0N6nAVwdbUvP1LQv4OgJUZUMocxg1wfnxTt6Ak37Ij1PgyNX7+Lwlbv4/Uoa0rILIIMPnlcYPwYdeg/BcPcGZWcAcDXlCST9YXw/Jo6djJDmZceaaIoCkfruUqPPpdS/hZbdBwGGxts8OI5QJaPsoGEAEIofb9pX/xiHcjwPcPRE53Yv4PiheBy4lo2jX/yFf/drgUnd/SGvxPaLNFrsOJuE5YeuIT4tBzK0wiwjz+UdwRlfL3gDd3LUuHkvFzfu5eDmvVzEp+Xg71v2SCo0/rfg3qE/Noc0RUt3B9hYPXJijmtouV4T/3n1VUzXACdvpCPqcvHf5LU72ViV4o8Xy/H3mOHWHf/u6IsBgZ5we/g14VD+14OhsSry5k+Vax/++/rr+CUmFTvOJuHcrQz8FpeD3+Kuop4VcMTGBU6aNL3LS8VgQUREVAElV15JDlkAdwMfBOVWVkgKWYBGx2ZAK+q/cktyyAK4W1vD2RpwtlcgyK9hqXVEx93Dou/G4yvrZQbXsUg9DhObu5cNFQAgk6PegI8gbh4Prb6rIQkC6g34qMwHmAZ2NujVohFs5DIsumh8+/sv3cP+S/cAAB5KW7T3aYBAnwYI9G6Adt5KXGnzJgKPzYAIfesQsbL+/+HXr47j3O0MPHwORX0bOUKauuKj+En4WPzYYA3/s56M90KfMHgFHE2AB946MQXvqz98/Dqa6hnoigo8l1L/FgyFCqD4OQpfCmwej+IBtw9/KH2wwvAPDA9gf7C8sHn8gyso/bO87opK4R/gX61boX87b8zddgEnbqTj3d0X8fO5JCx5vi3aPNj+45aHTA61RovtpxPxxaFrSEjPBQA0tLPG1J5NcCtnAdxPvPb442BjDW8ba3g3tEP3Zi66ecr9eujoh7beSoPHobyvCVsZ0KN5I/Ro3gjzANy+n4vv/4jHomPGa5jzXFuENHWu9PNg8HmswD7UU9phUnd/TOrujxtpOdh5Ngk7zybieloO3tKO1e2DqVnkGAsiIiJLdUdwxrlu/0OHsAmPna9D2ASc6/Y/3BVKf8Ao7/Jd/J1w3qEnXlXPRApKXwI0Bc54VT0T5x16oou/gcuDAkDrgRCGry3+FvQhgqMXhOFrgdYDK739V9QzcVzRHcOCvNHK3QEyAUjOzMeemBR8sOcSRq08joAF+zDscCO88ph1vB/fHGdvFYeKVu4OeKlXE2yY2hVn5vfDtxM6I2zo1Mceg96DXzR8WU0Un8LSe/CLktYh9bmUujyA4udq+FrA0aP0dEfP4umPeS4fXl54ZHnhkeWbudpj4/91xZLn28LB1grnb2di4Bd/YMnN5jjRZRnuPHIMU+GEMyGfobDFc9hwIgF9/huFWT+dR0J6Lpzr22BO/1Y4OrsvXu3dDMHPTqz0cTDJ6+HBcajMa8K7oR3aeTfAPm2Xx/4979N2wZ2sfL3rKNl+eZ4HU+5DY5f6eC20OSL/3QvvDw4wuA+mwDEWD/AcZKpN1Go1NBqNucugKiCXy2Ftrefb6cfg+5t0Jcfw+L7N6NR3iOFLxOqhKSrCpT/3Ie9+Iuo19EKr4LByL783JhmvrDsNGbToLLsEV2TgDhrgpLYVtJDhq7EdER7gYXxFWk3xefLZqYC9W/H524/7VrQS288pKMKFxEycu5WBc7czcDYhA0kP3YdBBi26PLSOEw/WAQAv9WyCSd394a60NVjH4p8vwCf7nG75W/aBmDewbfn230TrkPJcmmJ5AJV+Liuz/B1VPhbu+hu/XkjRTXv0eTypbQUNZHCys0F6biEAwMVegZd7NcHoYF/Y2ei/BG9ljoPJXg8VPA4louPuYdTK43qPw8N/zxumdtXfYyFx+6ZYx86ziXht41ndPnRQn8W2T+abrH1gsHiADS/VBiqVCmlpaSgoKDB3KVSFFAoFXFxcyv1exfc36cx5DPfGJGPRrthSN0vzUNpiwYDW5f8QZabt/xB9A/N2/m10G5+NbI9B7b0eO49GK+JEfDruZOXD1cEWXfydHtvLUFXrqIv2xaTglfWnjJ4642Jvg1d6N8PoLr6oZ1PBD8nlZM7Xg0Yr4smlB5GSmW9opAnclbY4Oruvxf5dPRyOAEBbkItby4Zz8DYRlaZSqZCYmAh7e3u4uLjA2tq6zt4QrbYSRRFqtRqZmZlITEwEAAaFOiA8wANPt3Y32wdiKdtv5lq+u/m6OujvqXiYXCYY/xa4GtZRFznWsy7X+fgfDw9ErxZ6brZoQuZ8PchlAhYMaI1X1p02NNIFCwa0tthQARSfUuahtDUYjqRisCCqJdLS0mBvbw9vb28GilqsXr16cHBwwO3bt5GWlsZgUUeY+wNxZbdv7ENMyTe8Rs+LJ7N67JiBh2Tkqqu4kmLmfD2EB3jgq7Edy/SauFdjL6IUj4YjU2OwIKoF1Go1CgoK4OLiwlBRBwiCAKVSicTERKjV6gqPuSCqLrXhG14qX49SRear6czdiyjVw+Eo8U6uSdfNq0IR1QIlA7X5AbPuKHmuOUifLF3Jh5hHB2a7K20rNtiWzKak58nQx2YBxeMc6lLPU0mvyaD2Xghp6lxjQkWJ8AAPHJ3dF6smdDbpetljQVSLsLei7uBzTTVJTf+Gt65jz1PtJJcJ6NLEtGGQwYKIiIiqnLnHiZA0NX1sAVUPBgsiIiIiMoo9T2QMgwUR1ToVPU3Iz88PN27cMGkNjRs3xs2bN8FbBRFRbcKeJ3ocBgsiqnUmTJhQZtrRo0cRFxeHwMBAtG/fvtRjLi4u1VQZERFR7cVgQUS1zurVq8tMmzhxIuLi4jB48GAsXLiwymuIjIyEWl0913QnIiKyBAwWRERVoGnTpuYugYiIqFrxPhZEVGEarYjouHvYeTYR0XH3oNHW3HEEq1evhiAIWLhwIa5cuYKRI0fCzc0NMpkMO3bsAABcu3YNCxcuREhICNzd3WFjYwNvb2+MHz8eV65c0bvexo0blxnrcePGDQiCgN69eyMvLw9vvvkm/Pz8oFAo0KxZMyxdupRjMoiIqMZijwURVcjemOQylxv0qAWXG7x8+TI6d+4MZ2dn9OnTB/fv39fdhO7bb7/Fhx9+iICAAHTu3BkKhQKxsbH44YcfsHPnThw5cgTt2rUr97YKCwvRr18/xMbGonfv3sjJycHhw4fx5ptvIisrC++++25V7SYREVGVYY8FEZXb3phkvLLudKlQAQApmfl4Zd1p7I1JNlNl0m3cuBHjx4/H1atXsXHjRuzbtw/PPvssAGDw4MGIi4vD+fPnsWvXLmzduhWxsbFYtWoVVCoVZs6cWaFtRUdHQy6XIz4+Hj/99BP27t2LI0eOQC6X49NPP0V2dnYV7CEREVHVYo8FUS0niiLy1BrJ69FoRSz4+W/oO1FHRPHdVxf+HIvuzVwkX9O8nrW82u8s3ahRIyxduhRyubzMY127dtW7zKRJk/Ddd98hKioKmZmZUCqV5dqWTCbD119/DUdHR920Tp06oX///vjll1/w119/oXfv3pXaDyIiInNhsCCq5fLUGrSev6/KtyMCSFHlo+3C/ZLXFftOGOxsqvftKTQ0FHZ2dgYfz87Oxq5du3D27Fmkp6frrviUnJwMURQRFxeHjh07lmtbfn5+aNmyZZnpLVq00K2TiIiopmGwICIC4Ovra/CxgwcPYuTIkbh7967BebKyssq9LW9vb73THRwcAAAFBQXlXhcREZGlYLAgquXqWcsR+06Y5PWciE/HxO9PGp1v9aTO6OLvJGlb9azLno5U1WxtbfVOz87OxvDhw5Geno758+dj5MiR8PPzQ7169SAIAkaPHo0NGzZU6GpOMhmHtxERUe3DYEFUywmCYJLTino0bwQPpS1SMvP1jrMQALgrbdGjeSPJYywsyZEjR3Dv3j0MHToUixYtKvP49evXzVAVERGR5eHXZkRULnKZgAUDWgMoDhEPK/l9wYDWtSpUAMD9+/cB6D996dq1azh9+nR1l0RERGSRGCyIqNzCAzzw1diOcFeWPm3IXWmLr8Z2rNH3sTCkZED1tm3bSo2xyMjIwOTJk3WDuImIiOo6ngpFRBUSHuCBp1u740R8Ou5k5cPVwRZd/J1qXU9FiU6dOuHpp5/GgQMH0KJFC91lYKOiouDi4oJBgwZh586d5i2SiIjIArDHgogqTC4TENLUGYPaeyGkqXOtDRUldu7cibfeeguNGjXCnj17cOrUKYwcORLHjx9HgwYNzF0eERGRRRDEilzKpBZTqVRQKpXIzMwsddMqopogPz8f8fHx8Pf3N3h1I6pdKvKc8/1NOh5DIqqNTP3exh4LIiIiIiKSjMGCiIiIiIgkY7AgIiIiIiLJGCyIiIiIiEgyBgsiIiIiIpKMwYKIiIiIiCRjsCAiIiIiIskYLIiIiIiISDIGCyIiIiIikozBgoiIiIiIJGOwICIiIiIiyRgsiIiIiIhIMgYLIiIiIiKSjMGCiIiIiIgkY7Agolpn9OjREAQBixcvNjrviRMnIAgC3NzcUFRUVKHtTJw4EYIgICoqqtT03r17QxAE3Lhxo9zrWr16NQRBwMKFCytUAxERkaVgsCCiWmfcuHEAgPXr1xudd926dQCAUaNGwcrKqkrrIiIiqs0YLIio1unXrx/c3Nxw+fJlnDx50uB8RUVF2LRpE4B/wogprF27FhcvXoSXl5fJ1klERGTpGCyIqOK0GiD+CHBha/G/Wo25KypFLpdj1KhRAP7pkdBn//79uHPnDp544gkEBQWZbPu+vr5o1aoVrK2tTbZOIiIiS8dgQUQVE/szsCwAWPMc8NPk4n+XBRRPtyBjx44FAGzatAkajf7gU3Kq1NixY5GRkYHPP/8cYWFh8PPzg0KhgLOzM8LDw3HgwIEKbftxYyz++OMPhIaGwsHBAQ0aNEBYWBj+/PPPiu0cERGRBWKwIKLyi/0Z2DweUCWVnq5KLp5uQeEiKCgITzzxBFJTU/UGg5ycHOzcuROCIGDMmDE4fvw4ZsyYgStXrqBly5YYMmQIWrZsif379yMsLAyrVq2SXNMvv/yC3r17IzIyEq1bt0b//v1x69Yt9OzZE9HR0ZLXT0REZE4cqUhU24kioM6Vvh6tBtgzC4CobyMABGDvbKBJb0Aml7YtaztAEKStA8XjJubOnYt169YhPDy81GPbtm1DTk4OevXqBT8/P2i1WkRHR6Nr166l5jtz5gz69u2L119/HcOHD4e9vX2lasnKysKLL76IoqIirFq1CpMmTQIAiKKIOXPmYOnSpZXbSSIiIgvBYEFU26lzgfc9q2FDYnFPxgc+0lc1NwmwqS95NWPGjMFbb72FHTt2ICcnB/Xr/7POkrEXJadM+fv7w9/fv8w6OnTogGnTpuG9997DoUOHMGDAgErVsnXrVty9exc9e/bUhQoAusvirl+/Hrdv367UuomIiCwBgwUR1Vq+vr7o2bMnDh8+jB07dmDMmDEAgNTUVERGRsLW1hbDhg3Tza/RaBAZGYljx44hOTkZBQUFAICrV6+W+rcyjhw5AgAYOXJkmcesra0xdOhQLFu2rNLrJyIiMjeLDRbLly/HRx99hJSUFAQGBuLzzz9Hly5dDM6/bNkyfPXVV0hISICLiwuGDh2KJUuWwNbWthqrJrJA1nbFPQBS3TwGrB9qfL4xWwG/btK2ZW0nbfmHjBs3DocPH8a6det0wWLDhg3QaDR4/vnnoVQqAQC3b9/Gc889h3PnzhlcV1ZWVqXrSEoqfg78/Pz0Pt64ceNKr7suYhtBRGR5LHLw9qZNmxAREYEFCxbg9OnTCAwMRFhYGO7cuaN3/h9//BFvvvkmFixYgIsXL+K7777Dpk2bMHfu3GqunMgCCULxaUVSf5r2BRw9ARga+yAAjl7F80ndlgnGV5QYOnQobG1t8dtvv+neQ0pOg3r43hVTpkzBuXPn8MILL+DPP/9ERkYGNBoNRFHE119/DaB4PASZH9sIIiLLZJHB4pNPPsHUqVMxadIktG7dGitWrICdnZ3Bq7IcO3YM3bt3x+jRo9G4cWP069cPo0aNwokTJ6q5cqJaTCYHwksGGD/6wf/B7+EfSB+4bWJKpRIDBw5EUVERNmzYgEuXLuHUqVNwcXHRDejOycnBgQMH4Obmhk2bNqFLly5QKpWQyYrfIq9fvy65Dg8PDwDAzZs39T5uaDqVxTaCiMgyWVywKCwsxKlTpxAaGqqbJpPJEBoaavByjN26dcOpU6d0jcT169fx66+/4plnnqmWmonqjNYDgeFrAUeP0tMdPYuntx5onrqMKBmgvX79et29K0aMGKG7gV1mZia0Wi08PDwgl5cORmq1Gtu3b5dcQ48ePQAAmzdvLvNYUVERfvrpJ8nbqAvYRhARWS6LG2ORlpYGjUYDNze3UtPd3Nxw6dIlvcuMHj0aaWlpePLJJyGKIoqKivDyyy8/tpu7oKBANzATAFQqlWl2gKi2az0QaPVs8ZiL7FTA3q14TIWF9VQ8LDw8HC4uLjh58iTi4+MBlD4NytXVFUqlEjExMfjjjz/QvXt3AMWDuWfPno0rV65IrmHYsGGYNWsWoqKisGbNGkyYMAFA8elVCxYsQEJCguRt1AVsI4iILJfF9VhURlRUFN5//318+eWXOH36NLZt24bdu3dj8eLFBpdZsmQJlEql7sfHxwSXyCSqK2RywL8H0HZo8b8WHCqA4qsulVyNKS0tDc2bN0dwcLDucSsrK8yaNQtFRUXo1asX+vXrh5EjR6JZs2ZYsWIFpk2bJrkGBwcHfPfdd5DL5Zg4cSK6du2K0aNHIyAgAB999BGmTp0qeRukH9sIIqLqYXHBwsXFBXK5HKmpqaWmp6amwt3dXe8y8+bNw7hx4zBlyhS0bdsWQ4YMwfvvv48lS5ZAq9XqXWbOnDnIzMzU/dy6dcvk+0JEluPhHoqSU6MeNnfuXKxZswbt2rXDH3/8gd9++w2BgYE4fvw4OnXqZJIaBg0ahEOHDqFPnz6IiYnB7t274eHhgcOHD6NbN4lX0qoj2EYQEVkuizsVysbGBkFBQYiMjMTgwYMBAFqtFpGRkZg+fbreZXJzc3WDLEuUnCdt6CouCoUCCoXCdIUTkUXr0qWL0as6jR8/HuPHjy8zvV27dpg4cWKZ6atXr8bq1avLTI+KijK4jR49euDgwYNlpoeEhOjdBpXGNoKIyHJZXLAAgIiICEyYMAGdOnVCly5dsGzZMuTk5OjuVjt+/Hh4eXlhyZIlAIABAwbgk08+QYcOHRAcHIxr165h3rx5GDBgQJmBmEREVLOxjSAiskwWGSxGjBiBu3fvYv78+UhJSUH79u2xd+9e3WC9hISEUt8+vf322xAEAW+//TYSExPRqFEjDBgwAO+99565doGIiKoI2wgiIsskiLzjE4DiK34olUpkZmbC0dHR3OUQVUh+fj7i4+Ph7+/POwnXERV5zvn+Jh2PIRHVRqZ+b7O4wdtERERERFTzMFgQEREREZFkDBZERERERCQZgwUREREREUnGYEFUi/BaDHUHn2siIrI0DBZEtUDJtfjVarWZK6HqUvJc8z4MRERkKRgsiGoBa2trKBQKZGZm8pvsOkAURWRmZkKhUMDa2trc5RAREQGw0BvkEVHFubi4IDExEbdv34ZSqYS1tTUEQTB3WWRCoihCrVYjMzMT2dnZ8PLyMndJREREOgwWRLVEyY1t0tLSkJiYaOZqqCopFAp4eXnxRm1ERGRRGCyIahFHR0c4OjpCrVZDo9GYuxyqAnK5nKc/ERGRRWKwIKqFrK2t+eGTiIiIqhUHbxMRERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZAwWREREREQkGYMFERERERFJxmBBRERERESSMVgQEREREZFkDBZERERERCQZgwUREREREUnGYEFERERERJIxWBARERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZAwWREREREQkGYMFERERERFJxmBBRERERESSMVgQEREREZFkDBZERERERCQZgwUREREREUnGYEFERERERJIxWBARERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZAwWREREREQkGYMFERERERFJxmBBRERERESSMVgQEZFJrVmzBvn5+eYug4iIqhmDBRERmdSkSZPg6emJf/3rXzh37py5yyEiomrCYEFERCY1ZcoUFBUVYfny5ejYsSO6du2K7777Djk5OeYujYiIqhCDBRERmdQ333yD5ORkfPPNN+jcuTNOnDiB//u//4Onpydefvll/PXXX+YukYiIqgCDBRERmVz9+vUxZcoUHD9+HOfPn8e0adNgZWWFb775BsHBwejQoQNWrFgBlUpl7lKJiMhEGCyIiKhKBQQE4H//+x+SkpKwbt069OzZE+fOncO0adPg6emJyZMn49SpU+Yuk4iIJGKwICKiaqFWq5GVlYWsrCwAgCiKUKvV+P7779GlSxcMHToUGRkZ5i2SiIgqjcGCiIiq1PHjxzF58mR4eHjg1Vdfxfnz5/H8889j//79UKlUWL9+Pdq2bYvt27djxowZ5i6XiIgqycrcBRARUe1z//59/PDDD1i5ciViY2MhiiJ8fHwwe/ZsTJkyBe7u7rp5R40ahWHDhqFDhw749ddfzVg1ERFJYbE9FsuXL0fjxo1ha2uL4OBgnDhx4rHzZ2RkYNq0afDw8IBCoUCLFi3YQBERmcHYsWPh5eWF119/HRcvXkT//v3x888/Iz4+Hm+//XapUFHCysoKnTt3xv3798u1DbYRRESWxyJ7LDZt2oSIiAisWLECwcHBWLZsGcLCwnD58mW4urqWmb+wsBBPP/00XF1dsXXrVnh5eeHmzZto0KBB9RdPRFTH/fjjj3B3d8eLL76I//u//4Ovr2+5lhsyZAj8/PyMzsc2gojIMgmiKIrmLuJRwcHB6Ny5M7744gsAgFarhY+PD/71r3/hzTffLDP/ihUr8NFHH+HSpUuwtrau1DZVKhWUSiUyMzPh6OgoqX4iIktS3e9vP/30EwYNGgQrq6r57optBBGRaZj6vc3iToUqLCzEqVOnEBoaqpsmk8kQGhqK6Ohovcv8/PPPCAkJwbRp0+Dm5oaAgAC8//770Gg01VU2ERE98MILL1RZqGAbQURkuSwuWKSlpUGj0cDNza3UdDc3N6SkpOhd5vr169i6dSs0Gg1+/fVXzJs3Dx9//DHeffddg9spKCiASqUq9UNERNKdPn0aEREROHnypMF5Tpw4gYiICJw9e7ZC62YbQURkuSwuWFSGVquFq6srvvnmGwQFBWHEiBF46623sGLFCoPLLFmyBEqlUvfj4+NTjRUTEdVeX3zxBb788ks0btzY4Dz+/v748ssvsXz58iqvh20EEVH1sLhg4eLiArlcjtTU1FLTU1NT9V5JBAA8PDzQokULyOVy3bQnnngCKSkpKCws1LvMnDlzkJmZqfu5deuW6XaCiKgOO3LkCDp27IhGjRoZnKdRo0bo2LEjDh8+XKF1s40gIrJcFhcsbGxsEBQUhMjISN00rVaLyMhIhISE6F2me/fuuHbtGrRarW7alStX4OHhARsbG73LKBQKODo6lvohIiLpEhMTH9tbUcLPzw9JSUkVWjfbCCIiy2VxwQIAIiIisHLlSqxZswYXL17EK6+8gpycHEyaNAkAMH78eMyZM0c3/yuvvIL09HS89tpruHLlCnbv3o33338f06ZNM9cuEBHVWQqFAhkZGUbnU6lUpXoRyottBBGRZbLI+1iMGDECd+/exfz585GSkoL27dtj7969usF6CQkJkMn+yUQ+Pj7Yt28fXn/9dbRr1w5eXl547bXXMHv2bHPtAhFRndWmTRscPXoU6enpcHJy0jtPeno6fv/9dwQEBFR4/WwjiIgsk0Xex8IceI1yIqqtqvv9bcWKFXj11VfRu3dvrF27Ft7e3qUeT0xMxIQJE3Do0CF89tlnmD59epXXJBXbCCKqjUz93maRPRZERFRzTZkyBRs2bEBUVBRatGiB8PBwNG3aFAAQFxeHffv2IS8vD927d8fLL79s5mqJiMhUGCyIiMikrKyssGfPHsyYMQNr1qzBjh07Sj0ul8sxadIkfPbZZ1V2Iz0iIqp+fEcnIiKTs7Ozw7fffovFixcjKipKd7lWHx8f9O7dGx4eHmaukIiITI3BgoiIqoyHhwdGjRpl7jKIiKgaWOTlZomIiIiIqGZhjwUREVWJ3NxcHDp0CFevXkVWVhb0XYRQEATMmzfPDNUREZGpSQoWubm5SEtLg7OzM+rXr6+bfv/+fSxduhQxMTHw9fXFv//9b90VQYiIqPZbvXo1Xn/9dahUKt00URQhCEKZ3xksiIhqB0nBYvHixfjwww9x4sQJBAUFAQAKCgrQtWtXXLt2Tfft1NatW3Hu3DkO1iMiqgN+++03TJ48GUqlEnPnzsWhQ4cQHR2Nr7/+GnFxcdi+fTuuXr2K6dOn69oOIiKq+SSNsTh48CCaNm1aqmFYt24drl69ij59+mDfvn2YMWMG0tLS8Omnn0ouloiILN/HH38MQRBw6NAhLF68GM2bNwcATJ06FR988AH+/vtvzJw5E6tWrWKwICKqRSQFi4SEBF2DUeLnn3+GIAj4/vvv8fTTT2PZsmVo0aIF9uzZI6lQIiKqGU6ePImuXbsiMDBQ7+NWVlb473//C1dXVyxYsKCaqyMioqoiKVjcv38fDRo00P0uiiKOHj2Kdu3awcfHRzc9MDBQdw1zIiKq3bKzs+Hr66v7XaFQAACysrJ002QyGYKDg3HkyJFqr4+IiKqGpGDh7u6O+Ph43e+nTp3C/fv30atXr1LzPTxYj4iIajd3d3ekp6frfi8ZX3flypVS86WnpyMvL69aayMioqojKVi0b98eJ06cwI4dO5CVlYXFixdDEAQ899xzpea7evUqPD09JRVKREQ1Q6tWrXD16lXd7926dYMoivjwww91F/U4duwYDh48iJYtW5qrTCIiMjFJwWLWrFkAgBdeeAENGjTArl27EBgYiL59++rmSU1Nxblz5zhAj4iojnj22WcRHx+PEydOAACeeuoptGvXDlu3boWXlxeCgoLQp08faLVazJw507zFEhGRyUgKFt26dcP27dvx5JNPolWrVhg7dix+/vlnyGT/rHbDhg1wcHBAeHi45GKJiMjyjR8/Hnv27IGbmxuA4vEUu3fvxtNPP407d+7gzJkzsLOzw7vvvouxY8eauVoiIjIVQdR3K9Q6SKVSQalUIjMzE46OjuYuh4jIZCzp/S03NxeZmZlwdXWFXC43ay0VYUnHkIjIVEz93ibpBnlERESPioiIQMOGDfXeUdvOzg52dnZmqIqIiKqapFOhUlNT8fvvvyM1NbXU9Li4OIwcORIBAQF45plnEB0dLalIIiKqOb744gucP3/e3GUQEVE1kxQsPvjgA/Tp0weZmZm6aSqVCk8++SS2bNmC2NhY7N27F6GhoaWuEEJERLWXt7c3tFqtucsgIqJqJilYREVFoXXr1mjRooVu2urVq5GamopRo0bh8uXL+OSTT5CXl4ePP/5YcrFERGT5Bg8ejMOHD5e6IR4REdV+koJFYmIimjRpUmra7t27YWVlhWXLlqF58+aYOXMmAgMDcfjwYUmFEhFRzbBo0SL4+vrimWeewZkzZ8xdDhERVRNJg7ezsrJKDcLTaDSIjo5GUFAQXFxcdNNbtWqFX375RcqmiIiohhg0aBAUCgX++OMPdOrUCR4eHvD19YWtrW2ZeQVBQGRkpBmqJCIiU5MULDw9PXHp0iXd70ePHkV2djZ69+5dar6ioiLY2NhI2RQREdUQUVFRuv+LooikpCQkJSXpnVcQhGqqioiIqpqkYBESEoINGzZg2bJleOqpp/D2229DEAQMGDCg1HwXL16El5eXpEKJiKhmiI+PN3cJRERkBpKCxZw5c7Bt2zb8+9//BlD8zVSfPn3QrVs33Tw3btxAbGwsJk+eLK1SIiKqEfz8/MxdAhERmYGkYNGmTRscPXoUn332GdLS0hAUFIQ33nij1Dz79u1DYGAgBg8eLGVTRERERERkwQRRFEVzF2EJTH1LcyIiS1Hd728JCQkVmt/X17eKKjEdthFEVBuZ+r1NUo8FERHRoxo3blzuQdmCIKCoqKiKKyIioupgkmCRmpqKVatW4ciRI0hMTAQAeHl5oWfPnpg0aRLc3NxMsRkiIqoBevbsqTdYaLVa3Lp1CwkJCdBqtQgJCeEVA4mIahHJp0L99NNPePHFF5GdnY1HVyUIAhwcHPDdd9/hhRdekFRoVWM3NxHVVpb2/nblyhVMmTIFoijiwIEDeu9vYWks7RgSEZmCqd/bJN15+6+//sKoUaOQk5ODIUOGYPv27Thz5gzOnj2LHTt24Pnnn0d2djZGjx6Nv/76S3KxRERU87Vo0QLbtm1DbGwsFixYYO5yiIjIRCQFiyVLlkCj0WDLli3YunUrBg0ahMDAQLRr1w4DBw7Eli1bsGXLFqjVanzwwQemqpmIiGo4FxcXBAcHY+PGjeYuhYiITERSsDh69Ci6deuGIUOGGJxnyJAh6N69O44cOSJlU0REVMuIoojU1FRzl0FERCYiKVhkZmaW6zKBvr6+yMzMlLIpIiKqRc6cOYPDhw/zZnpERLWIpKtCubu748yZM0bnO3v2LNzd3aVsioiIaoh33nnH4GPZ2dm4cuUK9uzZg6KiIrz00kvVWBkREVUlScEiLCwM3377LebOnYvFixdDLpeXelwURcybNw+XLl3C1KlTJRVKREQ1w8KFCyEIQpkrBT7Mzs4Oc+bMQURERDVWRkREVUnS5WZv376NDh06ID09Hb6+vhg+fDgaN24MALh58ya2bNmCGzduwNnZGadPn4a3t7ep6jY5XkqQiGqr6n5/W7NmjcHHbGxs4OHhgc6dO6N+/fpVXoupsI0gotrI1O9tku9jceHCBYwZMwYxMTHFK3xwU6SS1bZt2xbr169HQECAxFKrFhsNIqqt+P4mHY8hEdVGpn5vk3zn7bZt2+L8+fOIiorCkSNHkJSUBADw9PREjx490Lt3b6mbICIiIiIiCyc5WJTo3bu3wRCxatUq3L59G/PnzzfV5oiIyEKdPn0a69atw6hRo9C5c2e985w4cQIbN27E+PHj0b59++otkIiIqoSky82W18qVK7Fo0aLq2BQREZnZF198gS+//FI35k4ff39/fPnll1i+fHn1FUZERFWqWoIFERHVHUeOHEHHjh3RqFEjg/M0atQIHTt2xOHDh6uxMiIiqkoMFkREZFKJiYmP7a0o4efnpxuXR0RENR+DBRERmZRCoUBGRobR+VQqVZn7HxERUc3FYEFERCbVpk0bHD16FOnp6QbnSU9Px++//47WrVtXY2VERFSVGCyIiMikxo4di+zsbAwdOhS3b98u83hiYiKGDx+O3NxcjBkzxgwVEhFRVTDZ5WaJiIgAYMqUKdiwYQOioqLQokULhIeHo2nTpgCAuLg47Nu3D3l5eejevTtefvllM1dLRESmUqFgwXNhiYjIGCsrK+zZswczZszAmjVrsGPHjlKPy+VyTJo0CZ999hmsrPj9FhFRbVGhd3RRFCu9IUEQKr0sERHVLHZ2dvj222+xePFiREVF4datWwAAHx8f9O7dGx4eHmaukIiITK1CwUKr1VZVHUREVAt5eHhg1KhR5i6DiIiqAQdvExGRSWm1WqhUKqjVaoPzqNVqqFQqfmFFRFSLMFgQEZFJffrpp2jYsOFj76p9+PBhNGzYEJ9//nk1VkZERFXJooPF8uXL0bhxY9ja2iI4OBgnTpwo13IbN26EIAgYPHhw1RZIRERlbN++HT4+PggNDTU4T2hoKLy9vfHTTz9VahtsH4iILI/FBotNmzYhIiICCxYswOnTpxEYGIiwsDDcuXPnscvduHED//nPf9CjR49qqpSIiB529epVtGnTxuh8AQEBuHr1aoXXz/aBiMgyWWyw+OSTTzB16lRMmjQJrVu3xooVK2BnZ4dVq1YZXEaj0WDMmDFYtGgRmjRpUo3VEhFRiczMTCiVSqPzKZVK3L9/v8LrZ/tARGSZLDJYFBYW4tSpU6W60WUyGUJDQxEdHW1wuXfeeQeurq6YPHlydZRJRER6eHh44Pz580bnO3/+PFxdXSu0brYPRESWyyKDRVpaGjQaDdzc3EpNd3NzQ0pKit5ljh49iu+++w4rV64s1zYKCgqgUqlK/RARkXR9+/bFxYsXsWnTJoPzbN68GbGxsejTp0+F1l0d7QPANoKIqDIsMlhUVFZWFsaNG4eVK1fCxcWlXMssWbIESqVS9+Pj41PFVRIR1Q1vvPEGbGxsMH78eEyfPh3nz59HTk4OcnJycP78eUyfPh3jxo2DjY0N3njjjSqtpTLtA8A2goioMgRRyu20q0hhYSHs7OywdevWUlfumDBhAjIyMrBz585S8589exYdOnSAXC7XTSu5NrpMJsPly5fRtGnTUssUFBSgoKBA97tKpYKPjw8yMzPh6OhYBXtFRGQeKpUKSqWyWt/ftmzZggkTJpR6ny0hiiJsbW3x/fffY8SIERVab3W0DwDbCCKqG0zdPlhkj4WNjQ2CgoIQGRmpm6bVahEZGYmQkJAy87dq1QoXLlzA2bNndT8DBw5Enz59cPbsWb3fNCkUCjg6Opb6ISIi0xg2bBjOnz+Pl156Cc2aNYNCoYBCoUCzZs3wyiuv4Ny5cxgxYkSFb5BXHe0DwDaCiKgyrMxdgCERERGYMGECOnXqhC5dumDZsmXIycnBpEmTAADjx4+Hl5cXlixZAltbWwQEBJRavkGDBgBQZjoREVWPZs2a4csvv9T72JkzZxAREYGNGzciKSmpQutl+0BEZJksNliMGDECd+/exfz585GSkoL27dtj7969ugF7CQkJkMksssOFiIj0uHXrFtavX49169bh4sWLEEURgiBUeD1sH4iILJNFjrEwB3Ocg0xEVB3M+f6WlZWFLVu2YN26dfj9998hiiJEUYSXlxdGjBiBUaNGISgoqFprqgy2EURUG5n6vc1ieyyIiKhm0mg02Lt3L3744Qfs2rUL+fn5KPkOSxAEREVFoUePHpXqrSAiIsvFvmIiIjKJkydPYsaMGfD09MTAgQOxefNmFBUVYeDAgdiyZQs6d+4MAOjZsydDBRFRLcQeCyIikuTdd9/F+vXrceXKFV3PRLdu3TB27FgMHz4cTk5OAIBly5aZsUoiIqpqDBZERCTJ/PnzIQgC3N3d8eqrr2LMmDFo3LixucsiIqJqxlOhiIhIMlEUkZKSgn379uHAgQPIyMgwd0lERFTNGCyIiEiSP//8E9OmTYOzszOOHj2Kl19+GR4eHnjhhRewbds2qNVqc5dIRETVgMGCiIgk6dy5Mz7//HMkJSVh586dGDp0KARBwPbt2zFs2DB4eHjgpZdeQmpqqrlLJSKiKsRgQUREJmFlZYUBAwZg06ZNSElJwcqVK9GjRw/cv38fK1euRFxcHADgzTffxNmzZ81bLBERmRyDBRERmZyjoyMmT56MqKgo3LhxA++99x5atWoFURTx0UcfISgoCE888QQWL15s7lKJiMhEeOftB3hXVSKqrSzp/e306dP44YcfsHHjRqSmpkIQBGg0GrPWVB6WdAyJiEzF1O9t7LEgIqJq07FjR3z66adITEzE7t27MXLkSHOXREREJsL7WBARUbWTyWTo378/+vfvb+5SiIjIRNhjQUREREREkjFYEBERERGRZAwWREREREQkGYMFERERERFJxmBBRERERESSMVgQEREREZFkDBZERERERCQZgwUREREREUnGYEFERERERJIxWBARERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZAwWREREREQkGYMFERERERFJxmBBRERERESSMVgQEREREZFkDBZERERERCQZgwUREREREUnGYEFERERERJIxWBARERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZAwWREREREQkGYMFERERERFJxmBBRERERESSWZm7ACIiotpKrVZDo9GYuwyqAjKZDNbW1hAEwdylEFkMBgsiIiITU6lUSEtLQ0FBgblLoSokl8thZ2cHV1dX2NjYmLscIrNjsCAiIjIhlUqFxMRE2Nvbw8XFhd9q10KiKEKj0SAvLw+ZmZm4ceMGvL29YWdnZ+7SiMyKwYKIiMiE0tLSYG9vD29vbwaKWs7e3h5OTk64efMm0tLS4Ovra+6SiMyKg7eJiIhMRK1Wo6CgAEqlkqGijpDL5XByckJOTg6KiorMXQ6RWTFYEBERmUjJQG1ra2szV0LVSaFQAACDBdV5DBZEREQmxt6KuoXPN1ExBgsiIiIiIpKMwYKIiIiIiCRjsCAiIiIiIskYLIiIiKhKCIJQoZ/GjRubvIbGjRtzDARRNbHo+1gsX74cH330EVJSUhAYGIjPP/8cXbp00TvvypUrsXbtWsTExAAAgoKC8P777xucn4iIai62DzXDhAkTykw7evQo4uLiEBgYiPbt25d6zMXFpZoqI6KqYLHBYtOmTYiIiMCKFSsQHByMZcuWISwsDJcvX4arq2uZ+aOiojBq1Ch069YNtra2WLp0Kfr164e///4bXl5eZtgDIiKqCmwfao7Vq1eXmTZx4kTExcVh8ODBWLhwYZXXEBkZCbVaXeXbISILPhXqk08+wdSpUzFp0iS0bt0aK1asgJ2dHVatWqV3/vXr1+PVV19F+/bt0apVK3z77bfQarWIjIys5sqJiKgqsX34h0YrIjruHnaeTUR03D1otKK5S7I4TZs2RatWrcxdBlGdYJHBorCwEKdOnUJoaKhumkwmQ2hoKKKjo8u1jtzcXKjVajg5OVVVmUREVM3YPvxjb0wynlx6EKNWHsdrG89i1MrjeHLpQeyNSTZ3aZWyevVqCIKAhQsX4sqVKxg5ciTc3Nwgk8mwY8cOAMC1a9ewcOFChISEwN3dHTY2NvD29sb48eNx5coVvevVN8bixo0bEAQBvXv3Rl5eHt588034+flBoVCgWbNmWLp0KUSRIY2ooizyVKi0tDRoNBq4ubmVmu7m5oZLly6Vax2zZ8+Gp6dnqcbnYQUFBSgoKND9rlKpKl8wERFVi+poHwDLbyP2xiTjlXWn8ehH35TMfLyy7jS+GtsR4QEeZqlNqsuXL6Nz585wdnZGnz59cP/+fd2dzL/99lt8+OGHCAgIQOfOnaFQKBAbG4sffvgBO3fuxJEjR9CuXbtyb6uwsBD9+vVDbGwsevfujZycHBw+fBhvvvkmsrKy8O6771bVbhLVShYZLKT64IMPsHHjRkRFRcHW1lbvPEuWLMGiRYuquTIiIjKn8rQPQNW1EaIoIk+tkbQOjVbEgp//LhMqAEAEIABY+HMsujdzgVwm7WpI9azl1X5FpY0bN2L69OlYtmwZ5HJ5qccGDx6Ml156Cf7+/qWmf//993jxxRcxc+ZMHDx4sNzbio6ORq9evRAfHw9HR0cAwF9//YWuXbvi008/xZtvvgl7e3vpO0VUR1hksHBxcYFcLkdqamqp6ampqXB3d3/ssv/973/xwQcf4LfffnvstxZz5sxBRESE7neVSgUfHx9phRMRUZWqjvYBqLo2Ik+tQev5+ySv53FEACmqfLRduF/yumLfCYOdTfV+VGjUqBGWLl1aJlQAQNeuXfUuM2nSJHz33XeIiopCZmYmlEplubYlk8nw9ddf60IFAHTq1An9+/fHL7/8gr/++gu9e/eu1H4Q1UUWGSxsbGwQFBSEyMhIDB48GAB0A+2mT59ucLkPP/wQ7733Hvbt24dOnTo9dhsKhQIKhcKUZRMRURWrjvYBYBthTqGhobCzszP4eHZ2Nnbt2oWzZ88iPT1dd8Wn5ORkiKKIuLg4dOzYsVzb8vPzQ8uWLctMb9GihW6dRFR+FhksACAiIgITJkxAp06d0KVLFyxbtgw5OTmYNGkSAGD8+PHw8vLCkiVLAABLly7F/Pnz8eOPP6Jx48ZISUkBANjb27Mbk4ioFqnJ7UM9azli3wmTtI4T8emY+P1Jo/OtntQZXfylDVCvZ12216Cq+fr6Gnzs4MGDGDlyJO7evWtwnqysrHJvy9vbW+90BwcHACg1zoaIjLPYYDFixAjcvXsX8+fPR0pKCtq3b4+9e/fqBuwlJCRAJvvnolZfffUVCgsLMXTo0FLrWbBgQbVcJ5uIiKpHTW4fBEGQfGpRj+aN4KG0RUpmvt5xFgIAd6UtejRvJHmMhTkYGvuSnZ2N4cOHIz09HfPnz8fIkSPh5+eHevXqQRAEjB49Ghs2bKjQ1Zwe/jshIuksNlgAwPTp0w12bUdFRZX6/caNG1VfEBERWYS63D7IZQIWDGiNV9adhgCUChclMWLBgNY1MlQ8zpEjR3Dv3j0MHTpU78D669evm6EqInoYozoREVENEx7gga/GdoS7svS3++5K2xp9qdnHuX//PgD9py9du3YNp0+fru6SiOgRFt1jQURERPqFB3jg6dbuOBGfjjtZ+XB1sEUXf6da11NRomRA9bZt2zB37lw0atQIAJCRkYHJkyfrBnETkfkwWBAREdVQcpmAkKbO5i6jWnTq1AlPP/00Dhw4gBYtWuguAxsVFQUXFxcMGjQIO3fuNG+RRHUcT4UiIiKiGmHnzp1466230KhRI+zZswenTp3CyJEjcfz4cTRo0MDc5RHVeYJYkcsn1GIqlQpKpRKZmZmlbpRDRFTT8f1NuvIew/z8fMTHx8Pf3/+xd/am2oXPO9VUpm4f2GNBRERERESSMVgQEREREZFkDBZERERERCQZgwUREREREUnGYEFERERERJIxWBARERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZAwWREREREQkGYMFERERERFJxmBBRERERESSMVgQERFRlRg9ejQEQcDixYuNznvixAkIggA3NzcUFRVVaDsTJ06EIAiIiooqNb13794QBAE3btwo97pWr14NQRCwcOHCCtVARAwWREREVEXGjRsHAFi/fr3RedetWwcAGDVqFKysrKq0LiKqGgwWREREVCX69esHNzc3XL58GSdPnjQ4X1FRETZt2gTgnzBiCmvXrsXFixfh5eVlsnUSkWEMFkRERFQl5HI5Ro0aBeCfHgl99u/fjzt37uCJJ55AUFCQybbv6+uLVq1awdra2mTrJCLDGCyIiIhqKq0GiD8CXNha/K9WY+6Kyhg7diwAYNOmTdBo9NdXcqrU2LFjkZGRgc8//xxhYWHw8/ODQqGAs7MzwsPDceDAgQpt+3FjLP744w+EhobCwcEBDRo0QFhYGP7888+K7RwRlcJgQUREVBPF/gwsCwDWPAf8NLn432UBxdMtSFBQEJ544gmkpqbqDQY5OTnYuXMnBEHAmDFjcPz4ccyYMQNXrlxBy5YtMWTIELRs2RL79+9HWFgYVq1aJbmmX375Bb1790ZkZCRat26N/v3749atW+jZsyeio6Mlr5+ormKwICIiqmlifwY2jwdUSaWnq5KLp1tYuCgZN6HvdKht27YhJycHPXv2hJ+fH1q2bIno6GjEx8dj//792LhxI44dO4ZTp05BqVTi9ddfR3Z2dqVrycrKwosvvoiioiKsWrUKf/75JzZs2IC///4br7/+Or755ptKr5uormOwICIiqi6iCBTmSPvJVwF7ZgEQ9W2g+J+9s4vnk7otUd82Km7MmDEQBAE7duxATk5OqcdKwkbJKVP+/v7o2rVrmXV06NAB06ZNg0qlwqFDhypdy9atW3H37l307NkTkyZN0k0vuSyut7d3pddNVNfxem5ERETVRZ0LvO9ZxRsRi3syPvCRvqq5SYBNfcmr8fX1Rc+ePXH48GHs2LEDY8aMAQCkpqYiMjIStra2GDZsmG5+jUaDyMhIHDt2DMnJySgoKAAAXL16tdS/lXHkyBEAwMiRI8s8Zm1tjaFDh2LZsmWVXj9RXcZgQURERFVu3LhxOHz4MNatW6cLFhs2bIBGo8Hzzz8PpVIJALh9+zaee+45nDt3zuC6srKyKl1HUlLx6WN+fn56H2/cuHGl101U1zFYEBERVRdru+JeACluHgPWDzU+35itgF83aduytpO2/EOGDh2K6dOn47fffsOdO3fg6uqqOw3q4XtXTJkyBefOncMLL7yAWbNmoWXLlnBwcIBMJsM333yDl156CaKJTtEiItNisCCT0WhFnIhPx52sfLg62KKLvxPkMsHcZRERWQ5BkH5qUdO+gKNn8UBtveMshOLHm/YFZHJp2zIhpVKJgQMHYvPmzdiwYQPCwsJw6tQpuLi4IDw8HEDxFaIOHDgANzc3bNq0CXJ56fqvX78uuQ4PDw8AwM2bN/U+bmg6ERnHwdtkEntjkvHk0oMYtfI4Xtt4FqNWHseTSw9ib0yyuUsjIqpdZHIgfOmDXx798ubB7+EfWFSoKFEyQHv9+vW6e1eMGDFCdwO7zMxMaLVaeHh4lAkVarUa27dvl1xDjx49AACbN28u81hRURF++uknydsgqqsYLEiyvTHJeGXdaSRn5peanpKZj1fWnWa4ICIytdYDgeFrAUeP0tMdPYuntx5onrqMCA8Ph4uLC06ePIkVK1YAKH0alKurK5RKJWJiYvDHH3/opms0GsyePRtXrlyRXMOwYcPg7OyMqKgorFmzRjddFEUsWLAACQkJkrdBVFcxWNQSGq2I6Lh72Hk2EdFx96DRVs/5pxqtiEW7Yh930UMs2hVbbfUQEdUZrQcCM2OACb8AL3xX/O/MCxYbKoDiqy6VXI0pLS0NzZs3R3BwsO5xKysrzJo1C0VFRejVqxf69euHkSNHolmzZlixYgWmTZsmuQYHBwd89913kMvlmDhxIrp27YrRo0cjICAAH330EaZOnSp5G0R1FYNFLWDO05BOxKeX6al4mAggOTMfJ+LTq7wWMh1zBVUiqiCZHPDvAbQdWvyvBZ7+9KiHeyhKTo162Ny5c7FmzRq0a9cOf/zxB3777TcEBgbi+PHj6NSpk0lqGDRoEA4dOoQ+ffogJiYGu3fvhoeHBw4fPoxu3SQOeCeqwwSRl1YAAKhUKiiVShw4E48+7fwqPOjYXAOXS05DevRJLNnyV2M7IjzA49HFTCK7oAhL91zED8eNdxt/NrI9BrX3qpI6yLT2xiRj0a7YUoHRQ2mLBQNaV9nfElWtkve3zMxMODo6mrucGqm8xzA/Px/x8fHw9/eHra1tNVZI5sTnnWoqU7cPvCrUI15ccxJernEV+hBlig9ilQkmxk5DElB8GtLTrd3LFXLKU0NBkQaHL9/FznNJiLyYiny1tlz7p+U33jWCoaBaMl6mKoMqERER1WwMFnpU5EOUKT6IVTSYpOcU4nJKFvbHppTrNKT/RV7FoPaeaOxcHzIDAeNxNTzd2h1/Xr+HnWeTsCcmGar8It08jZ3tkJZdiOyCIn2r1Xlj6znEJqswvW9zKOtZP3ZeMg9TB1VT1MPLFxMREdUcDBaP6Cy7hDNoDy1kmL/zb7T3aQgHWyvUs5aX+VBuig9ixoLJv/u1QMP6Nriamo0rqVm4kpqFtOzCCu3TZ5FX8VnkVdjZyNHS3QFPeDjiCQ9HtPZwRCt3Bxy5eldvDcmZ+Xh53Wk42lqVChNujgoMaOeJge090dZLiX1/p+CVdad1+11CePB7G09H/J2kwsoj8fjpdCIinm6BkZ19YCU3/RAffhitvIqMlwlp6lyltfB0LNPRaEWcuM4xTkREVPU4xuIB3Tlmbzog28YZi9TjsU/bpdQ8CisZ7GzksLOxgq21DFoRiE/LMbru8AA3eDWwg0wAZDIBMkGAXCj+2L362E1kFxRBBi26yC7BFRm4gwY4oW0F7WPG1vs62cHF3ganEzKMbr+pS33czshDQZH+05bkMsHo4FxHWys8284DAwO99H5YN/ZB8NDlO3j3l1jE3S0+Xi3dHPD2c0+gR/NGpdYjJRhYyofRmhZucguLcCA2FSt/v46YJJXR+at6vIw5xw09qqY9l48qeU0k3knHrWXDOcZCAo6xoMfh8041FcdYVAN3pOMr62V4RT2zVLgoKNKioEiL+7nqMss8LhjsjUl97PbCZCewwHotPIV/vlVMEp104SbQW4ngJs5o7mqPlu4OaOZqDzsbK2i0Ip5cehApmfkQ9GxfhAzuSlvsj+gFURRx414OYpOzEJukwsXk4p87WQXluuLP8tEd0aNFI4OPhwd44OnW7gY/hPVp6Yonm7ngxz8T8OlvV3A5NQvjvjuB0CdcMfeZJ9CkkT32xiRj8c8X4JN9Trcft+wDMW9g22o5JQ2Q/kGypoSbwiItfr9yFz+fS8KB2FTkqTXlXveF25l4tq1HlfU4WcrpWJbyXFaWodcEERFRVWGPxQMP91g4KgRoRSAFzrgxJhrtGzsjt1CDvEIN8tQa5BZqkFtYhLMJ9/HhvitGg8GgQE94NKgHURSh0YrQioBWFBF3Nxt2cb/iK+tlAICHPyeVfNZ/RT0Tzwz/P4PfEO+NScaOH1dgvp7tv6Mej8GjX37sh6B1x2/i7R0xxdt/TDgq17fUWg1w8xiQnQrYuwF+3fRe+jAjtxCfRV7FD9E3UaQVYSUT0KtFI1hf+aVS+1ESsAydxiMAcFfa4ujsvo/9MCr1g6TJvmkv53Gs6H7Me7Y1Gta3wc/nEvHrhRRk5v0TkH2d7PBcOw9s/usW7mUXGv0w2sSlPv4T1hL9A9whCKb7gB8ddw+jVh43Ot+GqV2Nno4ltffLUnpNKuPR14S2IJc9FhKxx4Ieh8871VTssagmMgHwxD24X/4AMnUv2Cl9AKU30KARICv+sB3s74yEPzbjffWyMsuX9HrMtZ6F90Y8o/cDTfTVO/BLWKvb3qPb14rAAusfcLO+4RsChctOIszmM4iPfARyF9Lxlc1nEGRBAAzfLKlpI3sAxntNXB2MvFHG/gzsnQ2okv6Z5ugJhC8tc7OmBnY2WDCgDcYE++H9Xy/i4KU7sLryC758ELBK7QfS8aX1MszdYYMu/m8gK1+N9JxCZOQW/3s/txAxiZm6D1CGwlFyZj4+3HsJwU2c4FxfARcHBZzr28DWuvgDe8kHSQFadH1o+ZOZrcrV4/HwN+36ahAhK9837RU4jvoY2o8Tma3w6o+nS83byEGB59p5YFB7LwR6KyEIAtp5K/HKutOQQ4vODx+HB8dxaJA3Ii/dwfW0HLy6/jTaeSsxO7wVujdzKV1IJcLRnax8bDtz2+g+AsCuc4nwalAPPk719AYbKSHRknpNNEVFuPTnPuTdT0S9hl5oFRwGuZXxt21j42WIiIiqAnssHni0x8IguQJQehWHDEcvqP/+GVbqHOj70lYrAmpbJyie/wrQFgGaAqCoUPev9s5FyE6tMlqbtvvrkHl1AKztAOt6gFW94n/lNsDqZ4HsFANLCsUfSmdeMPihTqMV8db77+N99YcA9PeazLWehffmzjX8ISr2Z2DzeMDQ97vD1z72Q/HXUVcw4FAY3JFeJmCV1JECZzxZ8Nljx50YC0f6OCis4Gxvg8SMPPQV/zS4/DGbbni5V1MAeNDrJEKrFaERRWi0QOL9XOw6n2y0hsd+0/7gOIoQ8fBhECEU/27kOJZ8S90u63eDNezXdsGwTt4Y3N4LwU2c9T6nZ/atgWf0Irjhnm5aKpyRFLIAHcImILugCCt/v46VR64jt7D4FKoezV0wO7wVAryUQOzPEPfOhvBQOBIdPSHoCUeJGXnYG5OCvTHJ+OvmfTz8blSecUceyuKeiGB/ZwQ3cUITl/q6iwlUpLdBoxWRnJmHhPRcRF2+g29+jzd4nEuUp9dESu+TsefhYbmFRbiYnIXYZBVikzLxx7U0JKTn/VMGeywkq2iPRePGjVGvXr1qrJDMKS8vDzdu3GCPBdU4pu6xYLB4wGCwaNyzOAhk3gaykgGxfPdtsCg+wUADP0BhD9g8+NH93w6Fu96AdcF9g+Go0M4NtjNOAlY2gMwKEOS6XhtoNcCygNLfsJciFH+gGrMVKMoDCrKAwmygIPvBv1m4dfkUfBJ/NbobcwtfxJ9WQdDUawR7ezs0tLNBQzsbFKg1wKVdRk8pS/F8GhpRRFpWIe7lFECt+edPP0x2wujyhsJJRdbxRN8xeLV3M9hYPRKQHhxHUZUEffFNhADBQEjMzFXjr5vp2HE2EYUXdhqtYeLkGSYJN3ezCrD80DWs//Om7li+5X8VU5IXQoRYKgJoAQgQIAxfi3jXp7AnJhl7Y1Jw/nZmqc0HeitxPS0H3QqPGQxHf1iHoIWbAy4kZpZ6DgHAub4NcgqLkK/WGgwmDe2s8VKvJriVXhwkbqXnIjEjr8y6gMeHm7FdfTGjb3O4Ohr4EFGBgPWoM/vWIPDYjOIa9DyPu1otRbLn0/g7qThIXE/LgaF3chm06KA+i22fzGewkKC8ja9arca1a9fg5eXFY12HZGRkIDk5Gc2bN4dVOXoViSwFg0UVKRss9Hzbr1EXf4DOvF38c3kPELvd+MqVPoCDe3Fvh5XNP//mZQLxUcaX9+wAWNkC6lxAnffPT0FWcegxC+HBcREAbdnB7FVOoQTsXQF7V2jtXJB/cR/qifkGw9F9QYkGk7dDbq0AZHKIEJBdKOJenga/xaZgwOnJaIQMgz0md9AQb7suh6+zffGVvQDIZSi+wpdMQJoqB69d/7/HriMdjviP+iXYyzVo6WKDVi42aOZkBW8HAdb3rgBnfjC+3yH/QkbDNricrsXfd4twNlWNi+ka5GoVyIMNdivmwg33H9vzc3JwFAZ18NUzQzlCop5wk3AvF58cuIxd527jiM2Mx/Y83RWcEZL/T8+TTAA6N3ZCeIA7wtq4w7NBPaMfqs91+x86hE1AXqEGZxLu43h8Ok7E38PphAwUPrjyWWV6r6zlAnwa2sHB1grnbmeWex0t3RzwZHMXPNncBcH+TrCzsSoOFQ8CmqGAZShcaIqKkPZuCzQS71WoB6+RgwJtPIsvI/2EuyPe+SUWQblHMN96LewL70H5QRaDhQQVaXyvX78Oa2treHt7m3QMElkmjUaDmzdvwsrKCr6+et5biSwYg0UVKR0sHjTWRk49QfwRYM1zxlc+4RfAv0fZ6boPcskoexoRYPRUpvJuv+s0wNGjVC+Brtfg/g0g7bLxdUhl4wDUdy7bY6KwhzY/E7KLu4yuQrRzgZCfaZ4gU4sU2LlDYecICLJ/fiAAhTnA/evGV+DcvPj5A1D8NbkIiCIKclVQqG4YXfyApiPUDZrAx60R/D0bwd5BCVjXB2zqA1YKYMerEHPTKtxzU1CkwfJDcbh8aL3RXpu73v3QrakLfJ3t4OtU/OPmaKu79LKx0wMjEIFrzn3xd7KqVE+BtVxAkI8jvkqbCKX6rsFgUGjrjDt9P0Vmxj3kZKYhX5UOdU46kJcBp/wEBOGi0eN4sF4Y4NsVzh5+8Pb1h7N7Y6BeQ5Sk64cDWnahyGAhUUUaX5VKhcTERNjb20OpVMLa2poBo5YRRREajQZ5eXnIzMyEVquFj48PT3+jGofBooqUChaNvIHwD4wPlpUaDICHxicAZW8vh8eHG1Nsv7zhZMzW4lOqRA2g1RaPGRE1wM1o4KcXjS9vKFw92I+8j1pDkZti8INYgZ076r0RW/whOO8+kHMXyL4D5NwBrhwAzm8wXoNtg+JxKaL2n/0QNRA1hRA0Fbvp4D9KCi7fy0hs4It8W1dkFMqQXiBDSi6gKpJDiWz0lZ8zuvwpTTMUCDZwsVajgXUR7GUFsNXmQ1aUCxTVocG6Tk2LewF1IbU+YOOAWzmA8vwqOCDPYO/VPTgiJfxbtPV1KT6tT5AVvz4EefG/ooj8b/vDJj/N4N9jkaIBbPotRE5OFm6n3EHy3XtIv58OsTAbPriDLvIrVX8M9JHbAPbuxacfpl6AWJQPAYCqgMFCqoo2viqVCmlpaSgoMFevMlUHuVwOOzs7uLq6wsbGxtzlEFUYg0UV0R3Yc3vgGPB0+S/vKSUYPLyOMlcC8ipfuJG6fanhxBTh5sF+VPbUEck9R+Vefhfg39OkNRTfXyQXKw9fwfTzzxsdwP5D8C682rcFHGyty84UFwX8MMh4DeFLAfe2DwLWQz8pF4DfFhhfvu98wD0Aur8xofjUwZgzxxAQ+7HRxRN8BsPXxwcozC3uJVHnFP9bmAtkJgKqW8ZrqAWSRGfcs/ZAkY0SqNcAVvUbQmHvDG12GlolrDe6/H3PXmhoZw1kpRSP/8q9Z3BeBgvpKtv4qtVqaDTlv08M1RwymYy9UVTj8XKzVa1xxe4ZgNYDiz+8671EaDmCQck6Wj1buavHSN2+TF78QXPzeBR/UNQTTsI/MFyL1OUf2g9Bz34Ijl4QjO2HX7fi/TUWbvy6PXZ5UZUMQc/yutNv/LqbvAZBEODvUh8D2vti0anx+Mp6GbSi/tNvFqnHYWJLd/2hAigOLOXZjy5T9T8fTXoDJ742vg9PztS7fBbaIenv742Go8SeH8G3uav+fShvQHtqIdDQtziQlJziV5gNJJ0r37glO+fiq6uJmuJQpdX88391AaApR++PezvApUVxb4nC4UGviT2uXb+GZnFrjC5+/cmP8eTTQ8pM1xQVIfXdvY8dY3FHcEajF7cBDw8SLSosfv/ISgH+3gYc/9L4PlCVs7a2hrW1gdcsEVEtw2BhClKCQQmZ3PCpQlW9fanhxBTh6sF6hEf2QyjPfpgoHAmbxz+4+tE/y+uuhmQsHEmsoYu/EyIceuLVLBTfJBD/DBhOgTPeUY/DeYee6OLvZLSGSu+H1H1o2ghvWU/B++oPDYaj/1lPxntNDd/BvdwBrfsMw+OOyhMshq0x/Horb7gJe1/vOu663oHdtV1GA5a8sf6gKreyQlLIAjQ6NsPgcUwOWQD3R688Y2UDNPAp/inKZ7AgIqJqx1OhHjB1V1CNJPGOz5KXl0rKKWWmWF7iOkpubiczcHO6ct/t2YzHwfCd4IvDkbE7weu2b85xRxLXYZJ7w0D/fSxS4IxkPfexMLYPPBVKOrYRRFQbcYxFFWGjUUtYQjiSsA4pd4w26X5I3IfFP1+AT/Y5XTi6ZR+IeQPbln8fzDnuyATrMEnAQuXvvP3oPqgKtAwWErGNIKLaqE4Fi+XLl+Ojjz5CSkoKAgMD8fnnn6NLF8M3KduyZQvmzZuHGzduoHnz5li6dCmeeeaZcm2LjQZZCo1WxIn4dNzJyoerQ/GdpR/3zbYlMsk+SAlHZu59AkwUsKR6sA+qu4m1LlhUZ/sAsI0gotqpzgSLTZs2Yfz48VixYgWCg4OxbNkybNmyBZcvX4ara9mBn8eOHUPPnj2xZMkSPPfcc/jxxx+xdOlSnD59GgEBAUa3x0aDqJYxc+8TYCEhUauBKuYAlIH9a837W3W3DwDbCCKqnepMsAgODkbnzp3xxRdfAIDu5jP/+te/8Oabb5aZf8SIEcjJycEvv/yim9a1a1e0b98eK1asMLo9NhpEVFvVtve36m4fgNp3DImIANO/t8mMz1L9CgsLcerUKYSGhuqmyWQyhIaGIjo6Wu8y0dHRpeYHgLCwMIPzExFRzcP2gYjIclnk5WbT0tKg0Wjg5uZWarqbmxsuXbqkd5mUlBS986ekpOidv6CgoNQdUTMzMwEUJzciotqk5H3NQjuoK6Q62geAbQQR1Q2mbh8sMlhUhyVLlmDRokVlpvv4+JihGiKiqnfv3j0olUpzl1EjsI0gorrEVO2DRQYLFxcXyOVypKamlpqempoKd3d3vcu4u7tXaP45c+YgIiJC97tWq0V6ejqcnZ0hCDXrCjympFKp4OPjg1u3bvE8Ygl4HE2Dx9E0MjMz4evrCyenx9xgsYaojvYBYBuhD1+PpsHjaBo8jqZh6vbBIoOFjY0NgoKCEBkZicGDBwMoflOPjIzE9OnT9S4TEhKCyMhIzJw5UzftwIEDCAkJ0Tu/QqGAQqEoNa1BgwamKL9WcHR05AvVBHgcTYPH0TRkMoscVlch1dE+AGwjHoevR9PgcTQNHkfTMFX7YJHBAgAiIiIwYcIEdOrUCV26dMGyZcuQk5ODSZMmAQDGjx8PLy8vLFmyBADw2muvoVevXvj444/x7LPPYuPGjfjrr7/wzTffmHM3iIjIxNg+EBFZJosNFiNGjMDdu3cxf/58pKSkoH379ti7d69uAF5CQkKpdNWtWzf8+OOPePvttzF37lw0b94cO3bsKPc1yomIqGZg+0BEZJksNlgAwPTp0w12bUdFRZWZNmzYMAwbNqyKq6rdFAoFFixYUOYUAKoYHkfT4HE0jdp4HNk+VL/a+HdkDjyOpsHjaBqmPo4We4M8IiIiIiKqOWr+SD4iIiIiIjI7BgsiIiIiIpKMwYKIiIiIiCRjsCAAwMKFCyEIQqmfVq1ambssi/f7779jwIAB8PT0hCAI2LFjR6nHRVHE/Pnz4eHhgXr16iE0NBRXr141T7EWzNhxnDhxYpm/z/DwcPMUa6GWLFmCzp07w8HBAa6urhg8eDAuX75cap78/HxMmzYNzs7OsLe3xwsvvFDmxnFEj2L7UDlsH0yD7YNpVFcbwWBBOm3atEFycrLu5+jRo+YuyeLl5OQgMDAQy5cv1/v4hx9+iP/9739YsWIF/vzzT9SvXx9hYWHIz8+v5kotm7HjCADh4eGl/j43bNhQjRVavsOHD2PatGk4fvw4Dhw4ALVajX79+iEnJ0c3z+uvv45du3Zhy5YtOHz4MJKSkvD888+bsWqqKdg+VBzbB9Ng+2Aa1dZGiESiKC5YsEAMDAw0dxk1GgBx+/btut+1Wq3o7u4ufvTRR7ppGRkZokKhEDds2GCGCmuGR4+jKIrihAkTxEGDBpmlnprqzp07IgDx8OHDoigW/+1ZW1uLW7Zs0c1z8eJFEYAYHR1trjKpBmD7IB3bB9Ng+2A6VdVGsMeCdK5evQpPT080adIEY8aMQUJCgrlLqtHi4+ORkpKC0NBQ3TSlUong4GBER0ebsbKaKSoqCq6urmjZsiVeeeUV3Lt3z9wlWbTMzEwAgJOTEwDg1KlTUKvVpf4eW7VqBV9fX/49klFsH0yL7YNpsX2ouKpqIxgsCAAQHByM1atXY+/evfjqq68QHx+PHj16ICsry9yl1VgpKSkAoLsbcAk3NzfdY1Q+4eHhWLt2LSIjI7F06VIcPnwY/fv3h0ajMXdpFkmr1WLmzJno3r277u7SKSkpsLGxQYMGDUrNy79HMobtg+mxfTAdtg8VV5VthEXfeZuqT//+/XX/b9euHYKDg+Hn54fNmzdj8uTJZqyMCBg5cqTu/23btkW7du3QtGlTREVF4amnnjJjZZZp2rRpiImJ4XnwZBJsH8iSsX2ouKpsI9hjQXo1aNAALVq0wLVr18xdSo3l7u4OAGWuqJCamqp7jCqnSZMmcHFx4d+nHtOnT8cvv/yCQ4cOwdvbWzfd3d0dhYWFyMjIKDU//x6potg+SMf2oeqwfXi8qm4jGCxIr+zsbMTFxcHDw8PcpdRY/v7+cHd3R2RkpG6aSqXCn3/+iZCQEDNWVvPdvn0b9+7d49/nQ0RRxPTp07F9+3YcPHgQ/v7+pR4PCgqCtbV1qb/Hy5cvIyEhgX+PVCFsH6Rj+1B12D7oV11tBE+FIgDAf/7zHwwYMAB+fn5ISkrCggULIJfLMWrUKHOXZtGys7NLfSsSHx+Ps2fPwsnJCb6+vpg5cybeffddNG/eHP7+/pg3bx48PT0xePBg8xVtgR53HJ2cnLBo0SK88MILcHd3R1xcHGbNmoVmzZohLCzMjFVblmnTpuHHH3/Ezp074eDgoDsnVqlUol69elAqlZg8eTIiIiLg5OQER0dH/Otf/0JISAi6du1q5urJkrF9qBy2D6bB9sE0qq2NMPHVq6iGGjFihOjh4SHa2NiIXl5e4ogRI8Rr166ZuyyLd+jQIRFAmZ8JEyaIolh8ScF58+aJbm5uokKhEJ966inx8uXL5i3aAj3uOObm5or9+vUTGzVqJFpbW4t+fn7i1KlTxZSUFHOXbVH0HT8A4vfff6+bJy8vT3z11VfFhg0binZ2duKQIUPE5ORk8xVNNQLbh8ph+2AabB9Mo7raCOHBxoiIiIiIiCqNYyyIiIiIiEgyBgsiIiIiIpKMwYKIiIiIiCRjsCAiIiIiIskYLIiIiIiISDIGCyIiIiIikozBgoiIiIiIJGOwICIiIiIiyRgsqM4TBMHoz8SJE81dplELFy6EIAhYvXq1uUshIqo12EYQlZ+VuQsgshQTJkww+NiTTz5ZjZUQEZGlYRtBZByDBdED/BaHiIgMYRtBZBxPhSIiIiIiIskYLIgqQRAENG7cGIWFhViwYAGaNm0KW1tbNGnSBPPnz0d+fr7e5e7du4c33ngDzZs3h62tLZycnBAeHo79+/cb3Na9e/fw1ltvoW3btqhfvz4cHR3Rtm1bzJo1C8nJyXqXuXDhAgYOHIiGDRuifv366NWrF44dO2aSfSciosdjG0F1lkhUxwEQK/pSACD6+vqKzz33nFivXj3xueeeE59//nlRqVSKAMSnnnpKLCoqKrXM7du3xSZNmuiWHTFihNi3b19RLpeLAMRPPvmkzHZiY2NFb29vEYDo7u4uDhkyRBwyZIjYpk0bEYC4fft23bwLFiwQAYjTpk0T7ezsxLZt24ojRowQAwMDRQCira2teOHChUodIyKiuoptBFH5MVhQnVfZRgOA6O3tLcbFxemm37lzRwwICBABiJ9++mmpZZ577jkRgDh69GixoKBAN/3IkSOinZ2dKJfLxTNnzuimq9VqsWXLliIAcebMmaWWEUVRjImJEa9du6b7vaTRACB+9tlnpeadOXOmCEAcN25chfaTiKiuYxtBVH4MFlTnlbzRPu7n4W99Hl7mm2++KbO+PXv2iADEpk2b6qbFxcWJAER7e3vx3r17ZZaJiIgQAYhTpkzRTdu0aZMIQGzTpk2Zb7b0KWk0unfvXuaxtLQ0EYDo5+dndD1ERPQPthFE5cerQhE98LhLCfr6+uqdPnLkyDLTwsPD0bBhQ8TFxSE5ORkeHh44evSo7jEnJ6cyy4wbNw6ffPIJjhw5opv222+/AQCmTJkCuVxe7v3o169fmWnOzs5wcnIyeL4tERE9HtsIIuMYLIgeqOilBBs2bAgHBwe9j/n5+eH+/ftISkqCh4cHkpKSAACNGzfWO3/J9MTERN20W7duAQCaNm1aobq8vb31TndwcEB6enqF1kVERMXYRhAZx6tCEVkAQRBMti6ZjC9rIqLahG0E1RT86yKqpPv37yMrK0vvYwkJCQAAT0/PUv/evHlT7/w3btwAAHh5eemm+fj4AADi4uJMUi8REVUfthFUFzFYEEmwefPmMtP279+P9PR0NGnSBB4eHgCAJ598EgCwd+9eZGRklFlm3bp1AIAePXropoWGhgIAvvvuO2i1WlOXTkREVYxtBNU1DBZEEixatEj3TRIApKWl4Y033gAATJs2TTe9SZMmePbZZ5GVlYXXXnsNarVa91h0dDS++uoryOXyUss8//zzaNGiBWJiYjBr1qxSywDA33//jevXr1fRnhERkVRsI6iu4eBtogcmTpxo8DFfX1+88847Zaa1a9cObdq0wVNPPQVra2scPHgQGRkZ6NOnD2bMmFFq/q+//ho9evTA2rVrcfjwYYSEhODu3buIioqCRqPBxx9/jPbt2+vmt7Kywk8//YSnn34aH3/8MX788UeEhIRAFEVcvXoVMTEx2L59O5o0aWLKw0BERHqwjSAqB3Nf75bI3FCOa5QHBgaWWcbPz0/Mz88X586dKzZu3Fi0sbER/fz8xLfeekvMzc3Vu620tDTx3//+t9i0aVPRxsZGbNCggdivXz9x3759ButLTU0V//Of/4gtWrQQbW1tRaVSKbZt21acPXu2mJycrJuv5Brl33//vd71+Pn5VfgmT0REdR3bCKLyE0RRFKsvxhDVDoIgwM/Pr1QXNxEREcA2guoujrEgIiIiIiLJGCyIiIiIiEgyBgsiIiIiIpKMYyyIiIiIiEgy9lgQEREREZFkDBZERERERCQZgwUREREREUnGYEFERERERJIxWBARERERkWQMFkREREREJBmDBRERERERScZgQUREREREkjFYEBERERGRZP8P3GNnw/H1TP0AAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -864,7 +1200,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" ] }, { @@ -880,7 +1217,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 59, "metadata": {}, "outputs": [ { @@ -892,8 +1229,8 @@ " [3.3600e+01, 1.1300e+01, 2.0000e+03, 2.1100e+02, 1.0000e+00]])\n", "\n", "Raw output:\n", - "tensor([[1.2761e-03, 5.2205e-04, 9.9820e-01],\n", - " [9.6627e-01, 1.6535e-03, 3.2073e-02]])\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", From a3fda0fdaa523ccdc4ea891c62b71feb17db02d7 Mon Sep 17 00:00:00 2001 From: Surbhi Goel Date: Wed, 10 Jul 2024 20:43:38 +0100 Subject: [PATCH 19/19] Updated Task10 and Task11 --- worked-solutions/01_penguin_classification_solutions.ipynb | 2 -- 1 file changed, 2 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 9be6439..01277b3 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -982,7 +982,6 @@ "\n", "# Loss plot\n", "plt.figure(figsize=(6, 4))\n", - "\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", @@ -1014,7 +1013,6 @@ "source": [ "# Accuracy plot\n", "plt.figure(figsize=(6, 4))\n", - "\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",