From 724a7e1e8d872b7fa887d835f6c848019c554bb8 Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Thu, 4 Jul 2024 16:47:28 +0100 Subject: [PATCH 1/9] Update the classification solutions notebook to utilise the PenguinDataset defined within the notebook itself --- .../01_penguin_classification_solutions.ipynb | 361 ++++++------------ 1 file changed, 117 insertions(+), 244 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index fcab877..bfb814d 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -32,38 +32,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " bill_length_mm bill_depth_mm flipper_length_mm body_mass_g \\\n", - "count 342.000000 342.000000 342.000000 342.000000 \n", - "mean 43.921930 17.151170 200.915205 4201.754386 \n", - "std 5.459584 1.974793 14.061714 801.954536 \n", - "min 32.100000 13.100000 172.000000 2700.000000 \n", - "25% 39.225000 15.600000 190.000000 3550.000000 \n", - "50% 44.450000 17.300000 197.000000 4050.000000 \n", - "75% 48.500000 18.700000 213.000000 4750.000000 \n", - "max 59.600000 21.500000 231.000000 6300.000000 \n", - "\n", - " year \n", - "count 344.000000 \n", - "mean 2008.029070 \n", - "std 0.818356 \n", - "min 2007.000000 \n", - "25% 2007.000000 \n", - "50% 2008.000000 \n", - "75% 2009.000000 \n", - "max 2009.000000 \n", - "Index(['species', 'island', 'bill_length_mm', 'bill_depth_mm',\n", - " 'flipper_length_mm', 'body_mass_g', 'sex', 'year'],\n", - " dtype='object')\n" - ] - } - ], + "outputs": [], "source": [ "from palmerpenguins import load_penguins\n", "\n", @@ -108,6 +79,14 @@ "source": [ "### Task 2: creating a ``torch.utils.data.Dataset``\n", "\n", + "The penguin data reading and processing can be encapsulated in a PyTorch dataset class.\n", + "\n", + "- Why is this class representation helpful?\n", + " - Modularity - Separation of concerns makes the cde easier to understand, maintain and test.\n", + " - Maintainability - Changes are localised, therefore we only need to change a single file to update. \n", + " - Abstraction - Users do not need to know how the data is read or processed, they only need to know how to interact with the class. \n", + "\n", + "\n", "All PyTorch dataset objects are subclasses of the ``torch.utils.data.Dataset`` class. To make a custom dataset, create a class which inherits from the ``Dataset`` class, implement some methods (the Python magic (or dunder) methods ``__len__`` and ``__getitem__``) and supply some data.\n", "\n", "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\n", @@ -123,9 +102,79 @@ "- Review and discuss the class arguments.\n", " - ``input_keys``— A sequence of strings telling the data set which objects to return as inputs to the model.\n", " - ``target_keys``— Same as ``input_keys`` but specifying the targets.\n", - " - ``train``— A boolean variable determining if the model returns the training or validation split (``True`` for training).\n", - " - ``x_tfms``— A ``Compose`` object with functions which will convert the raw input to a tensor. This argument is _optional_.\n", - " - ``y_tfms``— A ``Compose`` object with functions which will convert the raw target to a tensor. This argument is _optional_." + " - ``train``— A boolean variable determining if the model returns the training or validation split (``True`` for training)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Optional, List, Dict, Tuple, Any\n", + "\n", + "# import pytorch functions necessary for transformations:\n", + "from torch import tensor, float32, eye\n", + "\n", + "from torch.utils.data import Dataset\n", + "from torchvision.transforms import Compose\n", + "\n", + "from pandas import DataFrame\n", + "\n", + "from palmerpenguins import load_penguins\n", + "\n", + "\n", + "class PenguinDataset(Dataset):\n", + " def __init__(\n", + " self,\n", + " input_keys: List[str],\n", + " target_keys: List[str],\n", + " train: bool,\n", + " ):\n", + " \"\"\"Build ``PenguinDataset``.\"\"\"\n", + " self.input_keys = input_keys\n", + " self.target_keys = target_keys\n", + "\n", + " data = load_penguins()\n", + " data = (\n", + " data.loc[~data.isna().any(axis=1)]\n", + " .sort_values(by=sorted(data.keys()))\n", + " .reset_index(drop=True)\n", + " )\n", + " # Transform the sex field into a float, with male represented by 1.0, female by 0.0\n", + " data.sex = (data.sex == \"male\").astype(float)\n", + " self.full_df = data\n", + "\n", + " valid_df = self.full_df.groupby(by=[\"species\", \"sex\"]).sample(\n", + " n=10,\n", + " random_state=123,\n", + " )\n", + " # The training items are simply the items *not* in the valid split\n", + " train_df = self.full_df.loc[~self.full_df.index.isin(valid_df.index)]\n", + "\n", + " self.split = {\"train\": train_df, \"valid\": valid_df}[\n", + " \"train\" if train is True else \"valid\"\n", + " ]\n", + "\n", + " def __len__(self) -> int:\n", + " return len(self.split)\n", + "\n", + " def __getitem__(self, idx: int) -> Tuple[Any, Any]:\n", + " # get the row index (idx) from the dataframe and\n", + " # select relevant column features (provided as input_keys)\n", + " feats = tuple(self.split.iloc[idx][self.input_keys])\n", + "\n", + " # this gives a 'species' i.e. one of ('Gentoo',), ('Chinstrap',), or ('Adelie',)\n", + " tgts = tuple(self.split.iloc[idx][self.target_keys])\n", + "\n", + " # Exercise #1: convert the feats (Series) to PyTorch Tensors\n", + " feats = tensor(feats, dtype=float32)\n", + "\n", + " # Exercise #2: convert target to a 'one-hot' vector.\n", + " target_names = sorted(self.full_df.species.unique())\n", + " tgts = eye(len(target_names))[target_names.index(tgts[0])]\n", + "\n", + " return feats, tgts" ] }, { @@ -146,39 +195,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(42.9, 13.1, 5000.0, 215.0, 0.0) ('Gentoo',)\n", - "(46.1, 13.2, 4500.0, 211.0, 0.0) ('Gentoo',)\n", - "(44.9, 13.3, 5100.0, 213.0, 0.0) ('Gentoo',)\n", - "(43.3, 13.4, 4400.0, 209.0, 0.0) ('Gentoo',)\n", - "(42.0, 13.5, 4150.0, 210.0, 0.0) ('Gentoo',)\n", - "(46.5, 13.5, 4550.0, 210.0, 0.0) ('Gentoo',)\n", - "(44.0, 13.6, 4350.0, 208.0, 0.0) ('Gentoo',)\n", - "(40.9, 13.7, 4650.0, 214.0, 0.0) ('Gentoo',)\n", - "(42.6, 13.7, 4950.0, 213.0, 0.0) ('Gentoo',)\n", - "(42.7, 13.7, 3950.0, 208.0, 0.0) ('Gentoo',)\n", - "(45.3, 13.7, 4300.0, 210.0, 0.0) ('Gentoo',)\n", - "(47.2, 13.7, 4925.0, 214.0, 0.0) ('Gentoo',)\n", - "(45.2, 13.8, 4750.0, 215.0, 0.0) ('Gentoo',)\n", - "(43.6, 13.9, 4900.0, 217.0, 0.0) ('Gentoo',)\n", - "(43.8, 13.9, 4300.0, 208.0, 0.0) ('Gentoo',)\n", - "(45.5, 13.9, 4200.0, 210.0, 0.0) ('Gentoo',)\n", - "(45.7, 13.9, 4400.0, 214.0, 0.0) ('Gentoo',)\n", - "(43.3, 14.0, 4575.0, 208.0, 0.0) ('Gentoo',)\n", - "(47.5, 14.0, 4875.0, 212.0, 0.0) ('Gentoo',)\n", - "(46.2, 14.1, 4375.0, 217.0, 0.0) ('Gentoo',)\n" - ] - } - ], + "outputs": [], "source": [ - "from ml_workshop import PenguinDataset\n", - "\n", "features = [\n", " \"bill_length_mm\",\n", " \"bill_depth_mm\",\n", @@ -196,16 +216,21 @@ ")\n", "\n", "for _, (input_feats, target) in zip(range(20), data_set):\n", - " print(input_feats, target)" + " print(input_feats, target)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "- Can we give these items to a neural network, or do they need to be transformed first?\n", - " - Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n", - " - We must represent these data as ``torch.Tensor``s." + "* Can we give these items to a neural network, or do they need to be transformed first?\n", + " + Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n", + " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html)\n", + " + The targets are tuples of strings i.e. ('Gentoo', )\n", + " - One idea is to represent as ordinal values i.e. [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n", + " \"A\" — [1, 0, 0]\\\n", + " \"B\" — [0, 1, 0]\\\n", + " \"C\" — [0, 0, 1]\n" ] }, { @@ -214,33 +239,22 @@ "source": [ "### Task 4: Applying transforms to the data\n", "\n", - "A common way of transforming inputs to neural networks is to apply a series of transforms using ``torchvision.transforms.Compose``. The [``Compose``](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects and applies them to the incoming data.\n", - "\n", - "These transforms can be very useful for mapping between file paths and tensors of images, etc.\n", - "\n", - "- Note: here we create a training and validation set.\n", + "- Here we create a training and validation set.\n", " - We allow the model to learn directly from the training set—i.e. we fit the function to these data.\n", " - During training, we monitor the model's performance on the validation set in order to check how it's doing on unseen data. Normally, people use the validation performance to determine when to stop the training process.\n", - "- For the validation set, we choose ten males and ten females of each species. This means the validation set is less likely to be biased by sex and species, and is potentially a more reliable measure of performance. You should always be _very_ careful when choosing metrics and splitting data." + "- For the validation set, we choose ten males and ten females of each species. This means the validation set is less likely to be biased by sex and species, and is potentially a more reliable measure of performance. You should always be _very_ careful when choosing metrics and splitting data.\n", + "\n", + "\n", + "Note: A common way of transforming inputs to neural networks is to apply a series of transforms using ``torchvision.transforms.Compose``. The [``Compose``](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects and applies them to the incoming data. See how this is done more generally in the `src/ml_workshop/_penguins.py` file. \n", + "\n", + "These transforms can be very useful for mapping between file paths and tensors of images, etc." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "tensor([ 42.9000, 13.1000, 5000.0000, 215.0000, 0.0000]) tensor([0., 0., 1.])\n", - "tensor([ 46.1000, 13.2000, 4500.0000, 211.0000, 0.0000]) tensor([0., 0., 1.])\n", - "tensor([ 44.9000, 13.3000, 5100.0000, 213.0000, 0.0000]) tensor([0., 0., 1.])\n", - "tensor([ 43.3000, 13.4000, 4400.0000, 209.0000, 0.0000]) tensor([0., 0., 1.])\n", - "tensor([ 42.0000, 13.5000, 4150.0000, 210.0000, 0.0000]) tensor([0., 0., 1.])\n" - ] - } - ], + "outputs": [], "source": [ "from torchvision.transforms import Compose\n", "\n", @@ -249,58 +263,10 @@ "# and using a lower-precision float32 is advised for performance\n", "from torch import tensor, float32, eye\n", "\n", - "\n", - "# Apply the transforms we need to the PenguinDataset to get out input\n", - "# targets as Tensors.\n", - "\n", - "\n", - "def get_input_transforms() -> Compose:\n", - " \"\"\"Return transforms which map from raw inputs to tensors.\n", - "\n", - " Returns\n", - " -------\n", - " Compose\n", - " A composition of transforms (callable functions) to map the tuple\n", - " of input features (``Tuple[float, ...]``) to a ``torch.Tensor``.\n", - "\n", - " Notes\n", - " -----\n", - " To create a ``torch.Tensor`` we can use ``torch.tensor([1.0, 2.0, ...])``\n", - "\n", - " \"\"\"\n", - " return Compose([lambda x: tensor(x, dtype=float32)])\n", - "\n", - "\n", - "def get_target_tfms() -> Compose:\n", - " \"\"\"Return transforms which map from the raw target strings to tensor.\n", - " Returns\n", - " -------\n", - " Compose\n", - " A composition of transforms (callable functions) to map the tuple\n", - " of input features (``Tuple[str]``) to a ``torch.Tensor``.\n", - "\n", - " Notes\n", - " -----\n", - " Suppose we have three labels, \"A\", \"B\" and \"C\". We want to encoder each\n", - " distinct label as a one-hot-encoded vector. A natural way to do this is:\n", - " - \"A\" — [1, 0, 0]\n", - " - \"B\" — [0, 1, 0]\n", - " - \"C\" — [0, 0, 1]\n", - "\n", - " The transforms this function produces will return these vectors as tensors.\n", - " Note also, in the example we have just given, A's vector was the first row\n", - " in the identity matrix, B's the second, etc.\n", - "\n", - " \"\"\"\n", - " return Compose([lambda x: eye(len(target_names))[target_names.index(x[0])]])\n", - "\n", - "\n", "train_set = PenguinDataset(\n", " input_keys=features,\n", " target_keys=[\"species\"],\n", " train=True,\n", - " x_tfms=get_input_transforms(),\n", - " y_tfms=get_target_tfms(),\n", ")\n", "\n", "\n", @@ -308,8 +274,6 @@ " input_keys=features,\n", " target_keys=[\"species\"],\n", " train=False,\n", - " x_tfms=get_input_transforms(),\n", - " y_tfms=get_target_tfms(),\n", ")\n", "\n", "\n", @@ -336,20 +300,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([16, 5]) torch.Size([16, 3])\n", - "torch.Size([16, 5]) torch.Size([16, 3])\n", - "torch.Size([16, 5]) torch.Size([16, 3])\n", - "torch.Size([12, 5]) torch.Size([12, 3])\n" - ] - } - ], + "outputs": [], "source": [ "from torch.utils.data import DataLoader\n", "\n", @@ -387,30 +340,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FCNet(\n", - " (_fwd_seq): Sequential(\n", - " (0): BatchNorm1d(5, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (1): Linear(in_features=5, out_features=16, bias=True)\n", - " (2): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (3): Dropout(p=0.1, inplace=False)\n", - " (4): LeakyReLU(negative_slope=0.1)\n", - " (5): Linear(in_features=16, out_features=16, bias=True)\n", - " (6): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", - " (7): Dropout(p=0.1, inplace=False)\n", - " (8): LeakyReLU(negative_slope=0.1)\n", - " (9): Linear(in_features=16, out_features=3, bias=True)\n", - " )\n", - ")\n" - ] - } - ], + "outputs": [], "source": [ "from torch.nn import Module\n", "from torch.nn import BatchNorm1d, Linear, LeakyReLU, Dropout, Sequential\n", @@ -485,7 +417,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -507,7 +439,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -535,7 +467,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -692,39 +624,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0-25 time: 1.934173 seconds\n", - "Epoch 25-50 time: 1.844448 seconds\n", - "Epoch 50-75 time: 1.831056 seconds\n", - "Epoch 75-100 time: 1.817979 seconds\n", - "Epoch 100-125 time: 1.822820 seconds\n", - "Epoch 125-150 time: 1.842434 seconds\n", - "Epoch 150-175 time: 1.967782 seconds\n", - "\n", - "\n", - " loss_train accuracy_train loss_valid accuracy_valid\n", - "0 0.578070 0.496324 0.586362 0.484375\n", - "1 0.490388 0.742647 0.495531 0.750000\n", - "2 0.417000 0.819853 0.406423 0.781250\n", - "3 0.371912 0.841912 0.356070 0.828125\n", - "4 0.325209 0.871324 0.310226 0.890625\n", - ".. ... ... ... ...\n", - "195 0.019916 0.988971 0.026766 0.984375\n", - "196 0.021192 0.988971 0.023146 0.984375\n", - "197 0.022928 0.988971 0.024764 0.984375\n", - "198 0.023786 0.985294 0.026085 0.984375\n", - "199 0.023932 0.981618 0.031793 0.984375\n", - "\n", - "[200 rows x 4 columns]\n" - ] - } - ], + "outputs": [], "source": [ "from time import perf_counter\n", "\n", @@ -774,20 +676,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAGGCAYAAADmRxfNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACP2ElEQVR4nOzdd3wUdf7H8ddskt0kkEpIgYQA0kVAARELgodiOTsqWFAsp56chTvrWc+7Q/R3incW7Fixg11UmoAUQYpKrwklCel9N9md3x+bbLIkgYSU3STv5+PBg93Z2ZnPzG72O5/5NsM0TRMREREREZFGsPg6ABERERERaf2UWIiIiIiISKMpsRARERERkUZTYiEiIiIiIo2mxEJERERERBpNiYWIiIiIiDSaEgsREREREWk0JRYiIiIiItJoSixERERERKTRlFiIiIiIiEij+WVi8eOPP3L++efTpUsXDMNg7ty5R3zPokWLOOGEE7DZbPTq1YtZs2Y1e5wiItLyVEaIiPgnv0wsioqKGDx4MM8//3y91t+1axfnnXceY8aMYd26ddx5553ceOONzJs3r5kjFRGRlqYyQkTEPxmmaZq+DuJwDMNgzpw5XHTRRXWuc++99/LVV1/x22+/eZZNmDCB3Nxcvv322xaIUkREfEFlhIiI//DLGouGWr58OWPHjvVaNm7cOJYvX+6jiERExF+ojBARaRmBvg6gKaSlpREXF+e1LC4ujvz8fEpKSggJCanxHrvdjt1u9zx3uVxkZ2fTqVMnDMNo9phFRJqDaZoUFBTQpUsXLJY2ce+o0VRGiIi4NXcZ0SYSi6Mxbdo0HnvsMV+HISLSLFJTU0lMTPR1GK2WyggRacuaq4xoE4lFfHw86enpXsvS09MJDw+v9U4UwP3338/UqVM9z/Py8ujWrRupqamEh4c3a7wiIs0lPz+fpKQkwsLCfB2K32irZUSJw8m2jAJ6x4YRYg1okm0W28t5YdF2Zv20B4Ck6BA+vfWUGtt3fD8N6+rKzvMWuOs3pi3Yy7srUz3rvHfTCAYlRpJT5GD0/y3C6TKJCg0ip7jMs45hgGnCLcHzmMKHAJgYnOV6lgOODnTuaOXrO0Y16PjWpeRw9WurAOgWHcIntcRfXU6Rg/V7cwkODGBwUiQh1gA27s/l8pdWAhAdGsTc204luqP1sOftlOkLKXO6SIwKZs6fTyXEGkCJw8mopxZQ4nB5jmV3ViGXz1yBWUt8v+zJ5trXf6Z659c3Jg3DZgugd2wYLpfJ9oMF9IkL9zqmotJytmcU0Cc+HNM02ZpewI9bM3l5yU6vOOtzPopKy9mRWej5XjldJqdNn09+qROA+AgbH940kr15JXV+91Kzizjvv0txHdKLt4PVQkmZq8by6iq/N5XndfvBwqP6jjf076P696byMw+xBvDr3lziIoLJLXLQJ77qvC/emsFt7671vH/WdcMJCjToExeOy2XyxDcbmbPuAAAJETYO5Nlr7LNrZLBnP3Ud64a9uVz5ysoa56fYXs62jJrfhUq5xQ7WpeYC0KNzB/KKy+gdG0ZZaVGzlhFtIrEYOXIkX3/9tdey77//npEjR9b5HpvNhs1mq7E8PDzcbwoNEZGjpeY6VXxeRjiKIWMTRCXDwS3uZZ371v04Z4/3ul2Op6TMSeqWNST1HEBI7jbS80s4d3YmPUklITyE6bdeTkjutrq3UX0fXY53/39ITCWRvXnwhffIKy0n2taVZCODPUWx5O9cRVxsR0oie7N361pKy8oJWv8Z/WyV3zETdnxOSGYQ0baO9Db2Eh1qY2iXYEKyf2Xh+n1EBDnd23PGMiJ4L2CwzexKb8P9+KygdYRbqr6z48uWssrSj21lXT37r35cpQc2kpJdQlKf472P++AWlize6ImDYoO9GX0JL9xJUnQIwQkDvM7N2tQcJn9V4ImjMOwY5lzeia3rUom2WdzLXQbXv+Lk66s6ExwYUOvntTAliBOCdkKQwbbiqph/So9gkGUnBBtsK+vKiqXz+G5jBlG2zp740nMGMCgkh1/yw3lx9lxODK46N6HWAO7+sJxjcD/+1ZHAMewlITyER2+4lAM71rEzo4BHV7pINNPJt3UhtmwPLhfsMLvWPNcV52NoaEaN70Vux57MnDOfD3YE0MvY6/leHdy6jv7sZJvNvY2zesZx6XM/0JO9RIVaeeLmy4ku3un5Du3YuJpZy3YRaY12f+ZmrOf8bjO7MtBW8/OvfBwQYKF/p1MIz/6VAnsZF7yVRoIrHTOyOx9eGlXj/Fd+J70+29j+lJQ5+esLb5JbUk5eh2P4/OquBHfu6fW5Hfod+mXlNqJttmqfeTndzVQK7E5PfPHhITx56+WEFKYSjI0RwbsBgz22Ptzz6Xq6OnZjD+tGnH03xQ4n0RXnDLuB3eZ9vMlGBntKYvlt9UKiQgO54ZsierGX6FArj9x8NQeLHPQ1UukV3dWzn5SAJIZZd1OUWs7572bQxUzHFdGdj8Z7n5utGQVc/mlOjfMbFWrlgSvPAZqvjPDLUaEKCwvZvn07AMcffzxPP/00Y8aMITo6mm7dunH//fezb98+3nrrLcA9lODAgQO57bbbuP7661mwYAG33347X331FePGjavXPvPz84mIiCAvL0+JhYi0Wu3ht6xVlRGOYvjfUCjYX883GICJWfEIwBWZTGZuPrHk4KJq1BWXCZXX4tXXr20bXiKTcZU7sBQe8FrHa5+mgcUwvfZR/XGlItNKB8PheV7bOvXZnmm6ay8Otz0TA+PQc1PtfHjHX8d+attGHevWvY3q58y9Pa/Ppa7HR4ipoXF4Pz78+a0rpupq20a9zlOdx3iEmOoRX0NiqjyPRPWgvCiHQEeu1zbq/K7XGf8RPq9q79tPPBbTTryR0ySf1x5XLFbKSLDkHOYzqLmN6uradq4dop7Ib7Yywi9rLFavXs2YMWM8zyuro6+99lpmzZrFgQMHSElJ8bzeo0cPvvrqK+666y6effZZEhMTefXVV+tdYIiISOvRqsqI9N8bkFQAFY1gql8nWHL3EFv5uPryait5X1fU3IaX3D2e7VRfx2ufhlljH7VdvFRPAupapz7bq7x5erjtGbWdG6q/Xvv7jriNOtatexs1t+f1udT1+AgxNTQO78dH2EYdMVVX2zbqdZ7qXKcBx1VHfA2JqfI8krPL6+K2cht1ftfrjP/w+6n+vi6keTbaFJ9XsiWj9liPsA3qXLfaY6+Gdk3PL2ssfKE93OUTkbZPv2XN46jP664f4c3zK564axIO+9iwgOnCaUJAxcVAOUEE4u6XUH159cdH2oYTqGyFbScQG+U1tuG54wuYhgXj0G14PTYIMEx2ueLoaBTT2Sg47PYq169zf1gwcLHLFUcHo4RYI7/OfdYdU30eN8U2jrC9aue6zuVe6xz+3NRv2wYBmHXuo67tVf/eeOKoax8NfVwRU/V9VI+jruW1nt96xFS5p1IzkGCjvPIAm+Qzr/W7XC2m6vusz+dY699otcd1be9ov8vV48gphejp7azGQkREpE3Y/oP7/55j4NJXj9jHIjUgiSkvzGGPGct1AfO4M2iOJ6mY7xzCX8tu4ZqeJazYlU1qYBJJ5SmAwTN/vpyQ/O0s2JTBqFNP444X5rDZ0cmrjfVlAYv5e9BsT1KxwtmPO82pLLougeDAAN7dGcJn389naLco7pt0EYVpO7jw3b1El+wEDNJsycTbdwMGfQaewJ7tm1jtSMAaYNDXtd2zn97GXiyGwd+uuoAn3/nMs3x8j3I+3hXoiemh6y9hUJC7c2tpZG/ufHEOi/M6kxQVwoxRcDC/lDsXlnrWTw1M4oKkMj7cGVDRj8PKqqJYehk12+wXR/SihyuV9AI7ReHHkFiWQk5JWVXb9mrt/sOSBvL6uWHkFjsY/VaaZ/n+oG4sua4LDqeLC97PJKJoR4397KArSdTsR3Do4+p9IgzTpCSyN0+8PdezTrKRgSsimSdOt3FM5w6YMf24+4X3SS9w4IjszVsXRJBeYCem+yAefu1j0vPtlET04p+nBGINsNBjwDBCClNxdEzy9DkwY/p59T9I37mev7y3lq1mV76dGEt8RDALsqPYuG4Vi7dlssvoykt/jKFHr4E89OpHZBQ42G529ZzfvA49vc7BuxdG8uPWg7y0KchzvLvpyotndyQ0KMATU/V+PEYd33ujos/DY1/8zjfpkTX7IlQ7v1nB3elUusv9OKQHnSq+n5MDv+HcgNWeC/L/K7uUdcax/Fbepda+HnU9/uiSaHYcLOC+JWWe5fddcyFvzP2W9AI728yuXJJcxqd7grg64Af+FvSxZ59rg45ncsHN3u/77FvS8+3YI3t79xPJ2cPXKUG89cU8z77nnpJC9zX/9mxvtbM3N5b91dNvaWVRZ8+2SyJ68doFnTn3nVR6mqk1jiWm+yBeHNfB6/zuzCjk1i+zgWsa+ktWb6qxqKC7fCLSFui3rHnU67zW6KRtwtw/Q+4euGgmDJnotXpecRlLth3kD/3jPKO6PDjnV95Z6W7GFUYx60NvxeJyJxb/Drmbl3OO97z/1F4x/Lw7G3u5i3BbAA6nSWm5i6AAgzKnSWxHK2Uu0zMKk5Uy1thuIcwoAeD+sut53zmWVX8fS+cwG3+ZvZYv1u/nb2f1YcoZvQH3yDob9uYCEN3BypnP/AhAfLiNF68eysUv/OR1TMnRoRSUOsguLue0XjEs2Z4JQFJUCB/eMpI//ncpWUUOenQKrTHaU4nDyZb0AvrGhXlGVDr9qYVkFLhH0xnUJZyAQAtrU3K5d1xfrjulB099t5nXl+4GICHSxtPjh2CxGJ5RhSq3B/DCom38b8EOAAItUO5y7/fOsb25c2wfAG56czXfb3KPIHZi92g+vGWk13l45LPf2Zzurp0ZeUw0z08cyi+p2dzz0Qayi8sItBiUVxvyqFt0CE+NH8ygxMgaxzpuxo+kZBeTGBXMfy4bUus61c/HkZbXx1WvrmDZ9iyuOSmZPw6K54qXq0Yb6mgL4Oe/n+k591vSC+gWFcq2DPfx9o4N4/znlrAvt5TunUL55o5RmKbJyCfmk1fivhAOswWy6u9jj3qUsu82pvGnt9Z4nidFhVDuMjmQV+pZdtaAOL7bmE5UaBDzp47mj88tYX9uKedYVvKi9VkA7GYgJ9hfIigknNwS9/f/jL6x3Hx6T7KK7Tw053eyihx0iw4hv6SM3Ir4k6ND+fbOUQCe717ldxXgjWU7eXLeVk8s8cHl/GjciNV0N+E7cMaznP9jVzILHV7vq+vzKnE4OeM/iziQV+pef8pIQp7tC6W5ADxpXM8LJe7JPW8e1ZOXfnR3kv9Dv848d+VQQqwBfPPbfm59Z22NcxkbZmPx3WNq7DM9M4f4ztGqsRAREfFbjmKYcRwUZ9b++uLpFB5zHtuynfRLcBfmpz25gPzScs8FQF5pGe9WJBUBFoMCVyi7OgzmmILVANxufMBbDKAU92hVa1NysFdcHefbnZ5dlTndF7bjBsbzwLkDmPXTLqZ/uwUHQSxxDeTcgJ8BuCXgS+Y4T+PVpTu58w99WL07G4ABXaouNkKsAYzo2QnAM3QlQFq+HcMw6J8QzqYD7mZL5w9K4LELBnLy9PkAnqQiIiSQzyqGa1167xl1XmSFWAMYkhTp9Xzx3WP4YsN+7vl4A+mFdipvhZ7SO4YQawBXj0j2JBb2MpMh3aK8tlt9e2f0i/MkFpVJBcAHP6dy86hjCLEGcP6QLp7Eok9cxxrn4c9jenH7++6LuN2ZxYRYAxjbP55l93VmS3oBLy7azrzf3e+fNDKZ+8/pX+tFdog1gHl3jjpsgnDo+TjS8voY2z+OZduzeHvFHj5du9frtUK7O5kYUjHkbuU+RnTs5Fnnh6mja8T88jXDuOLlFQAU2Ms92zganTt6j8T2f5cN5sOfU/lk7T7PsmUV36s+cWFEd7Qyf+poPlydyn8/z/V0UnYSgBMLRSVVQxtvSsv3JG9j+sR5JZ2VyXP15G7x3WNqHOvJvTpDtcQirTSQFcHHMgr3d8K1cBrf3b6SlEK83lfX+QixBrDgr4ec015j4bePAbjZ9i2vl5xGKTY+W1d1DjanFXgeJ0SE1rrtjAJ7rZ9FUw1NXRclFiJtQFlZGU6n88grSqsTEBBAUFCQr8OQI9m/ru6kAiBnF1f/+w3Wmb3o0SmUaZccR36p+y5p5QXA3LV7Pa3PnRV3vb/OSeIvge7EomNxCid3TGdBYTcAihxOEiKCve7mVvfDpgweOHcA153cgw9/TmVXVjHrXL08iUWyJYO+RiovLbbx+br9nu089vlGRvaMqXEB0jcujB6dQtmVVUyPTqH0jQtj3LFxnsRiXWou2zIKKC1zeb0vr6SclJxiojtaG3xRHGINYEzfWM95qtQ10j3/SOU5BMguchz2orZffLgn/i7hNvbnu7d3IK/U876Te1ZdRH/7exp/P2+A13lIjKqa96T6+yqPq39CuCexWLzlIPef0/+wx3a0F+BHq1dsVbJUZPcuM5IrPtPDqS3mQYmRNb4XR6v6Z9SjUyiDEiM5WGD3SiyKHO64e3bu4Inp8mFJrPixEEvFn0KoYaevkUpG2LEcqOVzPvQ4RlT73A93rNX/BiqtKjuGUUHuxKKrmcbWXesYcsLoeh9zjf10OcGTWESU7qevkcp6sxdp+VXf/325VcdSPabk6BAwDPY0wWdxtJRYiLRi+fn5ZGZmYrfXnHhH2g6bzUZMTIyaNvmzkMhqT2p2pM6yJbG5NAmAXVnF7M8t8axtMSA+PJgv1lWNHtUlMpj9uaU8X34+4wMWkWDksNMVz/WXnMumz7Z7mk58cuspfL5hH49+vrFGSNUvpL6+w313/N73A5hc+C0JRg55Id3YUhFT9eRkT3ZxnXc6K7dTeXd1cGKE5/XUHPcxVV7kVDYLauwFTkxHK7ZAi6d2JjjIQnQH92R1tSU7dakef7eoUC59cVmN9+2t9rlkFtZMVPonhB92f/3iq57XdR59aVhyNGHBgRRUJGSBBrx63TBCggJrNMWqr9q+F0ertm39oX9cjYt5gB4xHbze9/RfrsQ+8zlsBSm4onryjwsuJ6lzp1o/58bGt2FvLvd8soE9WcV8F3Yp19oX0NnMJtVIIKnv0Ebtg2GTYflzULAfV1RP7Pa+kO2sM2k49JxB3U2vWoL6WFRQu2RpbfLz89m3bx8dO3YkIiKCoKAgTYrWxpimSVlZGXl5eRQWFtK1a9cj/j7pt6x5HPG87vkJ3jgHwrrALUtqTKA2ZX4JX27KA9wXyn86rSf//maz5+0RIYHklZRjAG9dfyJBAQYTKmbbDcZ999Ue1Zc5d54JeF84lDicnPvsj7XesTy0H8MDn27g01Xb6WukUhzZh4OlFk/78kq1va8u1fd9aJvyblGhpOQUN8kFzhn/t4idmUUAHNO5A/P/OtorhqO5kKrtfbUdT23t4g/XZv5I7/e1NXuyufTF5QCEWgNY8+CZfhfjoUocTtam5HDlq1V9Ql6ZNIwzB8R5r1jZzym2P1hDPe9tjgvt6tulrNg9gWXfoYR0aIJagmrHUYKtSZOG5i4jVGMh0kplZmbSsWNHEhMTlVC0YSEhIYSFhbF3714yMzOVLPir/Irahuge0CHG/a9ShxjW7J/veTogIZxVu3MA9/wNpomn86sJhIUE0TcujO6dQtmdVUxcdCQPjD/d647yoX0R6nvHsn9CBKXYWG/2ghwX/7ygPw9+/rvn9SfHD+L8QV3qfdFS193qyviiO1rrtZ0j6RoV4kksukZ5tyk/2iZFtb2vPnffD7e/prx731wCLFUzMBQ7nH5Xq1KbEGsAJ/eKoXOYjYMVTeJ6xNTSt8AaColDa7y3OY7Pa7vWMPo0oPnTEVU7jhC8/979/bOqa54UEfFjZWVl2O12IiIilFS0A4ZhEBERgd1up6ys7MhvkJZX4B42lbD4Gi8dyCvhQF6pZxK4ZTsyWbbNPQHWHwcleK1b2c49xBrAN3eMYu5tp/Dtnaczomenw16kVl7khFgDvB4favzQRE//hB6dQjl3UBeSO4V6njckqaht382lMuZDHzeHxh5PS5yPxugbF+b1mfuiHf7R6tHJ3fzJYkBSdO2dlsW3VGMh0gpVdtRWp972o/Kzdjqd+tz9UUGa+/+wqkTB5TJZsTOTn3ZkAdAvLoztBwspc5qUVHTO/rliJCaATh2szLn1FM8FaXPcaQ2xBvDD1NO97qh/6+d32OHQxCLYh5G0fq3lM69Nj5gOrNqdTecwGy7XkdeXlqfEQqQVU21F+6HP2s9VNoUK7wLA/twSbnv3F9ZWG6K1S0Qwm6oNEwmQllc18EJWkcMzelJzqm1YV39vXtG12mhM1R/L0WkNn3ltkqLdn316vp1zn/3RL/uwtHdqCiUiItJYnqZQCSzcnM6p0xd4JRUAq/fkeJqgBFrciWJydEirbZbSkqrXWMR0sB1mTWnLqs+xsivLPeqW+BfVWIiIiDRWRWKxNjeYyV+urnWVvNJyXp40DFtQgNeISeDb4SFbg07VanHun/Mr3991us5VOzSyZ0yTzZkhzUOJhYi0ag1tIpScnMzu3bubNIbu3buzZ88eNHp3O2WakO9OLN7YYAeqLoLjwqwYFgtpFfNOVB/ZqXqTp9bYLKUl5VcbEndvTkmrGMlIml5rGHWrvVNiISKt2rXXXltj2dKlS9mxYweDBw9myJAhXq/FxMTUWF+kUUpywOnuK7Fgf1UL4y7hNr683d0GXBdCjdM/Idwz/K7uVLdvrbV/SHuhxEJEWrVZs2bVWHbdddexY8cOLrroIh599NFmj2H+/PkaBrY9q+i4bbdGUVgaSFJ0CP+dcDz94sNrnXdCGq5y+F0laCL+TYmFiEgjHXPMMb4OQXypYqjZDKIAOPvYeI7vFuXLiNok3akW8X8aFUpE2o1Zs2ZhGAaPPvooW7duZcKECcTFxWGxWJg7dy4A27dv59FHH2XkyJHEx8djtVpJTExk0qRJbN26tdbtdu/evUZfj927d2MYBqNHj6akpIT77ruP5ORkbDYbvXr1Yvr06eqT0Vbk7AZgZ4l78q6vfj1AicPpw4BERHxDNRYi0u5s2bKF4cOH06lTJ8aMGUNOTo5n0rlXX32VJ598koEDBzJ8+HBsNhsbN27k7bff5rPPPmPJkiUMGjSo3vtyOBycddZZbNy4kdGjR1NUVMTixYu57777KCgo4J///GdzHaa0BEcxLHR/hsdbthOMnf25qHOxiLRLSixEpN15//33mTJlCjNmzCAgwLut9kUXXcTNN99Mjx49vJa/8cYbXH/99dx5550sWLCg3vtavnw5p59+Ort27SI83D0G++rVqznppJN45plnuO++++jYsWPjD0p8I2OTu/M2EG6U0NdIJT96kDoXi0i7pMRCpI0xTZOSsqZvhlHicLIto4DesU3fcTIkKKBFZ5bu3Lkz06dPr5FUAJx00km1vmfy5Mm89tprLFq0iLy8PCIiIuq1L4vFwksvveRJKgCGDRvGOeecw5dffsnq1asZPXr0UR2H+IHY/hBog3I76WYkIYkDef8mzQYsIu2TEguRNqakzMmAh+f5OowG2fiPcYRaW+7naOzYsYSGhtb5emFhIV988QXr1q0jOzvbM+LTgQMHME2THTt2cMIJJ9RrX8nJyfTt27fG8j59+ni2Ka1YUAgEuBOLmxxTGZIYp6RCRNotJRYi0u5069atztcWLFjAhAkTOHjwYJ3rFBQU1HtfiYmJtS4PC3M3lbHb7fXelvihooNgz8eFhS1mNy6IrjthFRFp65RYiLQxIUEBbPzHuCbdZonDySUv/sSerGKSO4Xy6a0nN+ld2ZCglr3DGxwcXOvywsJCLr/8crKzs3n44YeZMGECycnJhISEYBgGV155JbNnz27QaE4Wiwbfa9MObgEg3RKHHSvdlFiISDumxEKkjTEMo8mbFYVaA/m2HUxOtWTJErKyshg/fjyPPfZYjdd37tzpg6jEr2W6hyDe5koAoFsnJRYi0n4psRCRemkPk1Pl5LhH96mt+dL27dv55ZdfWjok8XeZ2wDYXO5OLJKilFiISPulOnoRkQqVHao//fRTrz4Wubm53HDDDZ5O3CIeFTUWO8wuxHS00sGm+3Ui0n4psRARqTBs2DDOPPNMUlJS6NOnDxdffDEXX3wxPXr0YP/+/Vx44YW+DlH8TUUfi1RXDF0jQ3wcjIiIbymxEBGp5rPPPuPvf/87nTt35ptvvmHNmjVMmDCBFStWEBkZ6evwxJ8UZUL+XgCmBb3G3oNZlDiafg4ZEZHWwjAbMrxJG5afn09ERAR5eXleE1mJ+KPS0lJ27dpFjx496hzhSNqW+n7m+i1rHrWe142fw4fXeNa50P4PHvvztW2+L5KItF7NXUaoxkJERORohEZ7Hu50xZMb1pu+cWE+DEhExLfUy0xERORoOIoA2OrqwmWuafx455ltdihmEZH6UI2FiIjI0SjOAmC/2ZkTjulCRGiQjwMSEfEtJRYiIiJHoyKxyCaME3tEH2FlEZG2T4mFiIjIUSjNywAgxwzj7RV7NCKUiLR7SixERESOQtqBfQBkm2Hszy1lS3qBjyMSEfEtJRYiIiJHIcieA0AOYfToFKoRoUSk3VNiISIichTMij4W3bom8vUdozQilIi0e0osREREjkJgaTYA3ZKSlFSIiKDEQkRE5KiElOUCEB/f1beBiIj4CSUWIiIiDVRqdxBmFgKQlJjo42hERPyDEgsREZEG2rNvPxbDBCCmc7yPoxER8Q9KLERERBpoV8oeAAqNjhiBVh9HIyLiH5RYiIiINECJw8n7i9YBkOXqqInxREQqKLEQkVbtyiuvxDAMHn/88SOuu2rVKgzDIC4ujvLy8gbt57rrrsMwDBYtWuS1fPTo0RiGwe7du+u9rVmzZmEYBo8++miDYhD/sCW9AKvDPYdFltlRE+OJiFRQYiEirdo111wDwLvvvnvEdd955x0AJk6cSGBgYLPGJW1Xn9iORBvujtvFgZGaGE9EpIISCxFp1c466yzi4uLYsmULP//8c53rlZeX88EHHwBVyUhTeOutt9i0aRNdu2rI0fYivcBOFO5aihMH9NYcFiIiFZRYiEirFhAQwMSJE4GqGonafPfdd2RkZNC/f3+GDh3aZPvv1q0b/fr1IygoqMm2Kf7tlz05xBi5AFg7RPg2GBERP6LEQkRavauvvhqADz74AKez9o60lU2lrr76anJzc/nf//7HuHHjSE5Oxmaz0alTJ84++2y+//77Bu37cH0sli1bxtixYwkLCyMyMpJx48axcuXKhh2c+J1fdx/g8oBF7icbPgRHsS/DERHxG0osRKTVGzp0KP379yc9Pb3WxKCoqIjPPvsMwzC46qqrWLFiBbfffjtbt26lb9++XHzxxfTt25fvvvuOcePG8frrrzc6pi+//JLRo0czf/58BgwYwDnnnENqaiqjRo1i+fLljd6++E72rvWEGaXuJyXZkLHJtwGJiPgJ9V4UaWtME8qa4Q5qWTEc3AKd+0JQaNNuOygUDKNRm7jmmmt44IEHeOeddzj77LO9Xvv0008pKiri9NNPJzk5GZfLxfLlyznppJO81lu7di1nnHEGd911F5dffjkdO3Y8qlgKCgq4/vrrKS8v5/XXX2fy5MkAmKbJ/fffz/Tp04/uIMXnsgrsfJcZjcMWgNVw4gpLwBLb39dhiYj4BSUWIm1NWTH8u4uvo2iYB/aDtUOjNnHVVVfx97//nblz51JUVESHDlXbq+x7UdlkqkePHvTo0aPGNo4//nhuu+02/vWvf7Fw4ULOP//8o4rl448/5uDBg4waNcqTVACeYXHfffdd9u7de1TbFt9auj2TUmyUYsVKCVvPeIV+1iZOtEVEWiklFiLSJnTr1o1Ro0axePFi5s6dy1VXXQVAeno68+fPJzg4mMsuu8yzvtPpZP78+fz0008cOHAAu90OwLZt27z+PxpLliwBYMKECTVeCwoKYvz48cyYMeOoty++E9UhiBBKCTdKAEjuNdDHEYmI+A+/TSyef/55nnrqKdLS0hg8eDD/+9//OPHEE+tcf8aMGbz44oukpKQQExPD+PHjmTZtGsHBwS0YtYgfCAp11wA0pbJiePVMyNkFUT3gxu+btjlUE23rmmuuYfHixbzzzjuexGL27Nk4nU4uueQSIiLcI/js3buXP/7xj6xfv77ObRUUHP2kZ/v3u89/cnJyra937979qLctbr4qI+xlLuIM9+R4ZlAHQjpGNuYwRETaFL/svP3BBx8wdepUHnnkEX755RcGDx7MuHHjyMjIqHX99957j/vuu49HHnmETZs28dprr/HBBx/wwAMPtHDkIn7AMNzNipryX4fOcOtPcOMC9/8dOjft9hvZv6LS+PHjCQ4O5ocffvD8XlQ2g6o+d8WNN97I+vXrufTSS1m5ciW5ubk4nU5M0+Sll14C3P0hxD/5sozILy0jviKxMMITmuy7KyLSFvhlYvH0009z0003MXnyZAYMGMDMmTMJDQ2tc6SWn376iVNOOYUrr7yS7t27c9ZZZzFx4kRWrVrVwpGLtGHWUEgc6v7fT0VERHDBBRdQXl7O7Nmz2bx5M2vWrCEmJsbTobuoqIjvv/+euLg4PvjgA0488UQiIiKwWNw/hzt37mx0HAkJCQDs2bOn1tfrWi7148syoqC0nDiy3U/CEhpzGCIibY7fJRYOh4M1a9YwduxYzzKLxcLYsWPrHKLx5JNPZs2aNZ5CYufOnXz99dece+65LRKziPiPyg7a7777rmfuiiuuuMIzgV1eXh4ul4uEhAQCArxnTC4rK2POnDmNjuG0004D4MMPP6zxWnl5OZ988kmj99Fe+bqMKCgt9zSFIryVDZIgItLM/K6PRWZmJk6nk7i4OK/lcXFxbN68udb3XHnllWRmZnLqqadimibl5eXccssth63mttvtns6aAPn5+U1zACLiU2effTYxMTH8/PPP7Nq1C/BuBhUbG0tERAS//fYby5Yt45RTTgHcnbnvvfdetm7d2ugYLrvsMu655x4WLVrEm2++ybXXXgu4m1c98sgjpKSkNHof7ZWvy4iC0jL6VCYWYfGNPBoRkbbF72osjsaiRYv497//zQsvvMAvv/zCp59+yldffcXjjz9e53umTZtGRESE519SUlILRiwizSUoKMgzGlNmZia9e/dmxIgRntcDAwO55557KC8v5/TTT+ess85iwoQJ9OrVi5kzZ3Lbbbc1OoawsDBee+01AgICuO666zjppJO48sorGThwIE899RQ33XRTo/ch9deUZUReSRlxRmVTKNVYiIhU53eJRUxMDAEBAaSnp3stT09PJz6+9rtDDz30ENdccw033ngjxx13HBdffDH//ve/mTZtGi6Xq9b33H///eTl5Xn+paamNvmxiIhvVK+hqGwaVd0DDzzAm2++yaBBg1i2bBk//PADgwcPZsWKFQwbNqxJYrjwwgtZuHAhY8aM4bfffuOrr74iISGBxYsXc/LJJzfJPtojX5cRBfZyT+dtwtXHQkSkOr9rCmW1Whk6dCjz58/noosuAsDlcjF//nymTJlS63uKi4s9HS8rVbadrmtkF5vNhs1ma7rARcRvnHjiiUcc1WnSpElMmjSpxvJBgwZx3XXX1Vg+a9YsZs2aVWP5okWL6tzHaaedxoIFC2osHzlyZK37kCPzdRlRUFKtj4VqLEREvPhdYgEwdepUrr32WoYNG8aJJ57IjBkzKCoq8sxgO2nSJLp27cq0adMAOP/883n66ac5/vjjGTFiBNu3b+ehhx7i/PPPr9E5U0REWjdflhGFpXZiK0eFCo5o0uMSEWnt/DKxuOKKKzh48CAPP/wwaWlpDBkyhG+//dbTWS8lJcXr7tODDz6IYRg8+OCD7Nu3j86dO3P++efzr3/9y1eHICIizcSXZYStOA1rYEXzqdlXwC3L/HoIZhGRlmSYmgUKcI/4ERERQV5eHuHh4b4OR+SwSktL2bVrFz169NDs8u1EfT9z/ZY1j8rzeufdd/JMaLX5Mm5c4J7fRUSkFWjuMsLvOm+LiIj4q3JnedWT6GMgtr/vghER8TNKLEREROopyZIJgKvveXDLUjWDEhGpRomFiIhIPfUw0gCwdD9FSYWIyCGUWIiIiNRTZWJBTF/fBiIi4oeUWIi0Yhp7of3QZ+0fko2Kiflievs2EBERP6TEQqQVqhx7v6yszMeRSEup/Kw1N49v2YxyHFghIsnXoYiI+B0lFiKtUFBQEDabjby8PN3JbgdM0yQvLw+bzUZQUJCvw2n30q1JYFHxKSJyKL+cIE9EjiwmJoZ9+/axd+9eIiIiCAoKwjAMX4clTcg0TcrKysjLy6OwsJCuXbv6OiQBsmyJqL5CRKQmJRYirVTlxDaZmZns27fPx9FIc7LZbHTt2lUT3vmJPsVrwVGsUaFERA6hxEKkFQsPDyc8PJyysjKcTqevw5FmEBAQoOZPfibUmQ8ZmzTjtojIIZRYiLQBQUFBuvgUaSFF1k500IzbIiI1qPeZiIhIA/yr7GpKsPk6DBERv6PEQkREpAHS7YFsSS/wdRgiIn5HiYWIiEgDdAwJpm9cmK/DEBHxO0osREREGmDCST0JsWqiQhGRQymxEBERaYDgYPWvEBGpjRILERGRBrAEWH0dgoiIX1JiISIi0gCWQA3tLCJSGyUWIiIiDRCgxEJEpFZKLERERBogQE2hRERqpcRCRESkASxBgb4OQUTELymxEBERaYDAQNVYiIjURomFiIhIA1iUWIiI1EqJhYiISAMEBimxEBGpjRILERGRBggMVB8LEZHaKLEQERFpgMAgzbwtIlIbJRYiIiINoM7bIiK1U2IhIiLSAIFBmiBPRKQ2SixEREQaINCqGgsRkdoosRAREaknp2kQFKDO2yIitVFiISIiUk/lBGCxGL4OQ0TELymxEBERqadyFZsiInXSL6SIiEg9laNmUCIidVFiISIiUk9OI8DXIYiI+C0lFiIiIvXkQomFiEhdlFiIiIjUU7kSCxGROimxEBERqSenEgsRkTopsRAREaknpzpvi4jUSYmFiIhIPbnUeVtEpE5KLEREROrJaajGQkSkLkosRERE6slUjYWISJ2UWIiIiNSTmkKJiNRNiYWIiEg9aYI8EZG6KbEQEZEm9eabb1JaWurrMJqFS30sRETqpMRCRESa1OTJk+nSpQt/+ctfWL9+va/DaVJKLERE6qbEQkREmtSNN95IeXk5zz//PCeccAInnXQSr732GkVFRb4OrdFMixILEZG6KLEQEZEm9fLLL3PgwAFefvllhg8fzqpVq/jTn/5Ely5duOWWW1i9erWvQzxqGhVKRKRuSixERKTJdejQgRtvvJEVK1awYcMGbrvtNgIDA3n55ZcZMWIExx9/PDNnziQ/P9/XoTaISzUWIiJ1UmIhIiLNauDAgfz3v/9l//79vPPOO4waNYr169dz22230aVLF2644QbWrFnj6zDrR4mFiEidlFiIiEiLKCsro6CggIKCAgBM06SsrIw33niDE088kfHjx5Obm+vbII/AVOdtEZE6KbEQEZFmtWLFCm644QYSEhL485//zIYNG7jkkkv47rvvyM/P59133+W4445jzpw53H777b4O97DUeVtEpG76hRQRkSaXk5PD22+/zSuvvMLGjRsxTZOkpCTuvfdebrzxRuLj4z3rTpw4kcsuu4zjjz+er7/+2odR14M6b4uI1Mlvayyef/55unfvTnBwMCNGjGDVqlWHXT83N5fbbruNhIQEbDYbffr08f8CSkSkDbr66qvp2rUrd911F5s2beKcc87h888/Z9euXTz44INeSUWlwMBAhg8fTk5OTr324asywrQENfg9IiLthV/WWHzwwQdMnTqVmTNnMmLECGbMmMG4cePYsmULsbGxNdZ3OByceeaZxMbG8vHHH9O1a1f27NlDZGRkywcvItLOvffee8THx3P99dfzpz/9iW7dutXrfRdffDHJyclHXM+nZYSaQomI1MkwTdP0dRCHGjFiBMOHD+e5554DwOVykZSUxF/+8hfuu+++GuvPnDmTp556is2bNxMUdHR3k/Lz84mIiCAvL4/w8PBGxS8i4iv+8Fv2ySefcOGFFxIY2DwX4b4sI+Y/ezNn3D6zUfGLiPhKc5cRftcUyuFwsGbNGsaOHetZZrFYGDt2LMuXL6/1PZ9//jkjR47ktttuIy4ujoEDB/Lvf/8bp9PZUmGLiEiFSy+9tNmSCp+XERb1sRARqYvfJRaZmZk4nU7i4uK8lsfFxZGWllbre3bu3MnHH3+M0+nk66+/5qGHHuI///kP//znP+vcj91uJz8/3+ufiIg03i+//MLUqVP5+eef61xn1apVTJ06lXXr1jVo2z4vIwLUFEpEpC5+l1gcDZfLRWxsLC+//DJDhw7liiuu4O9//zszZ9ZdXT1t2jQiIiI8/5KSklowYhGRtuu5557jhRdeoHv37nWu06NHD1544QWef/75Zo+nScsIdd4WEamT3yUWMTExBAQEkJ6e7rU8PT291pFEABISEujTpw8BAVVV1P379yctLQ2Hw1Hre+6//37y8vI8/1JTU5vuIERE2rElS5Zwwgkn0Llz5zrX6dy5MyeccAKLFy9u0LZ9XUYY6rwtIlInv0ssrFYrQ4cOZf78+Z5lLpeL+fPnM3LkyFrfc8opp7B9+3ZcLpdn2datW0lISMBqtdb6HpvNRnh4uNc/AAoymu5gRETaoX379h22tqJScnIy+/fvb9C2fV5GqCmUiEid/C6xAJg6dSqvvPIKb775Jps2beLWW2+lqKiIyZMnAzBp0iTuv/9+z/q33nor2dnZ3HHHHWzdupWvvvqKf//739x2220N3/mss8FR3FSHIiLS7thsNnJzc4+4Xn5+vlctQn35soww1BRKRKROfnnr5YorruDgwYM8/PDDpKWlMWTIEL799ltPZ72UlBQslqqcKCkpiXnz5nHXXXcxaNAgunbtyh133MG9997b8J0XZkDGJkgc2lSHIyLSrhx77LEsXbqU7OxsoqOja10nOzubH3/8kYEDBzZ4+74sI4xAJRYiInXxy3ksfKFyXN/MR5Lp9MBGsIb6OiQRkQbzh3ksZs6cyZ///GdGjx7NW2+9RWJiotfr+/bt49prr2XhwoU8++yzTJkyxSdxNkTlef3xvemcNvEeX4cjInJUmruM8MsaC196034Gt2IjxNeBiIi0UjfeeCOzZ89m0aJF9OnTh7PPPptjjjkGgB07djBv3jxKSko45ZRTuOWWW3wcbcMYAaqxEBGpixKLQ5SXl7AlvYAhSZG+DkVEpFUKDAzkm2++4fbbb+fNN99k7ty5Xq8HBAQwefJknn322WabSK+5KLEQEalb6/pFbwGdAh30jQvzdRgiIq1aaGgor776Ko8//jiLFi3yDNealJTE6NGjSUhI8HGER8eiUaFEROqkX8hDDOxkIcTa8FFKRESkpoSEBCZOnOjrMJqMEgsRkbr55XCzvhToLPR1CCIi4qcsgbXPeyEiIqqxqMFSVuTrEERE2oTi4mIWLlzItm3bKCgooLZBCA3D4KGHHvJBdEcnQMPNiojUqVGJRXFxMZmZmXTq1IkOHTp4lufk5DB9+nR+++03unXrxl//+lfPiCD+Lqhck+OJiDTWrFmzuOuuu8jPz/csM00TwzBqPG9NiYU6b4uI1K1RicXjjz/Ok08+yapVqxg61D2hnN1u56STTmL79u2eu1Mff/wx69evbxWd9azlqrEQEWmMH374gRtuuIGIiAgeeOABFi5cyPLly3nppZfYsWMHc+bMYdu2bUyZMsVTdrQW6mMhIlK3RvWxWLBgAcccc4xXwfDOO++wbds2xowZw7x587j99tvJzMzkmWeeaXSwLcHqUo2FiEhj/Oc//8EwDBYuXMjjjz9O7969Abjpppt44okn+P3337nzzjt5/fXXW11iEaA+FiIidWpUYpGSkuIpMCp9/vnnGIbBG2+8wZlnnsmMGTPo06cP33zzTaMCbSnBZomvQxARadV+/vlnTjrpJAYPHlzr64GBgfzf//0fsbGxPPLIIy0cXeNY1MdCRKROjUoscnJyiIyM9Dw3TZOlS5cyaNAgkpKSPMsHDx7sGcPc34VSCi6nr8MQEWm1CgsL6datm+e5zWYDoKCgwLPMYrEwYsQIlixZ0uLxNUagEgsRkTo1KrGIj49n165dnudr1qwhJyeH008/3Wu96p31WgWHhpwVETla8fHxZGdne55X9q/bunWr13rZ2dmUlLSuWmKNCiUiUrdGJRZDhgxh1apVzJ07l4KCAh5//HEMw+CPf/yj13rbtm2jS5cujQq0JZml+UdeSUREatWvXz+2bdvmeX7yySdjmiZPPvmkZ1CPn376iQULFtC3b19fhXlU1MdCRKRujUos7rnnHgAuvfRSIiMj+eKLLxg8eDBnnHGGZ5309HTWr1/fqjrolRbl+ToEEZFW67zzzmPXrl2sWrUKgD/84Q8MGjSIjz/+mK5duzJ06FDGjBmDy+Xizjvv9G2wDRQYpFGhRETq0qjE4uSTT2bOnDmceuqp9OvXj6uvvprPP/8ci6Vqs7NnzyYsLIyzzz670cG2lJKCHF+HICLSak2aNIlvvvmGuLg4wN2f4quvvuLMM88kIyODtWvXEhoayj//+U+uvvpqH0fbMAFBqrEQEamLYdY2FWo7lJ+fT0REBHn3hVF46Xt0GfbHI79JRMTPeH7L8vIIDw/3dTg1FBcXk5eXR2xsLAEBAb4Op94qz2v6nq3Edut95DeIiPih5i4jVKdbC3uxmkKJiBytqVOnEhUVVeuM2qGhoYSGhvogqqYRFKTO2yIidWlUU6j09HR+/PFH0tPTvZbv2LGDCRMmMHDgQM4991yWL1/eqCBbWrn6WIiIHLXnnnuODRs2+DqMZqFRoURE6taoxOKJJ55gzJgx5OVVXYjn5+dz6qmn8tFHH7Fx40a+/fZbxo4d6zVCiL8rL1FiISJytBITE3G5XL4Oo3lYlFiIiNSlUYnFokWLGDBgAH369PEsmzVrFunp6UycOJEtW7bw9NNPU1JSwn/+859GB9tSnBpuVkTkqF100UUsXrzYa0K8NiNAiYWISF0alVjs27ePnj17ei376quvCAwMZMaMGfTu3Zs777yTwYMHs3jx4kYF2qJK22BhKCLSQh577DG6devGueeey9q1a30dTtMyGlVsioi0aY3qvF1QUODVCc/pdLJ8+XKGDh1KTEyMZ3m/fv348ssvG7OrlmVXYiEicrQuvPBCbDYby5YtY9iwYSQkJNCtWzeCg4NrrGsYBvPnz/dBlEfJMHwdgYiI32pUYtGlSxc2b97seb506VIKCwsZPXq013rl5eVYra1n7G+LQ4mFiMjRWrRokeexaZrs37+f/fv317quoQt1EZE2o1GJxciRI5k9ezYzZszgD3/4Aw8++CCGYXD++ed7rbdp0ya6du3aqEBbUkB5ka9DEBFptXbt2uXrEERExAcalVjcf//9fPrpp/z1r38F3HemxowZw8knn+xZZ/fu3WzcuJEbbrihcZG2oMCyQl+HICLSaiUnJ/s6hGZT4nDif9MOioj4h0b1Qjv22GNZunQpV199NWeffTYPPvggc+fO9Vpn3rx5DB48mIsuuqgxu2pRHcuywVHs6zBERMTPjH9xGSUOp6/DEBHxS4Zpmqavg/AHninO7wsj3GbgiuqJ5dZlYG29M8SKSPvj+S3LyyM83Df31lNSUhq0frdu3ZopkqZTeV6T7vyQz6eeyZCkSF+HJCLSYM1dRjSqKVRbZsnZSen+3wjufqKvQxERaVW6d+9e707ZhmFQXl7ezBE1neToEPrGhfk6DBERv9QkiUV6ejqvv/46S5YsYd++fQB07dqVUaNGMXnyZOLi4ppiNy1qpyueAjOJwb4ORESklRk1alStiYXL5SI1NZWUlBRcLhcjR45sVSMGAnx84/GEWAN8HYaIiF9qdFOoTz75hOuvv57CwkIO3ZRhGISFhfHaa69x6aWXNirQ5nZoU6gLQ97i/bv+qAJERFoVf2gKdSRbt27lxhtvxDRNvv/++1rnt/A3nvM6fRDhdy5XM1kRaZWau4xoVOft1atXM3HiRIqKirj44ouZM2cOa9euZd26dcydO5dLLrmEwsJCrrzySlavXt1UMTcrl+m+y/bO9UOVVIiINIM+ffrw6aefsnHjRh555BFfh9MwObsgY5OvoxAR8UuNSiymTZuG0+nko48+4uOPP+bCCy9k8ODBDBo0iAsuuICPPvqIjz76iLKyMp544ommirlZFeK+c1ZWku/jSERE2q6YmBhGjBjB+++/7+tQGiaqB8T293UUIiJ+qVGJxdKlSzn55JO5+OKL61zn4osv5pRTTmHJkiWN2VWLKTZCACjKz/FxJCIibZtpmqSnp/s6jIa5fp6aQYmI1KFRiUVeXl69hgns1q0beXl5jdlViynFnViUFOT6NhARkTZs7dq1LF68uPVNpqekQkSkTo0aFSo+Pp61a9cecb1169YRHx/fmF21GEeAu9CwF+X6NhARkVbqH//4R52vFRYWsnXrVr755hvKy8u5+eabWzAyERFpTo1KLMaNG8err77KAw88wOOPP05AgHdnZ9M0eeihh9i8eTM33XRTowJtKY6ADu7/i1pHDYuIiL959NFHMQyjxkiB1YWGhnL//fczderUFoxMRESaU6MSi4ceeohPP/2U6dOnM3v2bC6//HK6d+8OwJ49e/joo4/YvXs3nTp14sEHH2yKeJtdeVAolKvztojI0XrjjTfqfM1qtZKQkMDw4cPp0KFDC0YlIiLNrVGJRWJiIgsWLOCqq67it99+46mnnvJMilR5p+q4447j3XffJTExsfHRtgBnUBiUg6tUiYWIyNG49tprfR2CiIj4QKNn3j7uuOPYsGEDixYtYsmSJezfvx+ALl26cNpppzF69OjG7qJFmdaOUAKmEgsRERERkXprdGJRafTo0XUmEa+//jp79+7l4YcfbqrdNRvD1tH9wF7g20BERFqpX375hXfeeYeJEycyfPjwWtdZtWoV77//PpMmTWLIkCEtG6CIiDSLRg03W1+vvPIKjz32WEvsqtEswWHu/8sKfRyJiEjr9Nxzz/HCCy94+tzVpkePHrzwwgs8//zzLReYiIg0qxZJLFqToJBwAAKVWIiIHJUlS5Zwwgkn0Llz5zrX6dy5MyeccAKLFy9uwchERKQ5KbE4RFBIBADW8iIfRyIi0jrt27fvsLUVlZKTkz398kREpPVTYnEIW0d3YmFzKbEQETkaNpuN3NzcI66Xn59fY/4jERFpvZRYHCKkgzuxCHEV+zgSEZHW6dhjj2Xp0qVkZ2fXuU52djY//vgjAwYMaMHIRESkOSmxOERoWKT7f4pxlLt8G4yISCt09dVXU1hYyPjx49m7d2+N1/ft28fll19OcXExV111lQ8iFBGR5tBkw822FR06ujtvh1FCXkkZncNsPo5IRKR1ufHGG5k9ezaLFi2iT58+nH322RxzzDEA7Nixg3nz5lFSUsIpp5zCLbfc4uNoRUSkqTQosWgPbWErh5sNNsrYW1ikxEJEpIECAwP55ptvuP3223nzzTeZO3eu1+sBAQFMnjyZZ599lsBA3d8SEWkrGvSLbprmUe/IMIyjfm+LsoV5Hhbm50JCtO9iERFppUJDQ3n11Vd5/PHHWbRoEampqQAkJSUxevRoEhISfByhiIg0tQYlFi5XO+hzEBBEKVaCcZCXmwX09HVEIiKtVkJCAhMnTvR1GCIi0gLUefsQJQ4nBWYIADO/W0+Jw+njiEREWheXy0V+fj5lZWV1rlNWVkZ+fn77uGElItJOKLE4xLaMAk9iUVacx5b0Ah9HJCLSujzzzDNERUUddlbtxYsXExUVxf/+978WjExERJqTXycWzz//PN27dyc4OJgRI0awatWqer3v/fffxzAMLrroogbvs3dsGCWWUADibA76xoUd4R0iIlLdnDlzSEpKYuzYsXWuM3bsWBITE/nkk0+Oah++KB9EROTw/Dax+OCDD5g6dSqPPPIIv/zyC4MHD2bcuHFkZGQc9n27d+/mb3/7G6eddtpR7TfEGkBUhHuSvOFxJiHWtj8SlohIU9q2bRvHHnvsEdcbOHAg27Zta/D2fVU+iIjI4fltYvH0009z0003MXnyZAYMGMDMmTMJDQ3l9ddfr/M9TqeTq666iscee4yePY+y07WjmNjCzQBclDETHJqBW0SkIfLy8oiouEFzOBEREeTk5DR4+z4rH0RE5LD8MrFwOBysWbPGqxrdYrEwduxYli9fXuf7/vGPfxAbG8sNN9xw9Ds/uIVAZwkAkWYeZGw6+m2JiLRDCQkJbNiw4YjrbdiwgdjY2AZt26flg4iIHJZfJhaZmZk4nU7i4uK8lsfFxZGWllbre5YuXcprr73GK6+8Uq992O128vPzvf4B0LkvzuBIAPLNEFyd+x31cYiItEdnnHEGmzZt4oMPPqhznQ8//JCNGzcyZsyYBm27JcoHOEwZISIidfLLxKKhCgoKuOaaa3jllVeIiYmp13umTZtGRESE519SUpL7BWsonH4vAD+7+pFdpllhRUQa4u6778ZqtTJp0iSmTJnChg0bKCoqoqioiA0bNjBlyhSuueYarFYrd999d7PGcjTlAxymjBARkTr55VVzTEwMAQEBpKeney1PT08nPj6+xvo7duxg9+7dnH/++Z5llWOjBwYGsmXLFo455hiv99x///1MnTrV8zw/P99TcAREJQPQycgjLa+UmI62pjkwEZF2oF+/frz11ltce+21vPjii7z44oter5umSXBwMG+88QYDBw5s0LZbonyAw5cRIiJSO7+ssbBarQwdOpT58+d7lrlcLubPn8/IkSNrrN+vXz9+/fVX1q1b5/l3wQUXMGbMGNatW1drYWCz2QgPD/f659HRXTjFGrkcyCtt+gMUEWnjLrvsMjZs2MDNN99Mr169sNls2Gw2evXqxa233sr69eu54oorGjxBXkuUD3CEMkJERGrllzUWAFOnTuXaa69l2LBhnHjiicyYMYOioiImT54MwKRJk+jatSvTpk0jODi4xl2vyMhIgAbfDQMgzN12tzN5pOUWNeo4RETaq169evHCCy/U+tratWuZOnUq77//Pvv372/Qdn1aPoiISJ38NrG44oorOHjwIA8//DBpaWkMGTKEb7/91tNhLyUlBYulmSpcOrhHKQkynORmpQMamlBEpLFSU1N59913eeedd9i0aROmaWIYRoO349PyQURE6mSYpmn6Ogh/kJ+fT0REBHl5eYSHh1Pyr2RCynJ5qufr3D3pUl+HJyJSL4f+lvlaQUEBH330Ee+88w4//vgjpmlimiZdu3bliiuuYOLEiQwdOtTXYR6Rv51XEZGj0dy/ZX5bY+FrjpBYQspyKTiYSonDqRm4RUTqyel08u233/L222/zxRdfUFpaSuU9LMMwWLRoEaeddtpR1VaIiIj/Ul1xHZyhnQEoyjrAuc/+SInD6eOIRET8288//8ztt99Oly5duOCCC/jwww8pLy/nggsu4KOPPmL48OEAjBo1SkmFiEgbpBqLOhRbY4jGPTLUrqxitqQXMCQp0tdhiYj4nX/+85+8++67bN261VMzcfLJJ3P11Vdz+eWXEx0dDcCMGTN8GKWIiDQ3JRZ1iInvBikQa+TQLTqUvnFhvg5JRMQvPfzwwxiGQXx8PH/+85+56qqr6N69u6/DEhGRFqamUHUIju4KQGcjl/9NPF59LEREDsM0TdLS0pg3bx7ff/89ubm5vg5JRERamBKLunR0D1vYwzhAXn6ej4MREfFfK1eu5LbbbqNTp04sXbqUW265hYSEBC699FI+/fRTysrKfB2iiIi0ACUWdQmJBOBYSwpDvjofHMW+jUdExE8NHz6c//3vf+zfv5/PPvuM8ePHYxgGc+bM4bLLLiMhIYGbb76Z9PR0X4cqIiLNSIlFXUoLPA/Di/dAxiYfBiMi4v8CAwM5//zz+eCDD0hLS+OVV17htNNOIycnh1deeYUdO3YAcN9997Fu3TrfBisiIk1OiUVdepzqeZgV1AVi+/swGBGR1iU8PJwbbriBRYsWsXv3bv71r3/Rr18/TNPkqaeeYujQofTv35/HH3/c16GKiEgTUWJRl9BO2APdI0E9G30/WEN9HJCISOuUlJTE/fffz++//87q1au5/fbbiY2NZcuWLTz66KO+Dk9ERJqIEovDKO/Yxf1/QbaPIxERaRtOOOEEnnnmGfbt28dXX33FhAkTfB2SiIg0ESUWhxOeAEBg8QEfByIi0rZYLBbOOecc3n33XV+HIiIiTUSJxWFYoxIBiCzLpMhe7uNoRERERET8lxKLwwiKdCcW8UY2afmlPo5GRERERMR/KbE4nIqmUHFGDml5SixEREREROqixOJwwtydtxOMbFKyNEGeiIiIiEhdlFgcRmloPABxRjZPzttMicPp44hERERERPyTEovD2Fbinseik1FAUXExW9ILjvAOEREREZH2SYnFYfTqloSdIAC6BeXTNy7MxxGJiIiIiPgnJRaHEWILxNnB3RxqSEQRIdYAH0ckIiIiIuKflFgcgRkWB0BoYaqPIxERERER8V9KLA7HUUxo1iYA7jDfwl6iPhYiIiIiIrVRYnE4GZswyooAdwfu3F0bfByQiIiIiIh/UmJxOLH9ITQGgCLTRmpQd9/GIyIiIiLip5RYHI41FP44A4AUM5Z9Rb4NR0RERETEXymxOJKYXgB0NbJIyyv1cTAiIiIiIv5JicWRRCQBEG4Uk5OT6eNgRERERET8kxKLI7F1pDQoEoDyrD2+jUVERERExE8psagHe4euABh5mstCRERERKQ2SizqwYx0N4cKLNhLicPp42hERERERPyPEot6sER2AyC6LI1znv1RyYWIiIiIyCGUWNRDnjUegK5GJruzitmSrhm4RURERESqU2JRD7Hd+gDuxCIhIpi+cWE+jkhERERExL8osagHW6dkALobafx9bDIh1gAfRyQiIiIi4l+UWNRHh84ARBjFjFpwITiKfRyQiIiIiIh/UWJRH/n7PQ/DS/ZCxiYfBiMiIiIi4n+UWNRHbH/KLTYA8gKiILa/jwMSEREREfEvSizqwxrK/sTzAFhoGwvWUB8HJCIiIiLiX5RY1JMRPwCACPteH0ciIiIiIuJ/lFjUU0hCPwC6lO/F5TJ9HI2IiIiIiH9RYlFP4YkDAejOAbILS3wcjYiIiIiIfwn0dQCthbVTN0qxEmw42LNvGzHhg30dkoiI+LmysjKcTqevw5BmYLFYCAoKwjAMX4ci4jeUWNSXJYD9AV3p6dyFuflrOKa3OnGLiEit8vPzyczMxG63+zoUaUYBAQGEhoYSGxuL1Wr1dTgiPqfEogFybIlQvIu+65/AlfIhlluXKbkQEREv+fn57Nu3j44dOxITE6O72m2QaZo4nU5KSkrIy8tj9+7dJCYmEhqqawJp35RYNIAzOBIqJt225OykdP9vBHc/0acxiYiIf8nMzKRjx44kJiYqoWjjOnbsSHR0NHv27CEzM5Nu3br5OiQRn1Ln7QY4ED3C83inK54tZpIPoxEREX9TVlaG3W4nIiJCSUU7ERAQQHR0NEVFRZSXl/s6HBGfUmLRAKeNOReActPCTUHT6dM11scRiYiIP6nsqB0UFOTjSKQl2Ww2ACUW0u4psWiA6C49KQ4IJ9BwMbBDjq/DERERP6XaivZFn7eImxKLhjAMSBgEQHDW75z1zGJKHBpGUEREREREiUUDFUQdC8BAYxepOSVsSS/wcUQiIiIiIr6nxKKBonoOA2C4ZTNdQlz0jQvzcUQiIiIiIr6nxKKBrHH9AOhn2ctnQfcSgiY/EhERqY1hGA3617179yaPoXv37uoDIdJC/DqxeP755+nevTvBwcGMGDGCVatW1bnuK6+8wmmnnUZUVBRRUVGMHTv2sOsfNWep52Fnxz7I2NT0+xARkcPyy/JBarj22mtr/DvmmGMAGDx4cI3Xxo8f7+OIRaQx/HaCvA8++ICpU6cyc+ZMRowYwYwZMxg3bhxbtmwhNrbmMK+LFi1i4sSJnHzyyQQHBzN9+nTOOussfv/9d7p27dp0gcUNxBVgw+K0c5BIYmL7ofsgIiItx2/LB6lh1qxZNZZdd9117Nixg4suuohHH3202WOYP38+ZWVlzb4fEfHjGounn36am266icmTJzNgwABmzpxJaGgor7/+eq3rv/vuu/z5z39myJAh9OvXj1dffRWXy8X8+fObNjBrKK5jLwXg4/JTyXL4bW4mItIm+W35IH7pmGOOoV+/fr4OQ6Rd8MvEwuFwsGbNGsaOHetZZrFYGDt2LMuXL6/XNoqLiykrKyM6OrrJ4wvsOgSAXsZ+tmcUNvn2RUSkdv5ePsjRmzVrFoZh8Oijj7J161YmTJhAXFwcFouFuXPnArB9+3YeffRRRo4cSXx8PFarlcTERCZNmsTWrVtr3W5tfSx2796NYRiMHj2akpIS7rvvPpKTk7HZbPTq1Yvp06djmmZzH7JIm+OXt9szMzNxOp3ExcV5LY+Li2Pz5s312sa9995Lly5dvAqf6ux2O3Z7Vcfr/Pz8+gcY5x5ytp+RyjtbMhicGEmINaD+7xcRkaPSEuUDNLKMkEbZsmULw4cPp1OnTowZM4acnBzPTOavvvoqTz75JAMHDmT48OHYbDY2btzI22+/zWeffcaSJUsYNGhQvfflcDg466yz2LhxI6NHj6aoqIjFixdz3333UVBQwD//+c/mOkyRNskvE4vGeuKJJ3j//fdZtGgRwcHBta4zbdo0HnvssaPbQewAAJIsB3lv8W9891saX98xSsmFiIifq0/5AI0sIw7DNE1Kypp2YtUSh5NtGQX0jg1r8nIoJCigxUdUev/995kyZQozZswgIMD7eC666CJuvvlmevTo4bX8jTfe4Prrr+fOO+9kwYIF9d7X8uXLOf3009m1axfh4eEArF69mpNOOolnnnmG++67j44dOzb+oETaCb9MLGJiYggICCA9Pd1reXp6OvHx8Yd97//93//xxBNP8MMPPxz2rsX999/P1KlTPc/z8/NJSkqqX4Ch0RRaY+noyKCPkcqarFC2pBcwJCmyfu8XEZGj0hLlAzSyjDiMkjInAx6e1+jttJSN/xhHqLVlLxU6d+7M9OnTayQVACeddFKt75k8eTKvvfYaixYtIi8vj4iIiHrty2Kx8NJLL3mSCoBhw4Zxzjnn8OWXX7J69WpGjx59VMch0h75ZWJhtVoZOnQo8+fP56KLLgLwdLSbMmVKne978skn+de//sW8efMYNmzYYfdhs9mw2WxHHaMtcRDs/IGxAb+QZuujifJERFpAS5QP0PgyQo7e2LFjCQ0NrfP1wsJCvvjiC9atW0d2drZnxKcDBw5gmiY7duzghBNOqNe+kpOT6du3b43lffr08WxTROrPLxMLgKlTp3LttdcybNgwTjzxRGbMmEFRURGTJ08GYNKkSXTt2pVp06YBMH36dB5++GHee+89unfvTlpaGgAdO3ZslmrMoNi+sPMHbg38gvOcq3HZR4E1/MhvFBGRRvH38uFwQoIC2PiPcU22vRKHk0te/Ik9WcUkdwrl01tPbtLmUCFBLd/Et1u3bnW+tmDBAiZMmMDBgwfrXKegoKDe+0pMTKx1eViY+2Zh9X42InJkfptYXHHFFRw8eJCHH36YtLQ0hgwZwrfffuvpsJeSkoLFUjWo1YsvvojD4agxuc4jjzzSPONkd6waK70bB7jhv+/x3N03qZ+FyBHsyy3hkzWpXHNSd6I6WH0djrRCfl8+HIZhGE3atCjUGsi3d4xiS3oBfeOavo+FL9TV96WwsJDLL7+c7OxsHn74YSZMmEBycjIhISEYhsGVV17J7NmzGzSaU/XviYg0nt8mFgBTpkyps2p70aJFXs93797d/AFVd/zVmD88ioHJPlcnlhXEqp+FyBGUOJycM+NH8kvLefOnPSy994w2cSEkLc+vy4cWFmINaBdlz5IlS8jKymL8+PG1dqzfuXOnD6ISkeqUqh+tDjG4+pwDwFeuEVisoepnIXIEW9ILyC8tByCryMGW9Po3WRCR9i0nJweovfnS9u3b+eWXX1o6JBE5hBKLRggY5K5WP8+yglibU3deRY6gb1yYp812REiQknERqbfKDtWffvqpVx+L3NxcbrjhBk8nbhHxHSUWjdF9FCYGXS3ZvGO/nYysbF9HJOLXQqwBDEp0DwN5weAEJeMiUm/Dhg3jzDPPJCUlhT59+nDxxRdz8cUX06NHD/bv38+FF17o6xBF2j0lFo2Rm4KBu5NYoiWTnRtX+zggEf9X5nQBUO7ycSAi0up89tln/P3vf6dz58588803rFmzhgkTJrBixQoiIyN9HZ5Iu2eYDRk+oQ3Lz88nIiKCvLw8r4lyDstRDE/3h9Jc8s0Q/tlvLo9dOlx3YUUO45xnl7DpQD4XH9+VZ64Y4utw2pyj+i2TI6rveS0tLWXXrl306NHjsDN7S9uiz11ai+YuI1Rj0RjWUDhnOgB7zFg+XJ/Fuc/+SInD6ePARPyXvcz991Fapr8TERGRtkSJRWN1OwmAvsZerJSxK6tYI92IHEZlQlGixEJERKRNUWLRWJHJuIKjsRpO+hkpdIvWsLMih1Na0blCNRYiIiJtixKLxjIMLF2PB+CcgJU8eUEv9bEQOYzKpoIlZeq9LSIi0pYosWgK8ccBcGvglxz7xXnuTt0iUoNpmpSWuxMLu2osRERE2hQlFk2hQ2fPw7CiPZCxyYfBiPgvh9NF5Th06mMhIiLStiixaAqDrqByzN7MgDiI7e/1clpeKf/33RZyix0tH5uIHymt1vxJfSxERETaFiUWTaFjZ3LjTwbgU8uZfLM1l3m/p1HicFLicDL26cU8t2A7f/jPYg1FK+1a9WRCfwsiIiJtS6CvA2grAvufB2k/MdK+lMveWUEpNhKjQvi/8YMotJcDkFXkYEt6AUOSIn0brIiPVE8sSjX1toiISJuiGosmEtjzdACOs+zmW+u9BGNnb04JW9IKPeuEWgM0FK20a9WbQjnKXThd5mHWFhERkdZEiUUTST2Y5Xnc3ZJBXyMVgMe/2uhZfkxMBw1FK+3aof0q7OVqDiUiItJWKLFoIkl9h5JPBwCKCGaLmQRAebU7shmFdp/EJuIvDh0JqlRzWYiIiLQZSiyaSEiHMGwT3nQ/Dg6hS3R4jXUy8u2UO3UhJe3XoTUWGnJWRESk7VBi0YRsvcdAcASW0hy+GR/KLaf39HrdBA6q1kLasUNrKDTkrEjbduWVV2IYBo8//vgR1121ahWGYRAXF0d5eXmD9nPddddhGAaLFi3yWj569GgMw2D37t313tasWbMwDINHH320QTGIiBKLphUQCL3GAmBb/xZ3jEokPiLY/ZLFANxzWoi0V4f2qdCQsyJt2zXXXAPAu+++e8R133nnHQAmTpxIYKAGrRRpjZRYNLWeY9z/r59NyHODWHjrccy97RQGdnE3jVJiIe3ZoYmEOm+LtG1nnXUWcXFxbNmyhZ9//rnO9crLy/nggw+AqmSkKbz11lts2rSJrl27Ntk2RaRuSiyaWnS15k8l2YS8PJIhcVa6RoUAkJavxELarxp9LBzqcyTSlgUEBDBx4kSgqkaiNt999x0ZGRn079+foUOHNtn+u3XrRr9+/QgKCmqybYpI3ZRYNLUux0N4l6rnxZmQsYm4cHeTKCUW0p4dOime+liItH1XX301AB988AFOZ+1/85VNpa6++mpyc3P53//+x7hx40hOTsZms9GpUyfOPvtsvv/++wbt+3B9LJYtW8bYsWMJCwsjMjKScePGsXLlyoYdnIh4UWLR1KyhcPMSCIl2Pw+wQmx/Eir6WqgplLRn9RkV6vf9eby9fI/6X4i0EUOHDqV///6kp6fXmhgUFRXx2WefYRgGV111FStWrOD2229n69at9O3bl4svvpi+ffvy3XffMW7cOF5//fVGx/Tll18yevRo5s+fz4ABAzjnnHNITU1l1KhRLF++vNHbF2mvlFg0hw4xcNNC92OnA5yOqhqLQxKLEoeTdam5uoiSdqHmPBY1O3Nf+NwyHvrsN856ZrH+LkTaiMp+E7U1h/r0008pKipi1KhRJCcn07dvX5YvX86uXbv47rvveP/99/npp59Ys2YNERER3HXXXRQWFh51LAUFBVx//fWUl5fz+uuvs3LlSmbPns3vv//OXXfdxcsvv3zU2xZp75RYNJfo7hB9jPtx6kriKxKLPVlFnoulbekFDP3n91z0/DLOffZHXURJm2c/wnCzmw/keyaVTM0pYUt6QYvFJtIiTBMcRU37r+gg7F7q/r+pt22aRz6merjqqqswDIO5c+dSVFTk9VplslHZZKpHjx6cdNJJNbZx/PHHc9ttt5Gfn8/ChQuPOpaPP/6YgwcPMmrUKCZPnuxZXjksbmJi4lFvW6S903huzSn5ZMjeAb99SvTw4wFIy7cz+qkF/HfiCcyYv5XiimRiV1YxW9ILGJIUCbjv3G5JL6BvXBgh1gBfHYFIkzo0kTh0Xov4yGDP49gwG33jwlokLpEWU1YM/+5y5PX8xQP7wdqh0Zvp1q0bo0aNYvHixcydO5errroKgPT0dObPn09wcDCXXXaZZ32n08n8+fP56aefOHDgAHa7ew6obdu2ef1/NJYsWQLAhAkTarwWFBTE+PHjmTFjxlFvX6Q9U2LRnLoOh7Vvw4b3Sdq9khHGRGKMfOYXDOWKl1d4rRpmC6BbVCgARaXlnPbUQrKLHPToFMrXd4xSciFtwpH6WBRXq7W7/Q+99b0XaUOuueYaFi9ezDvvvONJLGbPno3T6eSSSy4hIiICgL179/LHP/6R9evX17mtgoKjr83cv38/AMnJybW+3r1796Petkh7p8SiOYV19jwMzt/F+7Z/YwB7XLGMc0ynFBuhgVBcDgV2Jxe9sIx5d47itWU7yS5yADVrMtqyEoeTjfvzGNAlQheUbVRlImENtOAod9VINCq/96DJ86SNCgp11wI0lbJiePVMyNkFUT3gxu/d+2gqTbit8ePHM2XKFH744QcyMjKIjY31NIOqPnfFjTfeyPr167n00ku555576Nu3L2FhYVgsFl5++WVuvvlmzCZqoiUiTUuJRXPqMRqCI6E0FwCjYnGyJYO+RirrzV7YrEEUl5cBkJLtTiLW7Mn1bKJ7p9B20RykxOFk1FMLOVhgp3OYjR/vHqPkog2qbPoUGRJERoG9Ro1FVmFVYpFb4kCkzTGMJmla5GHtALf+BBmbILa/e2RCPxUREcEFF1zAhx9+yOzZsxk3bhxr1qwhJiaGs88+G3CPEPX9998TFxfHBx98QECAdzmwc+fORseRkJAAwJ49e2p9va7lInJk6rzdnKyh8OflYPHO30wgmjyCsZNTXEZoxQV0RHAgncNsLNue6Vn3jcnD28UF9pb0Ag4WuNvQHiyw1+i0q9Gz2obKGoqoUGvFc+8+FjnFjmqPy1ouMJHWzBoKiUP9OqmoVNlB+9133/XMXXHFFVd4JrDLy8vD5XKRkJBQI6koKytjzpw5jY7htNNOA+DDDz+s8Vp5eTmffPJJo/ch0l4psWhu+QfAVV71PCwBA3jD9h9+tN7B4KhyHhsdzR+MNfTtFMC3v6V5RsUBSMuz12s3LX3h3dT76xsXRoDhrtMJDrR41dJsPpDPcY/O0+hZbUDlBHmRoe6LiMM1hcpTYiHS5px99tnExMTw888/M3PmTMC7GVRsbCwRERH89ttvLFu2zLPc6XRy7733snXr1kbHcNlll9GpUycWLVrEm2++6VlumiaPPPIIKSkpjd6HSHulxKK5xfavGnY2+hg4+faqlyz5zDH+yvil5/Ca7T88k/knnv1mndfb92S5h+WrfiF/6EV9icPJyU/M56Lnl3FOHRfeJQ4nK3dmsXJn1hEvzI+UNBSWljPsX007TG5eSRnOijaz0R2tXrU0H6xO9SRblX1OpHUqdRxaY6GmUCLtSVBQkGc0pszMTHr37s2IESM8rwcGBnLPPfdQXl7O6aefzllnncWECRPo1asXM2fO5Lbbbmt0DGFhYbz22msEBARw3XXXcdJJJ3HllVcycOBAnnrqKW666aZG70OkvVIfi+ZmDYVblla1fwVY9l8oPACApfigZ9WuRhbjzGV8wcmUYgNgd1YxJQ4np0xfQHaRg7hwGwYGafmldIkMZv7U0cz7Pc3TbGR3LcPWzvs9jXs/WY+93H1xnhgVwvd3nV5rE6v0/FLOeuZH8krK6hyRat7vaRTZax8m92itS82tFoOdcqeLwAB33ltYWnXnukc76XPSFL797QBOl8kZ/eL8pjldaXlFYtHBXWNxaB+L7KKqGrqcoqapsdDQzSL+5ZprruG5554DqppGVffAAw+QmJjIjBkzWLZsGSEhIZx66qn84x//4JdffmmSGC688EIWLlzII488wqpVq9i0aRPDhw/n1VdfZcuWLbzyyitNsh+R9kaJRUuobP9a6dal8MJIKMqosepT1le41fUFVwf+h/3FBnuyivhyw35PE5H0/KoLr/25pWxJL+CrDQc8y6I7WD0X3iUOJ2P+bxFp+d6zfe+tmHistmTgtaU7yStxX9DVlTTYgqoquppqroH1e3M9j50ukwN5pSRFu9sL78ku8bz28a0n6+KwHtan5nLLO+4CuKFDFtd1Id4UF+iVNRSRddRYZFdr/lT5PWyMEoeTM/6ziAN5pXTvFMo3rXToZpfLZOn2gwQHBXBc18hWeQwilU488cQjjuo0adIkJk2aVGP5oEGDuO6662osnzVrFrNmzaqxfNGiRXXu47TTTmPBggU1lo8cObLWfYjIkakplC90iIE71kPyqZ5FdktVp7ueljSmneb+aLZnFPL3Ob/Wuam8Yjvfb0r3PD+lV7TnouPLDftrJBUAHW0BNZKBvTnFrE3JIbuwKnGpq3agejv40X07N8lFzi97cryep+YUex7vPFjoeZxVpOYx9VH9O9GQ5mPZhQ5O/PcPNZq5FZWW17q8oaqPCgVQUvG8svldZkHV97V6R+7DKXE4WbL1YK0xzVm7lwN57m3ubsB58LfBAt5duYdJr//M5S+tUD8jERHxW6qx8BVrKJxyB+xZCoDNVUyZaSHIcFFgBuOwdWaw8RNbMpJwVDSLqs1fZq/zev7bXveFU2p2Mfd9ssGzPDEqhD8OSmDm4p30jQv3SgbeWbGHB+f+Brg7ToN7aNxP/3xKrUnD/tyqi78VO7Mbdty1KCotZ9Uu93YCDAOnabI3uwSOcd+1zqzW7j4lq5g+ddSQ1HZHva677Ct3ZmEvdzG8e3SbvPtbWO1uf9fIkHrXKs1elUJBqXuwgeo1Vl9s2F/r8oYqOWRUKHuZu8/QSdPmk1dSRoDF8Kxb7HBiL3diC6z78ylxODl1+gKyihx07mjjx3uqhik+kFfi+V6Dd23e4Ww+kM8lL/5EscPpNxNU/rCxZqLYHua2ERGR1kU1Fr7U/VRPx25XVE+eDroVgDCjlLHfjeUz28MssE4lknzA3ezoUPml5V7PU7KL2JtTzBUvLcdZrab5P5cN5rzjugCwu6JDOICj3MXT31eNslE5ao8JpBd413Zs3J/HT9szSc2pen9KdjFb0+rfmXrnwUKW78j0uuO6cEs6laFWduCurLGoXltRub/alDicnPbkAq876j9tz2TgI9/WuMu+eGsGV7y8gkmvr6r17u/enGKe+GYTaXk1a3taix2ZVZ/R38/rV+8LY0u1X4Tqc6jkV0tUEiKCj6r5m8tl4jhkVKiSMidrU3I8zZ6cLu/mEUdqDrUlvcBTi3Ww0HuY4teX7qL65k45pn5J5NPfb/XMAO4vgwXsr/ZdbC9z24iISOujxMKXKjt237gAy63LuOOqCz0vVd637WLJYZ7tPt66eiDf3jGKrpHBAMRHVCUZkSGBvH/TCCJCAnGaMPqpRV4XIj06hTIoMZIend2TMmUVOTxDeX7wc4pX06bqtme4L+pTs4uZ+MoKzv3vUq58dSU/bPTuGzLxlRX1aprx2748zvjPYia+stLrgj6/tOq9URUXnKkVCcSOg0Ve26grsfj61wOemo3Ki8E3lu3yJFfVLxDnrq2a9fbQC8cSh5OzZyxh5uKdnDp9Pt/9nlbj2Fqimczv+/NYtDnjqPextdoxVa9hOpLcan0c3rlxhOdCfHO17d14ao+juoNvL6+asyKqQ1UfC2tgzZ8hW8Wy6vHUdt7dwxRXvaf6BffBQu+hmosc3nNm1GVzWr7ncXSHILpFtfzcANWP1V7uZFe1RPHtG0b4vAZFRESkNkosfK3axEbBXY+D6J4AmNU+mjgjlz5bnic6cxU//OVEPrv5BF45wyAY94VTbkk5wdZABnaNACDQVcpgYzvB2Hly/CBPU46OtkDiwt0JyY7MQvKKy3jsi411hrYjo4hiezl/eHoxy3dkeZZXv0AEd6JSeXG+eGsGL/+4o9YL4s/X7/M8rn5Bv/FAHgAXDunCQ38cALg7mENVjUVwRYfxvTm1JxZrU6r6aESFBtE3LoyUnKpO39X7i+yudpGWfMjd300H8im0u2uByl3wp7fXeA3hWzlC10XPL+OUJ+Y36uK/LlvTCjjvv0u5btbPh21PX1eCk1dc5tXJv3oN1ZGkV+uTU/3xhr15nsebGlBDVV31jtqVfSwKS8vZV+1zArAGWugSGQJUJRafrNnLoMfcc5mMfXqR55gL7eWe5DE8ONDrgntLmvu7c+7AeKDupLS6A3klpFQbLCC7qIxLXlzWbElkbZ9hdqGDE/9V1Z/l1715XnPbpGYX+10fEBEREVAfC/9iDYVblkHGJkptMRQ+fzqdcV8wx//6Evz6EiG2SAbjBHsBa4KD+U/ZpfwUcQF948LoGxfGmu37WWq7nRijgH1GPNH9V3tdbB3TuSPp+XY2Hyjg+QXbvS5YDrX9YCFvLt/jab5yqISIYE/H2IiQQHKKHFz3+s+YwNvL9/DdIUPaZhVU1YxUb/e/PtV90XrmgDiSKu4O78wspMTh9Nx5H9GjE4u3Hqz14rDM6eLr39I8z4MDLRQ7yj01LrZAC1/dfhoh1gBKy5z8vr/qjvSzE4Z4xXjoKEXgPYTvb/vzPDU82cVlXDfr53q1w2/IiEqfrt3reVxXe/rKpl+ZhY4aox1tzfC+8N+TdeQL6sr4DlSr6dqVWczQ5GgK7eXsqNYk7ddqSUZDVPavCLCAw+n+ThU5nDz6xe9e63XqYPU0lcotdrBwczp//Wi95/V9uaUs2JLOupRcBiVGepYfLHRQ7Cgn1BqIvdzJtorvzrUnd+fr39LYk1WE02V69eM4VGUC3SUi2FPrtzurmA17c7EGWugXH95ktQWZBXZGPbWQYofT8xmWljkZP/MnCuxV/VkWbz3o9b5vf0tj8qyfsZe7/KYPiIiICCix8D8VNRghAHf/SuqS10ha8UjV6/Zcz8MOlPJw0LuYzMPY/xbHREZzX+C7xBjuC6quZhr8/hHE9oUux4M1lJ6dO/DTjiwe//J3z4g8AGHBgZ7OuZ3DbBwssLMtvYDf91ftzxZoeObCMAyYd+coJry8go0H8pm1bDfJMaGevhKptQxpu6XaBe/UM/t4LvQ3HXBf6FdfN7uojLNmLOZARTOe3/a5L2ZTsosxTRPDqLo4/O73NLKLHESHBpJTXM6BfDtjn17saa9vL3dR6Cgn1BbIr/vyPBe1UDGzeVLV6V22IxOAk3pG89s+d+1FR1ugJwly1JJ4HKkz7c+7srn2jVX17gxcvVYmPjyYmA5WVu7MYlBi1TCjv+7L9TT9OnTuki0VNQoRIUHklZR5NaOpzfaMAv74v6WUlrkICqg6r5U1O7/vy8M0IcwWSIG9nG0ZBZ4L+IbIrRjlyemCG2b97Fmec8gM21GhVk+NRm5xGV/9eoBD3TF7HeUuk0NzhN2ZxQzoEs629ELKXSYRIUEM6x6NNdCCo9zFvpwSunWqu2nTj9vcF/FnDojjvVUplDlNYjtaueHNnym0O0mKCqmRMNfH+tRcHE4nA7tUfYazftrt6cuxO6uYVbsyuf399V79ShIigj3NFg0DTBPeWrHH87o6couIiD9RUyg/FtIhjKQz/gRRPQ67nlGcCbPOZeLyC7gu8AfvF7++C2adC8+fCI5iesZ0BPBKKp4cP4h7x/XzPD9zQBwAm9MK2HnQfZEbF27j8qGJnnViw2yEhwRx2TD3sjeX7+HZH7Z5Xq9sjlSpzOlia1rVXe/KO+AbD+RT7jKJ6Wila2QIBwuqmvCkZpd4alQqO+iWlrnYllHgaQayPaOAO95fB4C93PQkNoderKZU3LVftj3Ta3n1mc3X7M7m24qaj4uP78qLV50AgMvl4td97v2trZjIb2hylGcbiVHu2pfamqdsScvnuoqkAurXGXhtSlWNwHmD4jn9qYVc8fIKryZZRY6qTvudD5lLZNN+9/tP7xMDwP7cEn7afpCvfz3geX9ecRnPL9zGws3pTPt6s2cY2LJqPf53VZybXyqamY3oGU1smBWXCWsPGR64Pn5JyfU8Tsu311lzYA006BjsTloO5JXy866qZngVcyZ6vheHVrhVNvv6veIcHNslnACLQfdOVTVhlQ79vIrt5Xyx3p3EfPt7GqP7xgLwhwFxFFZMCJmaU8Ln6/bzf/O2UHTIwAl1eXnxDi58fhmXzfQeKnbbITVLd36wvkZn9RtP7cHmikRxeHJ0jW2rI7f/OtI8DdK26PMWcVONhb+zhsKtP8H+tVBeCl/9DXJ2QlgCBNogZ7dnVUtxzQn3PPJSYd9qhhTvIQ6TeCOHLWYSMVGRnD+oi1c7/KHdonhvZYrneTB24gu2Exca61mWEOFuA98rtmPVLkqqLrROP2R+i23phV41BZW1FKsrhpkd2CUCwzDoFx9OZEgQuYdcYCVHh7A3txSny+SsZ5YAkBQdwv7cEio3W+RwempbDrU7q5hju0Tw0uId7nNluC9K91S0Vx/91ELSq73v+YU7+Ob20zzNvS5/aQU9OoUSX3HcFw3pgtPpYt3ePG4/ozcAo55ayMECu2dm8zKniz/+dyll1a5+65obxDRNlm7LJL2glH25VW38Z69M9fQhqF4zsa5a8jFxeJLnXOcWO/hgtbsp1U87sggJNCgpN7ny1VXucxYVwrw7R3Hbe7+w9JAkq8Y5yyyixOHk2fnuhHH17mxPjdWf31vLivv/0KA79wWHzKDev2s4X2+oasJ2QrdIfknJZV1qHjsrOu1//EsqxWUu4iNsvHjVUFbuzOKJb7fU2HbnjlYOFjrYlVnEr3tzmV8xj8eAhHD3/mI6sDW9kF2ZRYzu6z15ZGUtxPs/p3hqudLz7Z6BBDYf8E4A7v3UPYzzR2tSWfS3MYc9BzlFDs/5g6rEcmCXcH6q1m8J3Mlw5fcyOMhCaZmLzWn5rN7j/hvZccgIaQCzJp+oZlB+JiDA/XmUlZUREhLi42ikpdjt7vIjMFCXVdK+qcaiNbCGQvdToNcf4NZlcOMC+MsvcOtyuPZLCOpQbeWKu8BRPSC0s/d23rqQE36awgrbX/jM9jALrVP57zmdCclYR6K1mBONjQw3NjHjm6r27MHYWWSbyme2h/nT+ssYbmwiGDsJEe7RqYYlR9PBFuBZt7LT+K7MYnAUw9414Cj23EEOs7l/dDcdKKAkfQdr589muLGJzanplDichFgD+PDmkV5h//WsPjw5fnCNoUhTs6uSCnA3G5l3xyhG96k67sCKu+IpWUXuO/YVd+YrN7Unq4jf9ud5JRXgbnK17WAhp/Tq5Fm2K6uY1buzCKOIUwI2MjzJfdGw8UA+W9ILPAlN5czmH65O8UoqAN6+seaIPiUOJ3/7cD3XvL6Kv33kvmitbJFUXK3pVYAFkio6Na+sdhd/X7VRn/719SbP3fzCwgL6Ord5OvmD+477v77ceMSkAtyJxSs/7vDUZuSWlHv6SeSVlPHq0to76ddlU8UF+tUjuvH1HaM4qUcnr9evHNHN87hyGOXUio7UJQ4X/eLDGVxHk5/KYZKfmreF859bxncVI5clV9RU9Kioqft5V7anP0nl5JGpOSWsT8nhzeVVTYx6dAplRGIIg43t7EpN4bqAb7gz4EOCqd653X7E2qf/fLeFomrnqEuke6jeX1JyKSgtJzIk0JPAhAQFeL6X957trkH8+tc0z7LaJoesT4d0aVlBQUHYbDby8vJ0F7udcDqdZGdn06FDByUW0u7pL6C1qRxFqlKP02DibHjrgooFJlzwPAy8xP10/1pY8wb8+hGY7ouvyu4JCZYc4j89DTDpCHxYMYJtqiOGV0KvpKS0BGfHBOId7mYv1uI0PrI9zn5XFG8GvwOOYkIyNvHGZT35dvYMpgZ+QkejlJ2ueK5J/weuGddiKT6IK6onGxNfBuCsAXF8snYfSQW/EPziJbxoAWyw1xnD1n3DGNwjgT7xYZzYPZpVu7MJxs7vK+dz1fET6NEplF3VOiJX7/PRJdzGl385jeiOVq4c0Y1FFR1eKy+yd2YWsWBTVY1OZU3E7kzveTgCLQblLtNTs/C3cf2Ys3Y/TpdJqGHnbstsJgV9T8DXJneGdOFt/sW61FzuGtvH62NKzS5idbXmQkEBBmVOk00HCkisNnxpsb2cU6YvqNF0KyjQgrPMu9O80wVnzVjMjAnHe81UXr35z0cVtRXBlPJT8F1Ek8dOVzznOqZRWjHR4rs/p3I4sRW1PkUOJ09Xa96WFB2CBYM92cUEY+eH77/hy9V9mXvnmfW6a/5rRT+Zs46NJ8QawOBqHa+DgyycOzCB5xdsZ1dWMVGhQV7nJK+krKK2JsrzPYgPt5Gbn09fI5UtpUlQy0SS/12wnfFDk0isSMi+/i2NTQd+5N2bTiIYO32NVLaaSUx5f62nz8rL1wzltG7BWP97LJfaCnGZePpyXBv4Hc+UXUq8JZe55un0c24Fx0BKsLFhby4ul8mQblGEWAPIyC/lnYqav8qaiMuGJrI2JZvnFrprzk7uFcN5xyVw23trcbrcn3d0ByujKpJjr6Qk3Mb+fO8EeFtGoWddj+w9iG/FxMSwb98+9u7dS0REBEFBQV79wqT1M00Tp9NJSUkJeXl5uFwuEhISfB2WiM8psWgLEoe7J9rL3uH+f+Al7gQE3DUdGO7EooKJBYOKJKOiV0L1Ii/Jksk/XP8FK5iumlX5XSw53PLb5ZhbDQxHIcOBE4OqXu9pSeM/5f+Hpdh9cW/J2UlYxvNcHxDKvM1nE2/JZ2bgDK99JloyiSEFcP8wn3NcPDt272SJ7U5C7Q4crzzDt2c8QmZ6CjN2dGHrgRy2lCcRDEwbUcY5x4URbC0HrJzWuzNdIoPZn1tKbJiN/IJ8Un9dwnbTvf7ZHbbxwGAnbyzbxdq8Xsxa7L5Yu3JEEn87sx8pOcXu0Zt2fktITgovTRjHje9t4qGAN5kYuMgTc4eS/fzRspxv953MpgPeIyVVnxH9yfGDWLUzi49/2ceaPTmePizlThe3z15LZPEezrFs5FPXaZ6L/9Iyl+fiunOYlYMVI2plFZVxzWurvPa1J6sI0zS59+OqmdavCfieaPI8n8fIjuksLHTXCJxlWUWykcHbzjM9+/P6fCOCKSzMpzepbDGTPOv83/jBDEqM5NOFy7n4p4sJNRzsKYzl67VfMW5wT36oaH6UEBHs1dEc8OpEflxsEOxdQ7+YPoQHlNHDtQdXVH9CbYF8c2UsKQfSWFWSwINf7fK8v3u4QT/nVoIZyNd3jGJLegHdQssJ+N8QIigghQQuKH2EZCOD7UYSRS53zAcL3LUKkaFVP3W7sopZsnEPP1j/RqIliz2uWMYVTgdsBGOnu30zId++CWXupkfVu4JEGcX8w/o2ALeaX2DMAmfHLozNf4x9DnfNYWyYjcV3j+HTldsYbGx3n0PTHc9zC7fz7Pyq7a3cme1pSueoaPPWvVMo3Tt18DSHArj/nH5cNjSJS19cxq6sYiJDgigtKaR090o4Ma7q7z03FV4+vcZnKi0rPNzdBC8zM5N9+/YdYW1pzQICAggNDSU2Nhar1errcER8zjBVVwtAfn4+ERER5OXleQqFVsVRDBmbILZ/1UVG9ddmnupOPMK7wjVz4a0LoWA/GJaKmgwDOMxXYdiNlP06hyB7Vt3r1EOmGUYIDjoYdkyzqvbEvY8boGMc9ByNPTuFPXP/SR9217mtPNOd9EQYFX0SIpPhzyvAGkrpntXkrPsCXC7C171EB8POHlcsEUYhkYZ385EDrkhuL/sLuZED+fyuirvve9fAq2cAUBbcmX/lj+NR6zu1xrHTFc8VxlMctAcQZgugwF6t+ZIBvz46ji9/PcA9H29gWHwAbw3cQFZZED9kd2Lz72uZFvQ6FgOyiGRi4DOEFKVSEtmH1EKDkjInYbYAojrYajR7qbzjvsVM4t8nW0hf9RG7XbHsNeP4m+1zjuf3ivhjKLh5DZe8upaY7F/4yPoPDAMyieRh699YkN+Fk4N3Y9gLyacDcUk9mZZ+K2FGKftd0dxd9ic6hYcx/fZrCbFn4nptHJaidE8cL5Wdy/6gJEodZaSZMaw0+xMa2pEZVxzP8B7u2a6Xbc/kqldX0jsqgO+tf4W8vRAcRVFpKR0oIdvSieh+p8LGzwAwbeFML7+SjqX7SA4q5DzbGiz2fLCFw/nPur84y55118hVKDWDCDbKSCOadywXUWK3k9ZxIM+c6gRXGed9F84AczsJ1lJO6hHB6F0zPO99t3w0ERRzRuB6QvGuFXCaVU3TDvddfKX8XA6akRiY3N0/m9Cd3xFiFrPPFc2zQTdiL8knz+zINjORGCPfk7R9euvJTHh5Bd1du+lMHkmDx/DE6aFMf+czVmcHsyuoN8se/iM2l53SlNXsS0vnYGY2A9c+REfDDhFJlJ79NAf3bCLx539RUFxKxBMFrfe3zE8dbRlRVlaG06n5Rtoii8Wi2ihpdZr7eleJRYVWn1gcyaGJR+XzqGTI2eP+/+AWKM6GL26Hkmzv90f1pOTKuRQ+P5rOHPJaRXJykOiarx3B/Y7rmdLjAF33fdPIA6ww4lZI3wi7Fzf4remuSEpGP0z36FD46X+Q8XuNdVwYWDAxA0Mxyqsu9K+z/40igjn3uARe22Klk+MAW8wkLLiYOz4KZ3RPHn/lAx4Keov+lrrvYJrWjhiOQkpDE7gm50Z+Nd0TJn58SSQlkX24a85W9uaU0Jls5tnuI9oopMC00hEHdZZtMX3h8rcoTdsC8/5OcJF3UyinxUaAq+pi2sS7BssjJAZKc8B01r0OkGV25EL7P0gwskkID+HRGy7lo2++44fNBzm1ewfuOHBfncfvj66y34uDIGZdPZAOX02BYnf/lHLTINA4+p/PA64o/hX8V54eHcQvP3zISa41ADgMG0Gm3XN+88wQOiQPJTDlJ+DIs4fn200lFs2gzZcRItIuKLFoISo0qnEUu+8E710NPzxctfzGBZRE9WHv7z9xzPJ7seTscteAXD8PCjMo6ZiE8fpZBOfvwmEGYDWcpBJPCKXEkFtjN7tdcZzteIKzIvbyX/tDh4/JGg4O90hSphGAYTbuDqCLACwc5TYueB56j8X87wkYZe7mPdVrXyovuovNIIKNcnciQt0X4odTaFoJMkxslEFINKUXv0bO6k/ovPVdAg9XwwRgCQJX2eHXaYTSIdcTvO71Wl/zOh/VHpcQSAj1G6bVpyyB4Con05rIqfmPEx4ezuK/jSEEO+xfy+xVKTz7i4PPbA8TZ+T6OlovSiyah8oIEWkLmvu3TKNCSU2Vo1CdeJO7zwa4/4/tT0iHMHqfOA7LrT+5R6eashoik9yT+kXGEjzlJ1b94SNOtD/PhfZ/cGbpNHZduYxt536I49R7vHZzd9lNlGLju7xESsOSq16wVLSHtwRV7fuOtXDd13Dd1/x2+RL2udwjCu1yxbFt3Nsw6t5aD8Ws2FaWq4PXcseE97nd9k+utt9DPh1qe6vb2U9ASLXRi6J6uvuwhMVjXPWhZ3H12oLKh6FGGZZa+rBUV2a6+yG4bBG1vt7RcLiTCoCSbILfu5iEre/UmVSUV9/T4ZKKs/55yGhi1d5W+bMQFu997NWFdyX4zL+TH1I1u2B5tZ8Tr/NR7bEnqQjphCuyOwD7XVFkUTEvSGQyhHepeGO1LmAR3WpfHtnd/ZkArsjubBv3Nq6IqtGlMKr6ebioelxmumPdSzz7iKtaJzLZ/T376xa4cQFfnvwhpdjIyLe756DABt1PIXLA6aQRw+n2Z7jM/iB7XLHVtu3ez25XLBmm+3M1q8VhNsHPrqviHOx3RZFhVhUMe1yxTLLfU9fbREREmpU6b0vdrKFwy9La+24cOjpVteXHjfgDUSt+ZH1WOD06hTKwewIh1kRwnAYbP4HsHbiielJgPw6ynSR0isK8ZRkcrOh83LlvVfOsnD1V++7gnvCtl8PJRR1fIDhnC/aovswZeiYwFn79oGpej8jucNELGJ37UnpwJ/vKYoj6+lIsOTsh+hiCe57K9L/+gS3pBQSF3QSvj4b8fe6LVrPi4jeqO5xwrftfZVv+ihnM3Y9P8HSaLzMNgiqaxVTvHF/FQmUzlvLwbtxVdC1pxeCI7M0HVyQQ3LknvHIG5O5xz1FSVupudnQE+UGdybEbJFsySKMT1slfEP3JZe5jieoBmO5zYgRAZS1PVE93f5bBE+Gl0yB/P67I7kxKn4CdIHI79OSLqxMJ7jLQvb5nDpWp7m2Fd4Wbf4QOMewc/x3/evVdwCDV7MyPnZ7AWrQfFxYsFcdb/dx4lGRhueJtSgnioJlEn9iOkLPV/VlDVTO9g1uqzvsRllti+9PbGgpDx1Z9Xp37eta1R/bm7hc/ID3fzjazK8lGBlvMJN6+/kSKc38nKTqE4G7Dqj7fDjH0tWdCRT+f6rNcx3Z0D7dcio2fzQFcG/ws317ekZTsEi7/NNuzbYC+RiqPX38+g4Lck+8Zkd3g9XE1vm8prs4E4qSLJRtXZHccZz9Fak4px6x62F07GNUDzvsPBAZjj+zNX174lKX5sQRYDAaY24kJtfLQn6/m9gMFfPbMEWoARUREmoFfN4V6/vnneeqpp0hLS2Pw4MH873//48QTT6xz/Y8++oiHHnqI3bt307t3b6ZPn865555br32pmrtpVc4V0DcuzHso0mp9PUqw1b7O0W6/sgkXeCcAtey7ztcOvWg9dL1DOYr5edVSbvoyi97GXsDg4UnncNw31S7uL3ze6wKXLsfXfuzV4ysrhpdGubcRmeyufcjfX9W8qWK7c9I7c/+c3zyduN+/7QyGxFmrtgOHP66Kfa4v68KFL/3iOay5t53CkEPnjKjl/JU4nJz77I/syiqmR6dQvv7zMEJytlLSMYl7X/yAA/l2SiN68fgpgdgoo+8vj7kvkqOPcSetRzq/TazE4WTD3lzu+WQDeypjvmNUnd+/GsdXsW715V3CbXx5+yiiO1q9llcfurjGPg75vi3bnskNP7gTv75GKv/40+UM7pHgve4h39vKv4FuUaFVI5lZA9rNb1lLlg+gMkJE2oZm/y0z/dT7779vWq1W8/XXXzd///1386abbjIjIyPN9PT0WtdftmyZGRAQYD755JPmxo0bzQcffNAMCgoyf/3113rtLy8vzwTMvLy8pjwMaQeK7eXm6CcXmMn3fmmOfnKBWWwvN017kWmmrnb/f7Sqb6PyceFBr+0W28vNUYfu+yiP4fSj3E6xvdxcm5JT4z21Lm+K89IE6oq5IeseaXlWgb1B+xj+z+8b/TmaZvv4LWvp8sE028d5FZG2r7l/y/y2xmLEiBEMHz6c5557DgCXy0VSUhJ/+ctfuO++mqPKXHHFFRQVFfHll196lp100kkMGTKEmTNnHnF/uhsljVFnDU0r2rcvj0Ga7vy3h9+yli4foH2cVxFp+9pl522Hw8GaNWsYO3asZ5nFYmHs2LEsX7681vcsX77ca32AcePG1bm+SFMKsQYwJCnSJxfkTbVvXx6D6PzXl8oHERH/5ZedtzMzM3E6ncTFxXktj4uLY/PmzbW+Jy0trdb109LSal3fbrdjt1eN3Z+X556lOD8/vzGhi4j4VOVvmJ9WRjdaS5QPoDJCRNqm5i4j/DKxaAnTpk3jscceq7E8KSmplrVFRFqXrKwsIiJqH8ZYjkxlhIi0Zc1VRvhlYhETE0NAQADp6eley9PT04mPj6/1PfHx8Q1a//7772fq1Kme5y6Xi+zsbDp16oRR5xTGUik/P5+kpCRSU1PV3riedM4aTues4fLy8ujWrRvR0dG+DqVZtET5ACojGkN/t0dH563hdM4arrnLCL9MLKxWK0OHDmX+/PlcdNFFgPtHff78+UyZMqXW94wcOZL58+dz5513epZ9//33jBw5stb1bTYbNpvNa1lkZGRThN+uhIeH64+5gXTOGk7nrOEsFr/sQtdoLVE+gMqIpqC/26Oj89ZwOmcN11xlhF8mFgBTp07l2muvZdiwYZx44onMmDGDoqIiJk+eDMCkSZPo2rUr06ZNA+COO+7g9NNP5z//+Q/nnXce77//PqtXr+bll1/25WGIiEgTU/kgIuKf/DaxuOKKKzh48CAPP/wwaWlpDBkyhG+//dbTAS8lJcUr2zr55JN57733ePDBB3nggQfo3bs3c+fOZeDAgb46BBERaQYqH0RE/JPfJhYAU6ZMqbNqe9GiRTWWXXbZZVx22WXNHJWAu5nAI488UqOpgNRN56zhdM4arr2cM5UP/qu9fAebms5bw+mcNVxznzO/nSBPRERERERaj7bZu09ERERERFqUEgsREREREWk0JRYiIiIiItJoSiykTo8++iiGYXj969evn+f10tJSbrvtNjp16kTHjh259NJLa0xC1db9+OOPnH/++XTp0gXDMJg7d67X66Zp8vDDD5OQkEBISAhjx45l27ZtXutkZ2dz1VVXER4eTmRkJDfccAOFhYUteBQt70jn7brrrqvx3Tv77LO91mlP523atGkMHz6csLAwYmNjueiii9iyZYvXOvX5e0xJSeG8884jNDSU2NhY7r77bsrLy1vyUKQNURlxZCojGk7lQ8P5UxmhxEIO69hjj+XAgQOef0uXLvW8dtddd/HFF1/w0UcfsXjxYvbv388ll1ziw2hbXlFREYMHD+b555+v9fUnn3yS//73v8ycOZOVK1fSoUMHxo0bR2lpqWedq666it9//53vv/+eL7/8kh9//JE//elPLXUIPnGk8wZw9tlne333Zs+e7fV6ezpvixcv5rbbbmPFihV8//33lJWVcdZZZ1FUVORZ50h/j06nk/POOw+Hw8FPP/3Em2++yaxZs3j44Yd9cUjSRqiMODyVEQ2n8qHh/KqMMEXq8Mgjj5iDBw+u9bXc3FwzKCjI/OijjzzLNm3aZALm8uXLWyhC/wKYc+bM8Tx3uVxmfHy8+dRTT3mW5ebmmjabzZw9e7Zpmqa5ceNGEzB//vlnzzrffPONaRiGuW/fvhaL3ZcOPW+maZrXXnuteeGFF9b5nvZ+3jIyMkzAXLx4sWma9ft7/Prrr02LxWKmpaV51nnxxRfN8PBw0263t+wBSJugMqJhVEY0nMqHo+PLMkI1FnJY27Zto0uXLvTs2ZOrrrqKlJQUANasWUNZWRljx471rNuvXz+6devG8uXLfRWuX9m1axdpaWle5ygiIoIRI0Z4ztHy5cuJjIxk2LBhnnXGjh2LxWJh5cqVLR6zP1m0aBGxsbH07duXW2+9laysLM9r7f285eXlARAdHQ3U7+9x+fLlHHfccZ5J5ADGjRtHfn4+v//+ewtGL22JyoijpzLi6Kl8ODxflhF+PUGe+NaIESOYNWsWffv25cCBAzz22GOcdtpp/Pbbb6SlpWG1WomMjPR6T1xcHGlpab4J2M9Unofqf6SVzytfS0tLIzY21uv1wMBAoqOj2/V5PPvss7nkkkvo0aMHO3bs4IEHHuCcc85h+fLlBAQEtOvz5nK5uPPOOznllFM8M0fX5+8xLS2t1u9i5WsiDaUyonFURhwdlQ+H5+syQomF1Omcc87xPB40aBAjRowgOTmZDz/8kJCQEB9GJm3dhAkTPI+PO+44Bg0axDHHHMOiRYv4wx/+4MPIfO+2227jt99+82rLLuILKiPEF1Q+HJ6vywg1hZJ6i4yMpE+fPmzfvp34+HgcDge5uble66SnpxMfH++bAP1M5Xk4dNSF6ucoPj6ejIwMr9fLy8vJzs7WeaymZ8+exMTEsH37dqD9nrcpU6bw5ZdfsnDhQhITEz3L6/P3GB8fX+t3sfI1kcZSGdEwKiOahsqHKv5QRiixkHorLCxkx44dJCQkMHToUIKCgpg/f77n9S1btpCSksLIkSN9GKX/6NGjB/Hx8V7nKD8/n5UrV3rO0ciRI8nNzWXNmjWedRYsWIDL5WLEiBEtHrO/2rt3L1lZWSQkJADt77yZpsmUKVOYM2cOCxYsoEePHl6v1+fvceTIkfz6669eBe73339PeHg4AwYMaJkDkTZNZUTDqIxoGu29fAA/KyOapPu5tEl//etfzUWLFpm7du0yly1bZo4dO9aMiYkxMzIyTPP/27u3kKjWN47jv9mWqR08VNSkOTZiXahZ3UlGlCVGUuiNFYQFBR2gJA9RUlZX3Wh0FQVRRAQFIV1lER0okiAwyoIoO+dQOSoMqGX17Iv9b9j+Z8zGcevezfcDC/F5D/OuhePDs8b1amZbtmyx1NRUu379ut2/f99yc3MtNzd3lFc9snw+nzU3N1tzc7NJsvr6emtubrbXr1+bmdnhw4ctISHBLl26ZA8fPrTVq1fbrFmzrKenxz9HYWGhzZ8/3+7du2d37tyxjIwMW7t27Wid0oj42XXz+XxWWVlpTU1N9vLlS7t27ZotWLDAMjIyrLe31z9HJF23rVu3Wnx8vN28edM8Ho//6O7u9vcZ7P349etXy8rKsoKCAnvw4IE1Njba1KlTbc+ePaNxSvgNkCMGR44IHfkhdP+mHEFhgQGVlpaa0+m06OhoS05OttLSUnv+/Lm/vaenx7Zt22aJiYkWFxdnxcXF5vF4RnHFI+/GjRsmKeAoKyszs7+2E9y3b59NmzbNxo0bZ/n5+fb06dN+c3i9Xlu7dq1NmDDBJk2aZBs3bjSfzzcKZzNyfnbduru7raCgwKZOnWpjx441l8tlmzdv7rcFnllkXbdg10qSnTp1yt/nV96Pr169shUrVlhsbKxNmTLFKioqrK+vb4TPBr8LcsTgyBGhIz+E7t+UIxz/WxAAAAAADBnPWAAAAAAIG4UFAAAAgLBRWAAAAAAIG4UFAAAAgLBRWAAAAAAIG4UFAAAAgLBRWAAAAAAIG4UFAAAAgLBRWCBiORyOQY8NGzaM9jIHdeDAATkcDp0+fXq0lwIAvwXyAzA0Y0Z7AcBoKysrG7AtLy9vBFcCAPg3IT8AoaGwQMTjTg4AIBjyAxAa/hQKAAAAQNgoLIAQOBwOpaWl6cuXL6qtrVV6erpiYmLkdru1f/9+9fb2Bh3n9XpVVVWljIwMxcTEKCkpSYWFhbp69eqAr+X1elVTU6Ps7GyNHz9ekyZNUnZ2tqqrq+XxeIKOefTokVatWqXExESNHz9eixcv1t27d4fl3AEAAyM/AJIMiFCSLNS3gCRLTU21oqIii42NtaKiIispKbH4+HiTZPn5+fb169d+Y969e2dut9s/trS01JYuXWpRUVEmyerr6wNe58mTJ5aSkmKSbPr06VZcXGzFxcWWmZlpkqyhocHft7a21iTZ9u3bLS4uzrKzs620tNRycnJMksXExNijR4+GdI0AIBKRH4ChobBAxBpq4pBkKSkp1tra6o9//PjRsrKyTJIdOXKk35iioiKTZOvWrbPPnz/747dv37a4uDiLioqy5uZmf7yvr8/mzJljkqy8vLzfGDOzlpYWe/78uf/7H4lDkh09erRf3/LycpNk69evD+k8ASCSkR+AoaGwQMT68cv2Z8ff7/z8fcyJEycC5rt8+bJJsvT0dH+stbXVJNmECRPM6/UGjNm1a5dJsk2bNvlj58+fN0mWmZkZcHcrmB+JY+HChQFt7e3tJslcLteg8wAA/kJ+AIaGXaEQ8X62nWBqamrQ+Jo1awJihYWFSkxMVGtrqzwej5xOp+7cueNvS0pKChizfv161dfX6/bt2/7YtWvXJEmbNm1SVFTUL59HQUFBQGzy5MlKSkoa8G9uAQADIz8AoaGwQMQLdTvBxMRETZw4MWiby+VSZ2en2tra5HQ61dbWJklKS0sL2v9H/P379/7Y27dvJUnp6ekhrSslJSVofOLEiero6AhpLgAA+QEIFbtCAaPI4XAM21x//MHbGQB+F+QH/BfxkwaEqLOzUz6fL2jbmzdvJEkzZszo9/X169dB+7969UqSlJyc7I/NnDlTktTa2jos6wUAjAzyAyIdhQUwBBcuXAiIXb16VR0dHXK73XI6nZKkvLw8SVJjY6O6uroCxpw9e1aStGjRIn9s2bJlkqSTJ0/q+/fvw710AMA/iPyASEZhAQzBwYMH/XeTJKm9vV1VVVWSpO3bt/vjbrdbK1eulM/n086dO9XX1+dva2pq0rFjxxQVFdVvTElJiWbPnq2WlhZVV1f3GyNJjx8/1osXL/6hMwMAhIP8gEjGw9uIeBs2bBiwLTU1VYcOHQqIzZ07V5mZmcrPz9fYsWN1/fp1dXV1acmSJdqxY0e//sePH9eiRYt05swZ3bp1S7m5ufr06ZNu3rypb9++qa6uTvPmzfP3HzNmjC5evKjly5errq5O586dU25ursxMz549U0tLixoaGuR2u4fzMgAA/g/5AQjRaO93C4wW/cI+5Tk5OQFjXC6X9fb22t69ey0tLc2io6PN5XJZTU2NdXd3B32t9vZ2q6iosPT0dIuOjraEhAQrKCiwK1euDLi+Dx8+WGVlpc2ePdtiYmIsPj7esrOzbffu3ebxePz9fuxTfurUqaDzuFyukP/REwBEMvIDMDQOM7ORK2OA/zaHwyGXy9XvY24AAMgPAM9YAAAAABgGFBYAAAAAwkZhAQAAACBsPGMBAAAAIGx8YgEAAAAgbBQWAAAAAMJGYQEAAAAgbBQWAAAAAMJGYQEAAAAgbBQWAAAAAMJGYQEAAAAgbBQWAAAAAMJGYQEAAAAgbH8CzA5suqKVNDUAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import matplotlib.pyplot as plt\n", "from numpy import linspace\n", @@ -832,27 +723,9 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Raw input:\n", - "tensor([[4.2900e+01, 1.3100e+01, 5.0000e+03, 2.1500e+02, 0.0000e+00],\n", - " [3.3600e+01, 1.1300e+01, 2.0000e+03, 2.1100e+02, 1.0000e+00]])\n", - "\n", - "Raw output:\n", - "tensor([[2.4082e-05, 4.3393e-06, 9.9997e-01],\n", - " [8.5355e-01, 6.9033e-06, 1.4644e-01]])\n", - "\n", - "Predicted species:\n", - "['Gentoo', 'Adelie']\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "from torch import no_grad\n", "\n", @@ -894,7 +767,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.2" } }, "nbformat": 4, From c07528baf5c07e65074de03b7ac6a55c78dbd3ce Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Thu, 4 Jul 2024 17:20:28 +0100 Subject: [PATCH 2/9] Add solution outputs --- .../01_penguin_classification_solutions.ipynb | 199 ++++++++++++++++-- 1 file changed, 179 insertions(+), 20 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index bfb814d..ffee52f 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -32,9 +32,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 60, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " bill_length_mm bill_depth_mm flipper_length_mm body_mass_g \\\n", + "count 342.000000 342.000000 342.000000 342.000000 \n", + "mean 43.921930 17.151170 200.915205 4201.754386 \n", + "std 5.459584 1.974793 14.061714 801.954536 \n", + "min 32.100000 13.100000 172.000000 2700.000000 \n", + "25% 39.225000 15.600000 190.000000 3550.000000 \n", + "50% 44.450000 17.300000 197.000000 4050.000000 \n", + "75% 48.500000 18.700000 213.000000 4750.000000 \n", + "max 59.600000 21.500000 231.000000 6300.000000 \n", + "\n", + " year \n", + "count 344.000000 \n", + "mean 2008.029070 \n", + "std 0.818356 \n", + "min 2007.000000 \n", + "25% 2007.000000 \n", + "50% 2008.000000 \n", + "75% 2009.000000 \n", + "max 2009.000000 \n", + "Index(['species', 'island', 'bill_length_mm', 'bill_depth_mm',\n", + " 'flipper_length_mm', 'body_mass_g', 'sex', 'year'],\n", + " dtype='object')\n" + ] + } + ], "source": [ "from palmerpenguins import load_penguins\n", "\n", @@ -107,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 61, "metadata": {}, "outputs": [], "source": [ @@ -195,9 +224,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 62, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 42.9000, 13.1000, 5000.0000, 215.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 46.1000, 13.2000, 4500.0000, 211.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 44.9000, 13.3000, 5100.0000, 213.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 43.3000, 13.4000, 4400.0000, 209.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 42.0000, 13.5000, 4150.0000, 210.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 46.5000, 13.5000, 4550.0000, 210.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 44.0000, 13.6000, 4350.0000, 208.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 40.9000, 13.7000, 4650.0000, 214.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 42.6000, 13.7000, 4950.0000, 213.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 42.7000, 13.7000, 3950.0000, 208.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 45.3000, 13.7000, 4300.0000, 210.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 47.2000, 13.7000, 4925.0000, 214.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 45.2000, 13.8000, 4750.0000, 215.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 43.6000, 13.9000, 4900.0000, 217.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 43.8000, 13.9000, 4300.0000, 208.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 45.5000, 13.9000, 4200.0000, 210.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 45.7000, 13.9000, 4400.0000, 214.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 43.3000, 14.0000, 4575.0000, 208.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 47.5000, 14.0000, 4875.0000, 212.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 46.2000, 14.1000, 4375.0000, 217.0000, 0.0000]) tensor([0., 0., 1.])\n" + ] + } + ], "source": [ "features = [\n", " \"bill_length_mm\",\n", @@ -252,9 +308,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 63, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 42.9000, 13.1000, 5000.0000, 215.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 46.1000, 13.2000, 4500.0000, 211.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 44.9000, 13.3000, 5100.0000, 213.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 43.3000, 13.4000, 4400.0000, 209.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 42.0000, 13.5000, 4150.0000, 210.0000, 0.0000]) tensor([0., 0., 1.])\n" + ] + } + ], "source": [ "from torchvision.transforms import Compose\n", "\n", @@ -300,9 +368,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 64, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([16, 5]) torch.Size([16, 3])\n", + "torch.Size([16, 5]) torch.Size([16, 3])\n", + "torch.Size([16, 5]) torch.Size([16, 3])\n", + "torch.Size([12, 5]) torch.Size([12, 3])\n" + ] + } + ], "source": [ "from torch.utils.data import DataLoader\n", "\n", @@ -340,9 +419,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FCNet(\n", + " (_fwd_seq): Sequential(\n", + " (0): BatchNorm1d(5, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (1): Linear(in_features=5, out_features=16, bias=True)\n", + " (2): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (3): Dropout(p=0.1, inplace=False)\n", + " (4): LeakyReLU(negative_slope=0.1)\n", + " (5): Linear(in_features=16, out_features=16, bias=True)\n", + " (6): BatchNorm1d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", + " (7): Dropout(p=0.1, inplace=False)\n", + " (8): LeakyReLU(negative_slope=0.1)\n", + " (9): Linear(in_features=16, out_features=3, bias=True)\n", + " )\n", + ")\n" + ] + } + ], "source": [ "from torch.nn import Module\n", "from torch.nn import BatchNorm1d, Linear, LeakyReLU, Dropout, Sequential\n", @@ -417,7 +517,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "metadata": {}, "outputs": [], "source": [ @@ -439,7 +539,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "metadata": {}, "outputs": [], "source": [ @@ -467,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 68, "metadata": {}, "outputs": [], "source": [ @@ -624,9 +724,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 69, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0-25 time: 11.470797 seconds\n", + "Epoch 25-50 time: 10.322494 seconds\n", + "Epoch 50-75 time: 8.206659 seconds\n", + "Epoch 75-100 time: 9.680337 seconds\n", + "Epoch 100-125 time: 9.795119 seconds\n", + "Epoch 125-150 time: 10.032203 seconds\n", + "Epoch 150-175 time: 9.441857 seconds\n", + "\n", + "\n", + " loss_train accuracy_train loss_valid accuracy_valid\n", + "0 0.630636 0.507353 0.607762 0.500000\n", + "1 0.535187 0.742647 0.533367 0.640625\n", + "2 0.464604 0.790441 0.462660 0.671875\n", + "3 0.409597 0.797794 0.404585 0.687500\n", + "4 0.352028 0.808824 0.362779 0.687500\n", + ".. ... ... ... ...\n", + "195 0.017349 0.992647 0.023540 0.984375\n", + "196 0.018951 0.988971 0.020961 0.984375\n", + "197 0.037160 0.985294 0.022133 0.984375\n", + "198 0.032350 0.988971 0.027387 0.984375\n", + "199 0.016947 0.992647 0.025869 0.984375\n", + "\n", + "[200 rows x 4 columns]\n" + ] + } + ], "source": [ "from time import perf_counter\n", "\n", @@ -676,9 +806,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 70, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "from numpy import linspace\n", @@ -723,9 +864,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 71, "metadata": {}, - "outputs": [], + "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([[7.7734e-06, 3.7739e-08, 9.9999e-01],\n", + " [9.9173e-01, 2.2448e-06, 8.2675e-03]])\n", + "\n", + "Predicted species:\n", + "['Gentoo', 'Adelie']\n", + "\n" + ] + } + ], "source": [ "from torch import no_grad\n", "\n", From 43b80d6cde9e46be644fe82db017d552629caa6e Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Thu, 4 Jul 2024 17:24:11 +0100 Subject: [PATCH 3/9] Add 'task 4' to exercises --- worked-solutions/01_penguin_classification_solutions.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index ffee52f..354aa95 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -196,10 +196,10 @@ " # 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", + " # Task 4 - 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", + " # Task 4 - Exercise #2: convert target to a 'one-hot' vector.\n", " target_names = sorted(self.full_df.species.unique())\n", " tgts = eye(len(target_names))[target_names.index(tgts[0])]\n", "\n", From 27d046429573395946cac804630288a368882bdd Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Thu, 4 Jul 2024 18:38:19 +0100 Subject: [PATCH 4/9] Add docstrings to class and re-add the Compose object approach as an n optional exercise --- exercises/01_penguin_classification.ipynb | 175 ++++++++++++- .../01_penguin_classification_solutions.ipynb | 241 ++++++++++++++---- 2 files changed, 357 insertions(+), 59 deletions(-) diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb index 95eb953..e219ac6 100644 --- a/exercises/01_penguin_classification.ipynb +++ b/exercises/01_penguin_classification.ipynb @@ -55,9 +55,13 @@ "source": [ "### Task 2: creating a ``torch.utils.data.Dataset``\n", "\n", + "The penguin data reading and processing can be encapsulated in a PyTorch dataset class.\n", + "\n", + "- Why is this helpful?\n", + "\n", "All PyTorch dataset objects are subclasses of the ``torch.utils.data.Dataset`` class. To make a custom dataset, create a class which inherits from the ``Dataset`` class, implement some methods (the Python magic (or dunder) methods ``__len__`` and ``__getitem__``) and supply some data.\n", "\n", - "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\n", + "Spoiler alert: we've done this for you already below (see ``src/ml_workshop/_penguins.py`` for a more sophisticated implementation)\n", "\n", "- Open the file ``src/ml_workshop/_penguins.py``.\n", "- Let's examine, and discuss, each of the methods together.\n", @@ -75,6 +79,117 @@ " - ``y_tfms``— ..." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List, Tuple, Any\n", + "\n", + "# import some useful functions here, see https://pytorch.org/docs/stable/torch.html\n", + "# where `tensor` and `eye` are used for constructing tensors,\n", + "# and using a lower-precision float32 is advised for performance\n", + "# Task 4: add imports here\n", + "# from torch import tensor, eye, float32\n", + "\n", + "from torch.utils.data import Dataset\n", + "\n", + "from palmerpenguins import load_penguins\n", + "\n", + "\n", + "class PenguinDataset(Dataset):\n", + " \"\"\"Penguin dataset class.\n", + "\n", + " Parameters\n", + " ----------\n", + " input_keys : List[str]\n", + " The column titles to use in the input feature vectors.\n", + " target_keys : List[str]\n", + " The column titles to use in the target feature vectors.\n", + " train : bool\n", + " If ``True``, this object will serve as the training set, and if\n", + " ``False``, the validation set.\n", + "\n", + " Notes\n", + " -----\n", + " The validation split contains 10 male and 10 female penguins of each\n", + " species.\n", + "\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " input_keys: List[str],\n", + " target_keys: List[str],\n", + " train: bool,\n", + " ):\n", + " \"\"\"Build ``PenguinDataset``.\"\"\"\n", + " self.input_keys = input_keys\n", + " self.target_keys = target_keys\n", + "\n", + " data = load_penguins()\n", + " data = (\n", + " data.loc[~data.isna().any(axis=1)]\n", + " .sort_values(by=sorted(data.keys()))\n", + " .reset_index(drop=True)\n", + " )\n", + " # Transform the sex field into a float, with male represented by 1.0, female by 0.0\n", + " data.sex = (data.sex == \"male\").astype(float)\n", + " self.full_df = data\n", + "\n", + " valid_df = self.full_df.groupby(by=[\"species\", \"sex\"]).sample(\n", + " n=10,\n", + " random_state=123,\n", + " )\n", + " # The training items are simply the items *not* in the valid split\n", + " train_df = self.full_df.loc[~self.full_df.index.isin(valid_df.index)]\n", + "\n", + " self.split = {\"train\": train_df, \"valid\": valid_df}[\n", + " \"train\" if train is True else \"valid\"\n", + " ]\n", + "\n", + " def __len__(self) -> int:\n", + " \"\"\"Return the length of requested split.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " The number of items in the dataset.\n", + "\n", + " \"\"\"\n", + " return len(self.split)\n", + "\n", + " def __getitem__(self, idx: int) -> Tuple[Any, Any]:\n", + " \"\"\"Return an input-target pair.\n", + "\n", + " Parameters\n", + " ----------\n", + " idx : int\n", + " Index of the input-target pair to return.\n", + "\n", + " Returns\n", + " -------\n", + " in_feats : Any\n", + " Inputs.\n", + " target : Any\n", + " Targets.\n", + "\n", + " \"\"\"\n", + " # get the row index (idx) from the dataframe and\n", + " # select relevant column features (provided as input_keys)\n", + " feats = tuple(self.split.iloc[idx][self.input_keys])\n", + "\n", + " # this gives a 'species' i.e. one of ('Gentoo',), ('Chinstrap',), or ('Adelie',)\n", + " tgts = tuple(self.split.iloc[idx][self.target_keys])\n", + "\n", + " # Task 4 - Exercise #1: convert the features to PyTorch Tensors\n", + "\n", + " # Task 4 - Exercise #2: convert target to a 'one-hot' vector.\n", + "\n", + " return feats, tgts" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -97,8 +212,6 @@ "metadata": {}, "outputs": [], "source": [ - "from ml_workshop import PenguinDataset\n", - "\n", "data_set = PenguinDataset(\n", " input_keys=[\"bill_length_mm\", \"body_mass_g\"],\n", " target_keys=[\"species\"],\n", @@ -107,7 +220,7 @@ "\n", "\n", "for features, target in data_set:\n", - " # print the features and targets here\n", + " # print the features and targets her\n", " pass" ] }, @@ -117,7 +230,12 @@ "source": [ "- Can we give these items to a neural network, or do they need to be transformed first?\n", " - Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n", - " - We must represent these data as ``torch.Tensor``s." + " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html).\n", + " - The targets are tuples of strings i.e. ('Gentoo', )\n", + " - One idea is to represent as ordinal values i.e. [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n", + " \"A\" — [1, 0, 0]\\\n", + " \"B\" — [0, 1, 0]\\\n", + " \"C\" — [0, 0, 1]" ] }, { @@ -126,19 +244,50 @@ "source": [ "### Task 4: Applying transforms to the data\n", "\n", - "A common way of transforming inputs to neural networks is to apply a series of transforms using ``torchvision.transforms.Compose``. The [``Compose``](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects (i.e., functions) and applies them to the incoming data.\n", + "Modify the `PenguinDataset` class above so that the tuples of numbers are converted to PyTorch `torch.Tensor` s and the string targets are converted to one-hot vectors.\n", + "\n", + "- Begin by importing relevant PyTorch functions.\n", + "- Apply transformations inside `__getitem__()` function above.\n", + "\n", + "Then create a training and validation set.\n", + "\n", + " - We allow the model to learn directly from the training set—i.e. we fit the function to these data.\n", + " - During training, we monitor the model's performance on the validation set in order to check how it's doing on unseen data. Normally, people use the validation performance to determine when to stop the training process.\n", + " \n", + "For the validation set, we choose ten males and ten females of each species. This means the validation set is less likely to be biased by sex and species, and is potentially a more reliable measure of performance. You should always be _very_ careful when choosing metrics and splitting data.\n", + "\n", + "- Is this solution general?\n", "\n", - "These transforms can be very useful for mapping between file paths and tensors of images, etc.\n", + "A common way of transforming inputs to neural networks is to apply a series of transforms using `torchvision.transforms.Compose`. The [ `Compose` ](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects and applies them to the incoming data. See how this is done more generally in the `src/ml_workshop/_penguins.py` file. \n", "\n", - "- Note: here we create a training and validation set.\n", - " - We allow the model to learn directly from the training set — i.e. we fit the function to these data.\n", - " - During training, we monitor the model's performance on the validation set in order to check how it's doing on unseen data. Normally, people use the validation performance to determine when to stop the training process.\n", - "- For the validation set, we choose ten males and ten females of each species. This means the validation set is less likely to be biased by sex and species, and is potentially a more reliable measure of performance. You should always be _very_ careful when choosing metrics and splitting data." + "These transforms can be very useful for mapping between file paths and tensors of images, etc.\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Apply transforms to the data. See Task 4 exercise comments above.\n", + "\n", + "# Create train_set\n", + "\n", + "# Create valid_set\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### (Optional) Task 4b: \n", + "\n", + "Apply the `torchvision.transforms.Compose` transformations instead of hardcoding as above. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -417,7 +566,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.12.2" } }, "nbformat": 4, diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 354aa95..50fc762 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -136,24 +136,42 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "from typing import Optional, List, Dict, Tuple, Any\n", + "from typing import List, Tuple, Any\n", "\n", - "# import pytorch functions necessary for transformations:\n", + "# import some useful functions here, see https://pytorch.org/docs/stable/torch.html\n", + "# where `tensor` and `eye` are used for constructing tensors,\n", + "# and using a lower-precision float32 is advised for performance\n", "from torch import tensor, float32, eye\n", "\n", "from torch.utils.data import Dataset\n", - "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", + " \"\"\"Penguin dataset class.\n", + "\n", + " Parameters\n", + " ----------\n", + " input_keys : List[str]\n", + " The column titles to use in the input feature vectors.\n", + " target_keys : List[str]\n", + " The column titles to use in the target feature vectors.\n", + " train : bool\n", + " If ``True``, this object will serve as the training set, and if\n", + " ``False``, the validation set.\n", + "\n", + " Notes\n", + " -----\n", + " The validation split contains 10 male and 10 female penguins of each\n", + " species.\n", + "\n", + " \"\"\"\n", + "\n", " def __init__(\n", " self,\n", " input_keys: List[str],\n", @@ -186,9 +204,32 @@ " ]\n", "\n", " def __len__(self) -> int:\n", + " \"\"\"Return the length of requested split.\n", + "\n", + " Returns\n", + " -------\n", + " int\n", + " The number of items in the dataset.\n", + "\n", + " \"\"\"\n", " return len(self.split)\n", "\n", " def __getitem__(self, idx: int) -> Tuple[Any, Any]:\n", + " \"\"\"Return an input-target pair.\n", + "\n", + " Parameters\n", + " ----------\n", + " idx : int\n", + " Index of the input-target pair to return.\n", + "\n", + " Returns\n", + " -------\n", + " in_feats : Any\n", + " Inputs.\n", + " target : Any\n", + " Targets.\n", + "\n", + " \"\"\"\n", " # get the row index (idx) from the dataframe and\n", " # select relevant column features (provided as input_keys)\n", " feats = tuple(self.split.iloc[idx][self.input_keys])\n", @@ -196,7 +237,7 @@ " # this gives a 'species' i.e. one of ('Gentoo',), ('Chinstrap',), or ('Adelie',)\n", " tgts = tuple(self.split.iloc[idx][self.target_keys])\n", "\n", - " # Task 4 - Exercise #1: convert the feats (Series) to PyTorch Tensors\n", + " # Task 4 - Exercise #1: convert the features to PyTorch Tensors\n", " feats = tensor(feats, dtype=float32)\n", "\n", " # Task 4 - Exercise #2: convert target to a 'one-hot' vector.\n", @@ -224,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -281,9 +322,9 @@ "source": [ "* Can we give these items to a neural network, or do they need to be transformed first?\n", " + Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n", - " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html)\n", - " + The targets are tuples of strings i.e. ('Gentoo', )\n", - " - One idea is to represent as ordinal values i.e. [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n", + " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html) . \n", + " - The targets are tuples of strings i.e. ('Gentoo', )\n", + " - One idea is to represent as ordinal values i.e. [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n", " \"A\" — [1, 0, 0]\\\n", " \"B\" — [0, 1, 0]\\\n", " \"C\" — [0, 0, 1]\n" @@ -295,20 +336,76 @@ "source": [ "### Task 4: Applying transforms to the data\n", "\n", - "- Here we create a training and validation set.\n", - " - We allow the model to learn directly from the training set—i.e. we fit the function to these data.\n", - " - During training, we monitor the model's performance on the validation set in order to check how it's doing on unseen data. Normally, people use the validation performance to determine when to stop the training process.\n", - "- For the validation set, we choose ten males and ten females of each species. This means the validation set is less likely to be biased by sex and species, and is potentially a more reliable measure of performance. You should always be _very_ careful when choosing metrics and splitting data.\n", + "Modify the `PenguinDataset` class above so that the tuples of numbers are converted to PyTorch `torch.Tensor` s and the string targets are converted to one-hot vectors.\n", + "\n", + "- Begin by importing relevant PyTorch functions.\n", + "- Apply transformations inside `__getitem__()` function above.\n", + "\n", + "Then create a training and validation set.\n", "\n", + " - We allow the model to learn directly from the training set—i.e. we fit the function to these data.\n", + " - During training, we monitor the model's performance on the validation set in order to check how it's doing on unseen data. Normally, people use the validation performance to determine when to stop the training process.\n", + " \n", + "For the validation set, we choose ten males and ten females of each species. This means the validation set is less likely to be biased by sex and species, and is potentially a more reliable measure of performance. You should always be _very_ careful when choosing metrics and splitting data.\n", "\n", - "Note: A common way of transforming inputs to neural networks is to apply a series of transforms using ``torchvision.transforms.Compose``. The [``Compose``](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects and applies them to the incoming data. See how this is done more generally in the `src/ml_workshop/_penguins.py` file. \n", + "- Is this solution general?\n", + " - No. The transformations have been hardcoded. A more flexible way of transforming inputs to neural networks is to apply a series of transforms using `torchvision.transforms.Compose`. The [ `Compose` ](https://pytorch.org/vision/stable/generated/torchvision.transforms.Compose.html) object takes a list of callable objects and applies them to the incoming data. See how this is done more generally in the `src/ml_workshop/_penguins.py` file. \n", "\n", "These transforms can be very useful for mapping between file paths and tensors of images, etc." ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([ 42.9000, 13.1000, 5000.0000, 215.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 46.1000, 13.2000, 4500.0000, 211.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 44.9000, 13.3000, 5100.0000, 213.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 43.3000, 13.4000, 4400.0000, 209.0000, 0.0000]) tensor([0., 0., 1.])\n", + "tensor([ 42.0000, 13.5000, 4150.0000, 210.0000, 0.0000]) tensor([0., 0., 1.])\n" + ] + } + ], + "source": [ + "# Apply the transforms we need to the PenguinDataset to get out input\n", + "# targets as Tensors. See Task 4 exercise comments above.\n", + "\n", + "# Create train_set\n", + "train_set = PenguinDataset(\n", + " input_keys=features,\n", + " target_keys=[\"species\"],\n", + " train=True,\n", + ")\n", + "\n", + "# Create valid_set\n", + "valid_set = PenguinDataset(\n", + " input_keys=features,\n", + " target_keys=[\"species\"],\n", + " train=False,\n", + ")\n", + "\n", + "\n", + "for _, (input_feats, target) in zip(range(5), train_set):\n", + " print(input_feats, target)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### (Optional) Task 4b: \n", + "\n", + "Apply the `torchvision.transforms.Compose` transformations instead of hardcoding as above. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -326,15 +423,65 @@ "source": [ "from torchvision.transforms import Compose\n", "\n", + "from ml_workshop import PenguinDataset\n", + "\n", "# import some useful functions here, see https://pytorch.org/docs/stable/torch.html\n", "# where `tensor` and `eye` are used for constructing tensors,\n", "# and using a lower-precision float32 is advised for performance\n", "from torch import tensor, float32, eye\n", "\n", + "\n", + "# Apply the transforms we need to the PenguinDataset to get out input\n", + "# targets as Tensors.\n", + "\n", + "\n", + "def get_input_transforms() -> Compose:\n", + " \"\"\"Return transforms which map from raw inputs to tensors.\n", + "\n", + " Returns\n", + " -------\n", + " Compose\n", + " A composition of transforms (callable functions) to map the tuple\n", + " of input features (``Tuple[float, ...]``) to a ``torch.Tensor``.\n", + "\n", + " Notes\n", + " -----\n", + " To create a ``torch.Tensor`` we can use ``torch.tensor([1.0, 2.0, ...])``\n", + "\n", + " \"\"\"\n", + " return Compose([lambda x: tensor(x, dtype=float32)])\n", + "\n", + "\n", + "def get_target_tfms() -> Compose:\n", + " \"\"\"Return transforms which map from the raw target strings to tensor.\n", + " Returns\n", + " -------\n", + " Compose\n", + " A composition of transforms (callable functions) to map the tuple\n", + " of input features (``Tuple[str]``) to a ``torch.Tensor``.\n", + "\n", + " Notes\n", + " -----\n", + " Suppose we have three labels, \"A\", \"B\" and \"C\". We want to encoder each\n", + " distinct label as a one-hot-encoded vector. A natural way to do this is:\n", + " - \"A\" — [1, 0, 0]\n", + " - \"B\" — [0, 1, 0]\n", + " - \"C\" — [0, 0, 1]\n", + "\n", + " The transforms this function produces will return these vectors as tensors.\n", + " Note also, in the example we have just given, A's vector was the first row\n", + " in the identity matrix, B's the second, etc.\n", + "\n", + " \"\"\"\n", + " return Compose([lambda x: eye(len(target_names))[target_names.index(x[0])]])\n", + "\n", + "\n", "train_set = PenguinDataset(\n", " input_keys=features,\n", " target_keys=[\"species\"],\n", " train=True,\n", + " x_tfms=get_input_transforms(),\n", + " y_tfms=get_target_tfms(),\n", ")\n", "\n", "\n", @@ -342,6 +489,8 @@ " input_keys=features,\n", " target_keys=[\"species\"],\n", " train=False,\n", + " x_tfms=get_input_transforms(),\n", + " y_tfms=get_target_tfms(),\n", ")\n", "\n", "\n", @@ -368,7 +517,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -419,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -517,7 +666,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -539,7 +688,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -567,7 +716,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -724,34 +873,34 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0-25 time: 11.470797 seconds\n", - "Epoch 25-50 time: 10.322494 seconds\n", - "Epoch 50-75 time: 8.206659 seconds\n", - "Epoch 75-100 time: 9.680337 seconds\n", - "Epoch 100-125 time: 9.795119 seconds\n", - "Epoch 125-150 time: 10.032203 seconds\n", - "Epoch 150-175 time: 9.441857 seconds\n", + "Epoch 0-25 time: 8.108920 seconds\n", + "Epoch 25-50 time: 8.245825 seconds\n", + "Epoch 50-75 time: 7.894095 seconds\n", + "Epoch 75-100 time: 8.292500 seconds\n", + "Epoch 100-125 time: 7.116918 seconds\n", + "Epoch 125-150 time: 6.541059 seconds\n", + "Epoch 150-175 time: 7.708282 seconds\n", "\n", "\n", " loss_train accuracy_train loss_valid accuracy_valid\n", - "0 0.630636 0.507353 0.607762 0.500000\n", - "1 0.535187 0.742647 0.533367 0.640625\n", - "2 0.464604 0.790441 0.462660 0.671875\n", - "3 0.409597 0.797794 0.404585 0.687500\n", - "4 0.352028 0.808824 0.362779 0.687500\n", + "0 0.614220 0.452206 0.668509 0.375000\n", + "1 0.524949 0.698529 0.527703 0.703125\n", + "2 0.460917 0.786765 0.463121 0.781250\n", + "3 0.380868 0.886029 0.396204 0.828125\n", + "4 0.347903 0.878676 0.337664 0.859375\n", ".. ... ... ... ...\n", - "195 0.017349 0.992647 0.023540 0.984375\n", - "196 0.018951 0.988971 0.020961 0.984375\n", - "197 0.037160 0.985294 0.022133 0.984375\n", - "198 0.032350 0.988971 0.027387 0.984375\n", - "199 0.016947 0.992647 0.025869 0.984375\n", + "195 0.050222 0.966912 0.013005 0.984375\n", + "196 0.036788 0.985294 0.012601 1.000000\n", + "197 0.033748 0.970588 0.011316 1.000000\n", + "198 0.038716 0.988971 0.020271 0.984375\n", + "199 0.015950 0.988971 0.019603 0.984375\n", "\n", "[200 rows x 4 columns]\n" ] @@ -806,12 +955,12 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -864,7 +1013,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -876,8 +1025,8 @@ " [3.3600e+01, 1.1300e+01, 2.0000e+03, 2.1100e+02, 1.0000e+00]])\n", "\n", "Raw output:\n", - "tensor([[7.7734e-06, 3.7739e-08, 9.9999e-01],\n", - " [9.9173e-01, 2.2448e-06, 8.2675e-03]])\n", + "tensor([[8.2419e-07, 8.8322e-09, 1.0000e+00],\n", + " [6.8586e-01, 4.3171e-06, 3.1413e-01]])\n", "\n", "Predicted species:\n", "['Gentoo', 'Adelie']\n", From c50409cbbab3165f9104d7570ea16a10f53346a0 Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Thu, 4 Jul 2024 18:42:12 +0100 Subject: [PATCH 5/9] Add e --- exercises/01_penguin_classification.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb index e219ac6..5adb10c 100644 --- a/exercises/01_penguin_classification.ipynb +++ b/exercises/01_penguin_classification.ipynb @@ -220,7 +220,7 @@ "\n", "\n", "for features, target in data_set:\n", - " # print the features and targets her\n", + " # print the features and targets here\n", " pass" ] }, @@ -265,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -287,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ From da3e1aebbed772f8a512295b5046da288e36c8d9 Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Fri, 5 Jul 2024 09:38:23 +0100 Subject: [PATCH 6/9] Improve task 2 text --- exercises/01_penguin_classification.ipynb | 2 +- worked-solutions/01_penguin_classification_solutions.ipynb | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb index 5adb10c..ea9f855 100644 --- a/exercises/01_penguin_classification.ipynb +++ b/exercises/01_penguin_classification.ipynb @@ -57,7 +57,7 @@ "\n", "The penguin data reading and processing can be encapsulated in a PyTorch dataset class.\n", "\n", - "- Why is this helpful?\n", + "- Why is a class representation helpful?\n", "\n", "All PyTorch dataset objects are subclasses of the ``torch.utils.data.Dataset`` class. To make a custom dataset, create a class which inherits from the ``Dataset`` class, implement some methods (the Python magic (or dunder) methods ``__len__`` and ``__getitem__``) and supply some data.\n", "\n", diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 50fc762..17735f2 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -110,15 +110,14 @@ "\n", "The penguin data reading and processing can be encapsulated in a PyTorch dataset class.\n", "\n", - "- Why is this class representation helpful?\n", + "- Why is a class representation helpful?\n", " - Modularity - Separation of concerns makes the cde easier to understand, maintain and test.\n", " - Maintainability - Changes are localised, therefore we only need to change a single file to update. \n", " - Abstraction - Users do not need to know how the data is read or processed, they only need to know how to interact with the class. \n", "\n", - "\n", "All PyTorch dataset objects are subclasses of the ``torch.utils.data.Dataset`` class. To make a custom dataset, create a class which inherits from the ``Dataset`` class, implement some methods (the Python magic (or dunder) methods ``__len__`` and ``__getitem__``) and supply some data.\n", "\n", - "Spoiler alert: we've done this for you already in ``src/ml_workshop/_penguins.py``.\n", + "Spoiler alert: we've done this for you already below (see ``src/ml_workshop/_penguins.py`` for a more sophisticated implementation)\n", "\n", "- Open the file ``src/ml_workshop/_penguins.py``.\n", "- Let's examine, and discuss, each of the methods together.\n", From 51d17eb91e0fb04550bf52fed16d46b5f7591d48 Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Fri, 5 Jul 2024 15:26:35 +0100 Subject: [PATCH 7/9] Improve task 3 text and remove x_tfms and y_tfms comments --- exercises/01_penguin_classification.ipynb | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb index ea9f855..2e83dc8 100644 --- a/exercises/01_penguin_classification.ipynb +++ b/exercises/01_penguin_classification.ipynb @@ -74,9 +74,7 @@ "- Review and discuss the class arguments.\n", " - ``input_keys``— ...\n", " - ``target_keys``— ...\n", - " - ``train``— ...\n", - " - ``x_tfms``— ...\n", - " - ``y_tfms``— ..." + " - ``train``— ..." ] }, { @@ -230,7 +228,7 @@ "source": [ "- Can we give these items to a neural network, or do they need to be transformed first?\n", " - Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n", - " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html).\n", + " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch; they are the PyTorch equivalent to Numpy arrays, while also providing support for GPU acceleration. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html).\n", " - The targets are tuples of strings i.e. ('Gentoo', )\n", " - One idea is to represent as ordinal values i.e. [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n", " \"A\" — [1, 0, 0]\\\n", From 7c96347cce5a54b0ef84e2f710c5be903d4d4eda Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Sat, 6 Jul 2024 16:24:54 +0100 Subject: [PATCH 8/9] Fix Task 4 comment --- exercises/01_penguin_classification.ipynb | 3 ++- worked-solutions/01_penguin_classification_solutions.ipynb | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/exercises/01_penguin_classification.ipynb b/exercises/01_penguin_classification.ipynb index 2e83dc8..cf532cb 100644 --- a/exercises/01_penguin_classification.ipynb +++ b/exercises/01_penguin_classification.ipynb @@ -267,7 +267,8 @@ "metadata": {}, "outputs": [], "source": [ - "# Apply transforms to the data. See Task 4 exercise comments above.\n", + "# Apply transforms we need to PenguinDataset to convert input data and target class to tensors. \n", + "# See Task 4 exercise comments above.\n", "\n", "# Create train_set\n", "\n", diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 17735f2..489bffc 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -371,8 +371,9 @@ } ], "source": [ - "# Apply the transforms we need to the PenguinDataset to get out input\n", - "# targets as Tensors. See Task 4 exercise comments above.\n", + "# Apply transforms we need to PenguinDataset to convert input data and target class to tensors. \n", + "# See Task 4 exercise comments above.\n", + "\n", "\n", "# Create train_set\n", "train_set = PenguinDataset(\n", From db26564ca5738786ddc3f4df17d91ce6b902bedd Mon Sep 17 00:00:00 2001 From: Matt Archer Date: Sat, 6 Jul 2024 17:42:51 +0100 Subject: [PATCH 9/9] Fix Task 3 comment with more on PyTorch Tensors --- worked-solutions/01_penguin_classification_solutions.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/worked-solutions/01_penguin_classification_solutions.ipynb b/worked-solutions/01_penguin_classification_solutions.ipynb index 489bffc..25b6f49 100644 --- a/worked-solutions/01_penguin_classification_solutions.ipynb +++ b/worked-solutions/01_penguin_classification_solutions.ipynb @@ -321,7 +321,7 @@ "source": [ "* Can we give these items to a neural network, or do they need to be transformed first?\n", " + Short answer: no, we can't just pass tuples of numbers or strings to a neural network.\n", - " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html) . \n", + " - We must represent these data as ``torch.Tensor``s. This is the fundamental data abstraction used by PyTorch; they are the PyTorch equivalent to Numpy arrays. See [pytorch tensors documentation](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html) . \n", " - The targets are tuples of strings i.e. ('Gentoo', )\n", " - One idea is to represent as ordinal values i.e. [1] or [2] or [3]. But this implies that the class encoded by value 1 is closer to 2 than 1 is to 3. This is not desirable for categorical data. One-hot encoding avoids this by representing each species independently.\\\n", " \"A\" — [1, 0, 0]\\\n",