From 689329896769e58898d53f634c15c56230f3e14b Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 1 Feb 2025 19:39:22 +0000 Subject: [PATCH 01/17] Created using Colab --- .../Part_1_Deep_Learning_with_Pytorch/week1 | 351 ++++++++++++++++++ 1 file changed, 351 insertions(+) create mode 100644 week1.ipynb/Part_1_Deep_Learning_with_Pytorch/week1 diff --git a/week1.ipynb/Part_1_Deep_Learning_with_Pytorch/week1 b/week1.ipynb/Part_1_Deep_Learning_with_Pytorch/week1 new file mode 100644 index 0000000..e8392e9 --- /dev/null +++ b/week1.ipynb/Part_1_Deep_Learning_with_Pytorch/week1 @@ -0,0 +1,351 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyNmgmQPfwDlOMc4/UDTVN3a", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "V5ABxNIOnyAr" + }, + "outputs": [], + "source": [ + "import torch" + ] + }, + { + "cell_type": "code", + "source": [ + "# create random tensor\n", + "X = torch.rand(size=(7,7))\n", + "X,X.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4sPUYe-AR22P", + "outputId": "ff2f59aa-db29-467f-a2ab-a196be08ee1a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.3142, 0.4865, 0.7705, 0.3263, 0.7264, 0.6868, 0.0522],\n", + " [0.5438, 0.9234, 0.6737, 0.3396, 0.4684, 0.9051, 0.9022],\n", + " [0.5038, 0.2225, 0.9657, 0.4975, 0.0989, 0.6913, 0.5937],\n", + " [0.7634, 0.8749, 0.1176, 0.0565, 0.5362, 0.1045, 0.6571],\n", + " [0.2290, 0.1231, 0.1060, 0.2285, 0.8602, 0.9666, 0.6981],\n", + " [0.5703, 0.9126, 0.0165, 0.9157, 0.9846, 0.1595, 0.7734],\n", + " [0.0339, 0.1776, 0.6518, 0.5989, 0.2043, 0.2849, 0.2325]]),\n", + " torch.Size([7, 7]))" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Create another random tensor\n", + "Y = torch.rand(size=(1, 7))\n", + "# Perform matrix multiplication\n", + "Z = torch.matmul(X, Y.T)\n", + "Z, Z.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RduF2fcySFm8", + "outputId": "c85f229b-27d6-4215-8292-adff242d0708" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[1.4617],\n", + " [1.7799],\n", + " [1.3014],\n", + " [0.9893],\n", + " [1.7503],\n", + " [1.7336],\n", + " [0.8774]]),\n", + " torch.Size([7, 1]))" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set manual seed\n", + "torch.manual_seed(0)\n", + "\n", + "# Create two random tensors\n", + "X = torch.rand(size=(7, 7))\n", + "Y = torch.rand(size=(1, 7))\n", + "\n", + "# Matrix multiply tensors\n", + "Z = torch.matmul(X, Y.T)\n", + "Z, Z.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XJT1P2NBSfMu", + "outputId": "cf85f2aa-6bf2-4cf9-855d-0e451701d738" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[1.8542],\n", + " [1.9611],\n", + " [2.2884],\n", + " [3.0481],\n", + " [1.7067],\n", + " [2.5290],\n", + " [1.7989]]),\n", + " torch.Size([7, 1]))" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set random seed on the GPU\n", + "torch.cuda.manual_seed(1234)" + ], + "metadata": { + "id": "rcgfaPeMWPg2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Set random seed\n", + "torch.manual_seed(1234)\n", + "\n", + "# Check for access to GPU\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(f\"Device: {device}\")\n", + "\n", + "# Create two random tensors on GPU\n", + "tensor_A = torch.rand(size=(2,3)).to(device)\n", + "tensor_B = torch.rand(size=(2,3)).to(device)\n", + "tensor_A, tensor_B" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kXGUX9tLWtQR", + "outputId": "e715efb1-6115-4218-9c82-df5f494945be" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Device: cpu\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.0290, 0.4019, 0.2598],\n", + " [0.3666, 0.0583, 0.7006]]),\n", + " tensor([[0.0518, 0.4681, 0.6738],\n", + " [0.3315, 0.7837, 0.5631]]))" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Perform matmul on tensor_A and tensor_B\n", + "tensor_C = torch.matmul(tensor_A, tensor_B.T)\n", + "tensor_C, tensor_C.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EzvxTswjW2GP", + "outputId": "1cf4adf2-6618-4b23-b23c-f451f482741d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.3647, 0.4709],\n", + " [0.5184, 0.5617]]),\n", + " torch.Size([2, 2]))" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Find max\n", + "max = torch.max(tensor_C)\n", + "\n", + "# Find min\n", + "min = torch.min(tensor_C)\n", + "max, min" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lHPg2D23XDo6", + "outputId": "140287af-d71f-4e8d-b7c1-03ddb285f902" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor(0.5617), tensor(0.3647))" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Find arg max\n", + "arg_max = torch.argmax(tensor_C)\n", + "\n", + "# Find arg min\n", + "arg_min = torch.argmin(tensor_C)\n", + "arg_max, arg_min" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6Fcr_F6QXK_r", + "outputId": "b6045ba0-92a8-472f-de2f-104187b1b546" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor(3), tensor(0))" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set seed\n", + "torch.manual_seed(7)\n", + "\n", + "# Create random tensor\n", + "tensor_D = torch.rand(size=(1, 1, 1, 10))\n", + "\n", + "# Remove single dimensions\n", + "tensor_E = tensor_D.squeeze()\n", + "\n", + "# Print out tensors\n", + "print(tensor_D, tensor_D.shape)\n", + "print(tensor_E, tensor_E.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f9OBG49yXRVN", + "outputId": "e96e91a7-a407-4660-bba7-9867b3f6bb7f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n", + " 0.3653, 0.8513]]]]) torch.Size([1, 1, 1, 10])\n", + "tensor([0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297, 0.3653,\n", + " 0.8513]) torch.Size([10])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "tz9_OxvrXXyr" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 281b20e969be97a85fa11dfbf8693fd80cc289f6 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 1 Feb 2025 19:47:56 +0000 Subject: [PATCH 02/17] Created using Colab --- ...opy_of_01_pytorch_workflow_exercises.ipynb | 724 ++++++++++++++++++ 1 file changed, 724 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week2/Copy_of_01_pytorch_workflow_exercises.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week2/Copy_of_01_pytorch_workflow_exercises.ipynb b/Part_1_Deep_Learning_with_Pytorch/week2/Copy_of_01_pytorch_workflow_exercises.ipynb new file mode 100644 index 0000000..a7cae57 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week2/Copy_of_01_pytorch_workflow_exercises.ipynb @@ -0,0 +1,724 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 01. PyTorch Workflow Exercise Template\n", + "\n", + "The following is a template for the PyTorch workflow exercises.\n", + "\n", + "It's only starter code and it's your job to fill in the blanks.\n", + "\n", + "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n", + "\n", + "Don't worry about trying to be *right* just try writing code that suffices the question.\n", + "\n", + "You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)." + ], + "metadata": { + "id": "N8LsPXZti9Sw" + } + }, + { + "cell_type": "code", + "source": [ + "# Import necessary libraries\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "from torch import nn" + ], + "metadata": { + "id": "Glu2fM4dkNlx" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup device-agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n" + ], + "metadata": { + "id": "LqKhXY26m31s", + "outputId": "0e6e7442-e4c8-4869-954b-27c7aae6f1da", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Create a straight line dataset using the linear regression formula (`weight * X + bias`).\n", + " * Set `weight=0.3` and `bias=0.9` there should be at least 100 datapoints total.\n", + " * Split the data into 80% training, 20% testing.\n", + " * Plot the training and testing data so it becomes visual.\n", + "\n", + "Your output of the below cell should look something like:\n", + "```\n", + "Number of X samples: 100\n", + "Number of y samples: 100\n", + "First 10 X & y samples:\n", + "X: tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n", + " 0.0900])\n", + "y: tensor([0.9000, 0.9030, 0.9060, 0.9090, 0.9120, 0.9150, 0.9180, 0.9210, 0.9240,\n", + " 0.9270])\n", + "```\n", + "\n", + "Of course the numbers in `X` and `y` may be different but ideally they're created using the linear regression formula." + ], + "metadata": { + "id": "g7HUhxCxjeBx" + } + }, + { + "cell_type": "code", + "source": [ + "# Create the data parameters\n", + "weight = 0.3\n", + "bias = 0.9\n", + "# Make X and y using linear regression feature\n", + "X = torch.arange(0,1,0.01).unsqueeze(dim = 1)\n", + "y = weight * X + bias\n", + "print(f\"Number of X samples: {len(X)}\")\n", + "print(f\"Number of y samples: {len(y)}\")\n", + "print(f\"First 10 X & y samples:\\nX: {X[:10]}\\ny: {y[:10]}\")" + ], + "metadata": { + "id": "KbDG5MV7jhvE", + "outputId": "a2868ed1-4ca1-4a4d-eae8-8ff4bf6d9996", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Number of X samples: 100\n", + "Number of y samples: 100\n", + "First 10 X & y samples:\n", + "X: tensor([[0.0000],\n", + " [0.0100],\n", + " [0.0200],\n", + " [0.0300],\n", + " [0.0400],\n", + " [0.0500],\n", + " [0.0600],\n", + " [0.0700],\n", + " [0.0800],\n", + " [0.0900]])\n", + "y: tensor([[0.9000],\n", + " [0.9030],\n", + " [0.9060],\n", + " [0.9090],\n", + " [0.9120],\n", + " [0.9150],\n", + " [0.9180],\n", + " [0.9210],\n", + " [0.9240],\n", + " [0.9270]])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Split the data into training and testing\n", + "train_split = int(len(X) * 0.8)\n", + "X_train = X[:train_split]\n", + "y_train = y[:train_split]\n", + "X_test = X[train_split:]\n", + "y_test = y[train_split:]\n", + "len(X_train),len(y_train),len(X_test),len(y_test)\n" + ], + "metadata": { + "id": "GlwtT1djkmLw", + "outputId": "1b5f0c58-8f26-4df8-885e-e0203eeb9a09", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(80, 80, 20, 20)" + ] + }, + "metadata": {}, + "execution_count": 30 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot the training and testing data\n", + "def plot_predictions(train_data = X_train,\n", + " train_labels = y_train,\n", + " test_data = X_test,\n", + " test_labels = y_test,\n", + " predictions = None):\n", + " plt.figure(figsize = (10,7))\n", + " plt.scatter(train_data,train_labels,c = 'r',s = 5,label = \"Training data\")\n", + " plt.scatter(test_data,test_labels,c = 'b',s = 5,label = \"Test data\")\n", + "\n", + " if predictions is not None:\n", + " plt.scatter(test_data,predictions,c = 'g',s = 5,label = \"Predictions\")\n", + " plt.legend(prop = {\"size\" : 10})\n", + "plot_predictions()\n" + ], + "metadata": { + "id": "29iQZFNhlYJ-", + "outputId": "b97b8c89-ff33-4ae0-ec64-195249ecfdf8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 599 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Build a PyTorch model by subclassing `nn.Module`.\n", + " * Inside should be a randomly initialized `nn.Parameter()` with `requires_grad=True`, one for `weights` and one for `bias`.\n", + " * Implement the `forward()` method to compute the linear regression function you used to create the dataset in 1.\n", + " * Once you've constructed the model, make an instance of it and check its `state_dict()`.\n", + " * **Note:** If you'd like to use `nn.Linear()` instead of `nn.Parameter()` you can." + ], + "metadata": { + "id": "ImZoe3v8jif8" + } + }, + { + "cell_type": "code", + "source": [ + "# Create PyTorch linear regression model by subclassing nn.Module\n", + "class LinearRegressionModel(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.linear_layer = nn.Linear(in_features = 1,\n", + " out_features = 1)\n", + " def forward(self,x : torch.Tensor) -> torch.Tensor:\n", + " return self.linear_layer(x)\n", + "torch.manual_seed(42)\n", + "model_1 = LinearRegressionModel()\n", + "model_1,model_1.state_dict()" + ], + "metadata": { + "id": "qzd__Y5rjtB8", + "outputId": "7437a819-2c41-4292-eafb-06da70d88fb9", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(LinearRegressionModel(\n", + " (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n", + " ),\n", + " OrderedDict([('linear_layer.weight', tensor([[0.7645]])),\n", + " ('linear_layer.bias', tensor([0.8300]))]))" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [ + "next(model_1.parameters()).device" + ], + "metadata": { + "id": "LQpVsgqg2Bvm", + "outputId": "57314bf0-92d2-49a7-d5c3-98be345541f6", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "device(type='cpu')" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Instantiate the model and put it to the target device\n", + "model_1.to(device)\n", + "list(model_1.parameters())" + ], + "metadata": { + "id": "5LdcDnmOmyQ2", + "outputId": "098a2e6b-05cb-431f-f4ba-5549ca273b7b", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[Parameter containing:\n", + " tensor([[0.7645]], device='cuda:0', requires_grad=True),\n", + " Parameter containing:\n", + " tensor([0.8300], device='cuda:0', requires_grad=True)]" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Create a loss function and optimizer using `nn.L1Loss()` and `torch.optim.SGD(params, lr)` respectively.\n", + " * Set the learning rate of the optimizer to be 0.01 and the parameters to optimize should be the model parameters from the model you created in 2.\n", + " * Write a training loop to perform the appropriate training steps for 300 epochs.\n", + " * The training loop should test the model on the test dataset every 20 epochs." + ], + "metadata": { + "id": "G6nYOrJhjtfu" + } + }, + { + "cell_type": "code", + "source": [ + "# Create the loss function and optimizer\n", + "loss_fn = nn.L1Loss()\n", + "optimizer = torch.optim.SGD(params = model_1.parameters(),\n", + " lr = 0.01)" + ], + "metadata": { + "id": "ltvoZ-FWjv1j" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Training loop\n", + "# Train model for 300 epochs\n", + "torch.manual_seed(42)\n", + "\n", + "epochs = 300\n", + "\n", + "# Send data to target device\n", + "X_train = X_train.to(device)\n", + "X_test = X_test.to(device)\n", + "y_train = y_train.to(device)\n", + "y_test = y_test.to(device)\n", + "\n", + "for epoch in range(epochs):\n", + " ### Training\n", + "\n", + " # Put model in train mode\n", + " model_1.train()\n", + "\n", + " # 1. Forward pass\n", + " y_pred = model_1(X_train)\n", + "\n", + " # 2. Calculate loss\n", + " loss = loss_fn(y_pred,y_train)\n", + "\n", + " # 3. Zero gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # 4. Backpropagation\n", + " loss.backward()\n", + "\n", + " # 5. Step the optimizer\n", + " optimizer.step()\n", + "\n", + " ### Perform testing every 20 epochs\n", + " if epoch % 20 == 0:\n", + " # Put model in evaluation mode and setup inference context\n", + " model_1.eval()\n", + " with torch.inference_mode():\n", + " # 1. Forward pass\n", + " y_preds = model_1(X_test)\n", + " # 2. Calculate test loss\n", + " test_loss = loss_fn(y_preds,y_test)\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Train loss: {loss:.3f} | Test loss: {test_loss:.3f}\")" + ], + "metadata": { + "id": "xpE83NvNnkdV", + "outputId": "e190714c-f4fb-4928-8735-3f24338ee9b0", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch: 0 | Train loss: 0.128 | Test loss: 0.337\n", + "Epoch: 20 | Train loss: 0.082 | Test loss: 0.218\n", + "Epoch: 40 | Train loss: 0.072 | Test loss: 0.175\n", + "Epoch: 60 | Train loss: 0.065 | Test loss: 0.153\n", + "Epoch: 80 | Train loss: 0.058 | Test loss: 0.137\n", + "Epoch: 100 | Train loss: 0.051 | Test loss: 0.121\n", + "Epoch: 120 | Train loss: 0.045 | Test loss: 0.104\n", + "Epoch: 140 | Train loss: 0.038 | Test loss: 0.088\n", + "Epoch: 160 | Train loss: 0.031 | Test loss: 0.072\n", + "Epoch: 180 | Train loss: 0.024 | Test loss: 0.056\n", + "Epoch: 200 | Train loss: 0.017 | Test loss: 0.040\n", + "Epoch: 220 | Train loss: 0.010 | Test loss: 0.024\n", + "Epoch: 240 | Train loss: 0.003 | Test loss: 0.007\n", + "Epoch: 260 | Train loss: 0.008 | Test loss: 0.007\n", + "Epoch: 280 | Train loss: 0.008 | Test loss: 0.007\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Make predictions with the trained model on the test data.\n", + " * Visualize these predictions against the original training and testing data (**note:** you may need to make sure the predictions are *not* on the GPU if you want to use non-CUDA-enabled libraries such as matplotlib to plot)." + ], + "metadata": { + "id": "x4j4TM18jwa7" + } + }, + { + "cell_type": "code", + "source": [ + "# Make predictions with the model\n", + "model_1.eval()\n", + "\n", + "with torch.inference_mode():\n", + " y_preds = model_1(X_test)\n", + "y_preds" + ], + "metadata": { + "id": "bbMPK5Qjjyx_", + "outputId": "92aa19b8-8495-44a0-b89a-864259250bc3", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[1.1333],\n", + " [1.1363],\n", + " [1.1393],\n", + " [1.1423],\n", + " [1.1454],\n", + " [1.1484],\n", + " [1.1514],\n", + " [1.1545],\n", + " [1.1575],\n", + " [1.1605],\n", + " [1.1635],\n", + " [1.1666],\n", + " [1.1696],\n", + " [1.1726],\n", + " [1.1757],\n", + " [1.1787],\n", + " [1.1817],\n", + " [1.1847],\n", + " [1.1878],\n", + " [1.1908]], device='cuda:0')" + ] + }, + "metadata": {}, + "execution_count": 39 + } + ] + }, + { + "cell_type": "code", + "source": [ + "y_preds.cpu()" + ], + "metadata": { + "id": "OPU8PJbS2fnm", + "outputId": "06733a03-73e9-458d-bcf3-ebe67a9fb7b5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[1.1333],\n", + " [1.1363],\n", + " [1.1393],\n", + " [1.1423],\n", + " [1.1454],\n", + " [1.1484],\n", + " [1.1514],\n", + " [1.1545],\n", + " [1.1575],\n", + " [1.1605],\n", + " [1.1635],\n", + " [1.1666],\n", + " [1.1696],\n", + " [1.1726],\n", + " [1.1757],\n", + " [1.1787],\n", + " [1.1817],\n", + " [1.1847],\n", + " [1.1878],\n", + " [1.1908]])" + ] + }, + "metadata": {}, + "execution_count": 40 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot the predictions (these may need to be on a specific device)\n", + "plot_predictions(predictions = y_preds.cpu())" + ], + "metadata": { + "id": "K3BdmQaDpFo8", + "outputId": "7317e273-37e6-48aa-b905-1ab1f9f3c2f2", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 599 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Save your trained model's `state_dict()` to file.\n", + " * Create a new instance of your model class you made in 2. and load in the `state_dict()` you just saved to it.\n", + " * Perform predictions on your test data with the loaded model and confirm they match the original model predictions from 4." + ], + "metadata": { + "id": "s2OnlMWKjzX8" + } + }, + { + "cell_type": "code", + "source": [ + "from pathlib import Path\n", + "\n", + "# 1. Create models directory\n", + "MODEL_PATH = Path(\"models\")\n", + "MODEL_PATH.mkdir(parents = True,exist_ok = True)\n", + "# 2. Create model save path\n", + "MODEL_NAME = \"01_pytorch_model1\"\n", + "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n", + "# 3. Save the model state dict\n", + "print(f\"Saving model to {MODEL_SAVE_PATH}\")\n", + "torch.save(obj = model_1.state_dict(),f = MODEL_SAVE_PATH)\n" + ], + "metadata": { + "id": "hgxhgD14qr-i", + "outputId": "04412cb6-a060-4d32-96f1-7e2fca0b5944", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving model to models/01_pytorch_model1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Create new instance of model and load saved state dict (make sure to put it on the target device)\n", + "loaded_model = LinearRegressionModel()\n", + "loaded_model.load_state_dict(torch.load(f = MODEL_SAVE_PATH))\n", + "loaded_model.to(device)" + ], + "metadata": { + "id": "P9vTgiLRrJ7T", + "outputId": "fddc6cc9-2692-4d22-c637-0a0f95597c32", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":3: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " loaded_model.load_state_dict(torch.load(f = MODEL_SAVE_PATH))\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "LinearRegressionModel(\n", + " (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 43 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make predictions with loaded model and compare them to the previous\n", + "y_preds_new = loaded_model(X_test)\n", + "y_preds == y_preds_new" + ], + "metadata": { + "id": "8UGX3VebrVtI", + "outputId": "e17b6491-8995-41b5-cd76-6873b5b2137a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True]], device='cuda:0')" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ] + } + ] +} \ No newline at end of file From 0956226e0514309965e52fb6e245e0a92a2ce3e0 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 1 Feb 2025 19:49:04 +0000 Subject: [PATCH 03/17] Created using Colab --- .../week1/week1.ipynb | 351 ++++++++++++++++++ 1 file changed, 351 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week1/week1.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week1/week1.ipynb b/Part_1_Deep_Learning_with_Pytorch/week1/week1.ipynb new file mode 100644 index 0000000..890f475 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week1/week1.ipynb @@ -0,0 +1,351 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyNmgmQPfwDlOMc4/UDTVN3a", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "V5ABxNIOnyAr" + }, + "outputs": [], + "source": [ + "import torch" + ] + }, + { + "cell_type": "code", + "source": [ + "# create random tensor\n", + "X = torch.rand(size=(7,7))\n", + "X,X.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4sPUYe-AR22P", + "outputId": "ff2f59aa-db29-467f-a2ab-a196be08ee1a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.3142, 0.4865, 0.7705, 0.3263, 0.7264, 0.6868, 0.0522],\n", + " [0.5438, 0.9234, 0.6737, 0.3396, 0.4684, 0.9051, 0.9022],\n", + " [0.5038, 0.2225, 0.9657, 0.4975, 0.0989, 0.6913, 0.5937],\n", + " [0.7634, 0.8749, 0.1176, 0.0565, 0.5362, 0.1045, 0.6571],\n", + " [0.2290, 0.1231, 0.1060, 0.2285, 0.8602, 0.9666, 0.6981],\n", + " [0.5703, 0.9126, 0.0165, 0.9157, 0.9846, 0.1595, 0.7734],\n", + " [0.0339, 0.1776, 0.6518, 0.5989, 0.2043, 0.2849, 0.2325]]),\n", + " torch.Size([7, 7]))" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Create another random tensor\n", + "Y = torch.rand(size=(1, 7))\n", + "# Perform matrix multiplication\n", + "Z = torch.matmul(X, Y.T)\n", + "Z, Z.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RduF2fcySFm8", + "outputId": "c85f229b-27d6-4215-8292-adff242d0708" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[1.4617],\n", + " [1.7799],\n", + " [1.3014],\n", + " [0.9893],\n", + " [1.7503],\n", + " [1.7336],\n", + " [0.8774]]),\n", + " torch.Size([7, 1]))" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set manual seed\n", + "torch.manual_seed(0)\n", + "\n", + "# Create two random tensors\n", + "X = torch.rand(size=(7, 7))\n", + "Y = torch.rand(size=(1, 7))\n", + "\n", + "# Matrix multiply tensors\n", + "Z = torch.matmul(X, Y.T)\n", + "Z, Z.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XJT1P2NBSfMu", + "outputId": "cf85f2aa-6bf2-4cf9-855d-0e451701d738" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[1.8542],\n", + " [1.9611],\n", + " [2.2884],\n", + " [3.0481],\n", + " [1.7067],\n", + " [2.5290],\n", + " [1.7989]]),\n", + " torch.Size([7, 1]))" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set random seed on the GPU\n", + "torch.cuda.manual_seed(1234)" + ], + "metadata": { + "id": "rcgfaPeMWPg2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Set random seed\n", + "torch.manual_seed(1234)\n", + "\n", + "# Check for access to GPU\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(f\"Device: {device}\")\n", + "\n", + "# Create two random tensors on GPU\n", + "tensor_A = torch.rand(size=(2,3)).to(device)\n", + "tensor_B = torch.rand(size=(2,3)).to(device)\n", + "tensor_A, tensor_B" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kXGUX9tLWtQR", + "outputId": "e715efb1-6115-4218-9c82-df5f494945be" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Device: cpu\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.0290, 0.4019, 0.2598],\n", + " [0.3666, 0.0583, 0.7006]]),\n", + " tensor([[0.0518, 0.4681, 0.6738],\n", + " [0.3315, 0.7837, 0.5631]]))" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Perform matmul on tensor_A and tensor_B\n", + "tensor_C = torch.matmul(tensor_A, tensor_B.T)\n", + "tensor_C, tensor_C.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EzvxTswjW2GP", + "outputId": "1cf4adf2-6618-4b23-b23c-f451f482741d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.3647, 0.4709],\n", + " [0.5184, 0.5617]]),\n", + " torch.Size([2, 2]))" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Find max\n", + "max = torch.max(tensor_C)\n", + "\n", + "# Find min\n", + "min = torch.min(tensor_C)\n", + "max, min" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lHPg2D23XDo6", + "outputId": "140287af-d71f-4e8d-b7c1-03ddb285f902" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor(0.5617), tensor(0.3647))" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Find arg max\n", + "arg_max = torch.argmax(tensor_C)\n", + "\n", + "# Find arg min\n", + "arg_min = torch.argmin(tensor_C)\n", + "arg_max, arg_min" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6Fcr_F6QXK_r", + "outputId": "b6045ba0-92a8-472f-de2f-104187b1b546" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor(3), tensor(0))" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set seed\n", + "torch.manual_seed(7)\n", + "\n", + "# Create random tensor\n", + "tensor_D = torch.rand(size=(1, 1, 1, 10))\n", + "\n", + "# Remove single dimensions\n", + "tensor_E = tensor_D.squeeze()\n", + "\n", + "# Print out tensors\n", + "print(tensor_D, tensor_D.shape)\n", + "print(tensor_E, tensor_E.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f9OBG49yXRVN", + "outputId": "e96e91a7-a407-4660-bba7-9867b3f6bb7f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n", + " 0.3653, 0.8513]]]]) torch.Size([1, 1, 1, 10])\n", + "tensor([0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297, 0.3653,\n", + " 0.8513]) torch.Size([10])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "tz9_OxvrXXyr" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From 0f7a1df66d7534ae57955af251883b8f78ab0ac5 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Thu, 13 Feb 2025 00:19:12 +0000 Subject: [PATCH 04/17] Created using Colab --- .../02_pytorch_classification_exercises.ipynb | 1128 +++++++++++++++++ 1 file changed, 1128 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/exercise_submissions/extras/exercises/02_pytorch_classification_exercises.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/extras/exercises/02_pytorch_classification_exercises.ipynb b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/extras/exercises/02_pytorch_classification_exercises.ipynb new file mode 100644 index 0000000..9a06c3a --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/extras/exercises/02_pytorch_classification_exercises.ipynb @@ -0,0 +1,1128 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "02_pytorch_classification_exercises.ipynb", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 02. PyTorch Classification Exercises\n", + "\n", + "The following is a template for 02. PyTorch Classification exercises.\n", + "\n", + "It's only starter code and it's your job to fill in the blanks.\n", + "\n", + "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n", + "\n", + "Don't worry about trying to be *right* just try writing code that suffices the question.\n", + "\n", + "## Resources\n", + "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n", + "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)." + ], + "metadata": { + "id": "ZKJFt7YxH8yl" + } + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Setup device agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n", + "\n", + "# Setup random seed\n", + "RANDOM_SEED = 42" + ], + "metadata": { + "id": "CSrUPgapO0tf" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n", + " * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n", + " * Turn the data into PyTorch tensors.\n", + " * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing." + ], + "metadata": { + "id": "pH7jIZ2SPFee" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a dataset with Scikit-Learn's make_moons()\n", + "from sklearn.datasets import make_moons\n", + "NUM_SAMPLES = 1000\n", + "X, y = make_moons(n_samples=NUM_SAMPLES,\n", + " noise=0.07,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "X[:10], y[:10]" + ], + "metadata": { + "id": "5t4VhPV1PX1X", + "outputId": "ed1efa82-95db-4ac0-c5b0-86b9f97b8fbd", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(array([[-0.03341062, 0.4213911 ],\n", + " [ 0.99882703, -0.4428903 ],\n", + " [ 0.88959204, -0.32784256],\n", + " [ 0.34195829, -0.41768975],\n", + " [-0.83853099, 0.53237483],\n", + " [ 0.59906425, -0.28977331],\n", + " [ 0.29009023, -0.2046885 ],\n", + " [-0.03826868, 0.45942924],\n", + " [ 1.61377123, -0.2939697 ],\n", + " [ 0.693337 , 0.82781911]]),\n", + " array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0]))" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into a DataFrame\n", + "import pandas as pd\n", + "data_df = pd.DataFrame({\"X0\": X[:, 0],\n", + " \"X1\": X[:, 1],\n", + " \"y\": y})\n", + "data_df.head()" + ], + "metadata": { + "id": "SUeHZ3-3P9C7", + "outputId": "f0344982-1235-4973-85eb-8728806c6cd5", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + } + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " X0 X1 y\n", + "0 -0.033411 0.421391 1\n", + "1 0.998827 -0.442890 1\n", + "2 0.889592 -0.327843 1\n", + "3 0.341958 -0.417690 1\n", + "4 -0.838531 0.532375 0" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X0X1y
0-0.0334110.4213911
10.998827-0.4428901
20.889592-0.3278431
30.341958-0.4176901
4-0.8385310.5323750
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "data_df", + "summary": "{\n \"name\": \"data_df\",\n \"rows\": 1000,\n \"fields\": [\n {\n \"column\": \"X0\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.8694818021016458,\n \"min\": -1.1517146477802855,\n \"max\": 2.1819758362649324,\n \"num_unique_values\": 1000,\n \"samples\": [\n 0.5424909907290043,\n 0.8410600562502046,\n 1.274536542513856\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"X1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.4984727335666475,\n \"min\": -0.6690694860909892,\n \"max\": 1.132945524956193,\n \"num_unique_values\": 1000,\n \"samples\": [\n -0.39644452406089203,\n 0.6354459945668033,\n -0.4373423036321222\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Visualize the data on a scatter plot\n", + "import matplotlib.pyplot as plt\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlGn_r);" + ], + "metadata": { + "id": "owrkPSFvQPFI", + "outputId": "9e3a4075-43f2-4a72-e702-15460cfb665d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + } + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors of dtype float\n", + "X = torch.tensor(X, dtype=torch.float)\n", + "y = torch.tensor(y, dtype=torch.float)\n", + "\n", + "# Split the data into train and test sets (80% train, 20% test)\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X,\n", + " y,\n", + " test_size=0.2,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "len(X_train), len(X_test), len(y_train), len(y_test)" + ], + "metadata": { + "id": "bDhyHn9fR4dq", + "outputId": "54e5018c-16b3-4879-d5c3-3b8fd29392bc", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(800, 200, 800, 200)" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Build a model by subclassing `nn.Module` that incorporates non-linear activation functions and is capable of fitting the data you created in 1.\n", + " * Feel free to use any combination of PyTorch layers (linear and non-linear) you want." + ], + "metadata": { + "id": "cMIjxZdzQfPz" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from torch import nn\n", + "\n", + "# Inherit from nn.Module to make a model capable of fitting the mooon data\n", + "class MoonModelV0(nn.Module):\n", + " ## Your code here ##\n", + " def __init__(self, in_features, out_features, hidden_units):\n", + " super().__init__()\n", + "\n", + " self.layer1 = nn.Linear(in_features=in_features,\n", + " out_features=hidden_units)\n", + " self.layer2 = nn.Linear(in_features=hidden_units,\n", + " out_features=hidden_units)\n", + " self.layer3 = nn.Linear(in_features=hidden_units,\n", + " out_features=out_features)\n", + " self.relu = nn.ReLU()\n", + "\n", + " def forward(self, x):\n", + " ## Your code here ##\n", + " return self.layer3(self.relu(self.layer2(self.relu(self.layer1(x)))))\n", + "# Instantiate the model\n", + "model_0 = MoonModelV0(in_features=2,\n", + " out_features=1,\n", + " hidden_units=10).to(device)\n", + " ## Your code here ##\n", + "model_0\n", + "model_0.state_dict()\n" + ], + "metadata": { + "id": "hwtyvm34Ri6Q", + "outputId": "ed95d535-2bfa-47be-f533-425ef8734562", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "OrderedDict([('layer1.weight',\n", + " tensor([[-0.5470, -0.6836],\n", + " [-0.6950, 0.4084],\n", + " [-0.2922, -0.2321],\n", + " [ 0.6820, -0.5020],\n", + " [-0.6546, -0.6460],\n", + " [-0.2421, -0.3052],\n", + " [ 0.5689, -0.4556],\n", + " [-0.3980, -0.3647],\n", + " [-0.5105, 0.1456],\n", + " [-0.3020, -0.0145]], device='cuda:0')),\n", + " ('layer1.bias',\n", + " tensor([-0.4632, 0.6134, -0.2137, 0.0313, 0.2942, 0.1956, 0.2712, 0.4399,\n", + " -0.3251, 0.4376], device='cuda:0')),\n", + " ('layer2.weight',\n", + " tensor([[ 0.1165, -0.0450, -0.1116, -0.1601, 0.1070, 0.1842, 0.3130, 0.2653,\n", + " -0.1831, 0.1318],\n", + " [ 0.1607, 0.0982, 0.0973, -0.2744, 0.0552, 0.1487, -0.2684, 0.2512,\n", + " -0.1862, 0.1385],\n", + " [ 0.0164, -0.2737, 0.1847, 0.3070, 0.1939, 0.1399, -0.2639, 0.3137,\n", + " 0.0070, 0.2273],\n", + " [ 0.0614, 0.1864, 0.0584, -0.1277, -0.2208, -0.2585, 0.2736, 0.2088,\n", + " 0.2896, 0.2426],\n", + " [ 0.2687, 0.2152, 0.0520, 0.0781, 0.1021, 0.2492, 0.0022, 0.0666,\n", + " -0.1148, 0.1932],\n", + " [-0.2938, -0.2830, -0.2036, -0.1110, -0.2106, -0.2842, 0.3041, 0.0025,\n", + " -0.2531, 0.0739],\n", + " [ 0.0978, 0.0700, -0.2572, -0.0159, -0.2283, -0.2082, -0.2708, -0.1413,\n", + " 0.2099, 0.2307],\n", + " [ 0.2255, 0.0754, -0.3120, -0.2223, -0.0177, -0.1004, 0.0213, 0.1084,\n", + " 0.2014, 0.3029],\n", + " [-0.0838, 0.1268, 0.1217, -0.2499, -0.0082, 0.0147, 0.3039, -0.2365,\n", + " -0.0534, -0.2617],\n", + " [ 0.0107, -0.3108, -0.1708, 0.1689, -0.2182, -0.0506, 0.0155, 0.2588,\n", + " 0.1216, 0.2880]], device='cuda:0')),\n", + " ('layer2.bias',\n", + " tensor([ 0.1875, -0.1325, -0.1128, 0.0385, 0.2302, 0.1784, -0.0004, -0.1464,\n", + " 0.3064, -0.0241], device='cuda:0')),\n", + " ('layer3.weight',\n", + " tensor([[-0.2544, 0.2815, 0.2945, -0.1788, -0.0604, -0.0120, -0.2550, -0.3014,\n", + " -0.2443, 0.2854]], device='cuda:0')),\n", + " ('layer3.bias', tensor([0.2758], device='cuda:0'))])" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Setup a binary classification compatible loss function and optimizer to use when training the model built in 2." + ], + "metadata": { + "id": "DSj97RwyVeFE" + } + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function\n", + "loss_fn = nn.BCEWithLogitsLoss()\n", + "# Setup optimizer to optimize model's parameters\n", + "optimizer = torch.optim.SGD(params=model_0.parameters(), # parameters of model to optimize\n", + " lr=0.1) # learning rate" + ], + "metadata": { + "id": "whSGw5qgVvxU" + }, + "execution_count": 22, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Create a training and testing loop to fit the model you created in 2 to the data you created in 1.\n", + " * Do a forward pass of the model to see what's coming out in the form of logits, prediction probabilities and labels.\n", + " * To measure model accuray, you can create your own accuracy function or use the accuracy function in [TorchMetrics](https://torchmetrics.readthedocs.io/en/latest/).\n", + " * Train the model for long enough for it to reach over 96% accuracy.\n", + " * The training loop should output progress every 10 epochs of the model's training and test set loss and accuracy." + ], + "metadata": { + "id": "nvk4PfNTWUAt" + } + }, + { + "cell_type": "code", + "source": [ + "# What's coming out of our model?\n", + "\n", + "# logits (raw outputs of model)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "print(model_0(X_train.to(device)[:10]).squeeze())\n", + "# Prediction probabilities\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "print(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze()))\n", + "\n", + "# Prediction labels\n", + "print(\"Pred labels:\")\n", + "## Your code here ##\n", + "print(torch.round(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze())))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AgnFdlamd2-D", + "outputId": "d5fe83a8-4bca-4840-f7cf-7d7bd0075b92" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Logits:\n", + "tensor([ 0.0768, 0.0087, -0.0099, -0.0048, 0.0583, -0.0122, 0.0910, 0.0062,\n", + " 0.0361, 0.0620], device='cuda:0', grad_fn=)\n", + "Pred probs:\n", + "tensor([0.5192, 0.5022, 0.4975, 0.4988, 0.5146, 0.4970, 0.5227, 0.5016, 0.5090,\n", + " 0.5155], device='cuda:0', grad_fn=)\n", + "Pred labels:\n", + "tensor([1., 1., 0., 0., 1., 0., 1., 1., 1., 1.], device='cuda:0',\n", + " grad_fn=)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy using accuracy from TorchMetrics\n", + "!pip -q install torchmetrics # Colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "## TODO: Uncomment this code to use the Accuracy function\n", + "acc_fn = Accuracy(task=\"multiclass\", num_classes=2).to(device) # send accuracy function to device\n", + "acc_fn" + ], + "metadata": { + "id": "rUSDNHB4euoJ", + "outputId": "25c62d81-a655-4228-b978-897cd129357e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m23.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m106.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m86.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m53.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m64.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MulticlassAccuracy()" + ] + }, + "metadata": {}, + "execution_count": 24 + } + ] + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "fGmP1hSLn-DR" + } + }, + { + "cell_type": "code", + "source": [ + "##TODO: Uncomment this to set the seed\n", + "torch.manual_seed(RANDOM_SEED)\n", + "\n", + "# Setup epochs\n", + "epochs=1000\n", + "\n", + "# Send data to the device\n", + "X_train, y_train = X_train.to(device), y_train.to(device)\n", + "X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + "# Loop through the data\n", + "# for epoch in range(epochs):\n", + " ### Training\n", + "\n", + "\n", + " # 1. Forward pass (logits output)\n", + "y_logits = model_0(X_train).squeeze()\n", + " # Turn logits into prediction probabilities\n", + "y_pred_probs = torch.sigmoid(y_logits)\n", + "\n", + " # Turn prediction probabilities into prediction labels\n", + "y_pred = torch.round(y_pred_probs)\n", + "\n", + " # 2. Calculaute the loss\n", + "loss = loss_fn(y_logits, y_train) # loss = compare model raw outputs to desired model outputs\n", + " # Calculate the accuracy\n", + "acc = acc_fn(y_pred, y_train.int()) # the accuracy function needs to compare pred labels (not logits) with actual labels\n", + "\n", + " # 3. Zero the gradients\n", + "\n", + "\n", + " # 4. Loss backward (perform backpropagation) - https://brilliant.org/wiki/backpropagation/#:~:text=Backpropagation%2C%20short%20for%20%22backward%20propagation,to%20the%20neural%20network's%20weights.\n", + "\n", + " # 5. Step the optimizer (gradient descent) - https://towardsdatascience.com/gradient-descent-algorithm-a-deep-dive-cf04e8115f21#:~:text=Gradient%20descent%20(GD)%20is%20an,e.g.%20in%20a%20linear%20regression)\n", + "\n", + "\n", + " ### Testing\n", + " # model_0.eval()\n", + " # with torch.inference_mode():\n", + " # 1. Forward pass (to get the logits)\n", + "\n", + " # Turn the test logits into prediction labels\n", + "\n", + "\n", + " # 2. Caculate the test loss/acc\n", + "\n", + "\n", + " # Print out what's happening every 100 epochs\n", + " # if epoch % 100 == 0:\n", + "" + ], + "metadata": { + "id": "SHBY3h7XXnxt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Make predictions with your trained model and plot them using the `plot_decision_boundary()` function created in this notebook." + ], + "metadata": { + "id": "8Nwihtomj9JO" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot the model predictions\n", + "import numpy as np\n", + "\n", + "def plot_decision_boundary(model, X, y):\n", + "\n", + " # Put everything to CPU (works better with NumPy + Matplotlib)\n", + " model.to(\"cpu\")\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Source - https://madewithml.com/courses/foundations/neural-networks/\n", + " # (with modifications)\n", + " x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n", + " y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n", + " xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101),\n", + " np.linspace(y_min, y_max, 101))\n", + "\n", + " # Make features\n", + " X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n", + "\n", + " # Make predictions\n", + " model.eval()\n", + " with torch.inference_mode():\n", + " y_logits = model(X_to_pred_on)\n", + "\n", + " # Test for multi-class or binary and adjust logits to prediction labels\n", + " if len(torch.unique(y)) > 2:\n", + " y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\n", + " else:\n", + " y_pred = torch.round(torch.sigmoid(y_logits)) # binary\n", + "\n", + " # Reshape preds and plot\n", + " y_pred = y_pred.reshape(xx.shape).detach().numpy()\n", + " plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n", + " plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + " plt.xlim(xx.min(), xx.max())\n", + " plt.ylim(yy.min(), yy.max())" + ], + "metadata": { + "id": "0YRzatb8a1P2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n" + ], + "metadata": { + "id": "PMrcpyirig1d" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Replicate the Tanh (hyperbolic tangent) activation function in pure PyTorch.\n", + " * Feel free to reference the [ML cheatsheet website](https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh) for the formula." + ], + "metadata": { + "id": "EtMYBvtciiAU" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a straight line tensor\n" + ], + "metadata": { + "id": "BlXaWC5TkEUE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Test torch.tanh() on the tensor and plot it\n" + ], + "metadata": { + "id": "vZPCcQmIkZjO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Replicate torch.tanh() and plot it\n" + ], + "metadata": { + "id": "J-ne__Kjkdc1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Create a multi-class dataset using the [spirals data creation function from CS231n](https://cs231n.github.io/neural-networks-case-study/) (see below for the code).\n", + " * Split the data into training and test sets (80% train, 20% test) as well as turn it into PyTorch tensors.\n", + " * Construct a model capable of fitting the data (you may need a combination of linear and non-linear layers).\n", + " * Build a loss function and optimizer capable of handling multi-class data (optional extension: use the Adam optimizer instead of SGD, you may have to experiment with different values of the learning rate to get it working).\n", + " * Make a training and testing loop for the multi-class data and train a model on it to reach over 95% testing accuracy (you can use any accuracy measuring function here that you like) - 1000 epochs should be plenty.\n", + " * Plot the decision boundaries on the spirals dataset from your model predictions, the `plot_decision_boundary()` function should work for this dataset too." + ], + "metadata": { + "id": "Lbt1bNcWk5G9" + } + }, + { + "cell_type": "code", + "source": [ + "# Code for creating a spiral dataset from CS231n\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "RANDOM_SEED = 42\n", + "np.random.seed(RANDOM_SEED)\n", + "N = 100 # number of points per class\n", + "D = 2 # dimensionality\n", + "K = 3 # number of classes\n", + "X = np.zeros((N*K,D)) # data matrix (each row = single example)\n", + "y = np.zeros(N*K, dtype='uint8') # class labels\n", + "for j in range(K):\n", + " ix = range(N*j,N*(j+1))\n", + " r = np.linspace(0.0,1,N) # radius\n", + " t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta\n", + " X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]\n", + " y[ix] = j\n", + "# lets visualize the data\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "tU-UNZsKlJls", + "outputId": "8b7b745a-070d-4ecb-c639-c4ee4d8eae06" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors\n", + "import torch\n", + "X = torch.from_numpy(X).type(torch.float) # features as float32\n", + "y = torch.from_numpy(y).type(torch.LongTensor) # labels need to be of type long\n", + "\n", + "# Create train and test splits\n", + "from sklearn.model_selection import train_test_split\n" + ], + "metadata": { + "id": "OWVrmkEyl0VP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy for when we fit our model\n", + "!pip -q install torchmetrics # colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "\n", + "## TODO: uncomment the two lines below to send the accuracy function to the device\n", + "# acc_fn = Accuracy(task=\"multiclass\", num_classes=4).to(device)\n", + "# acc_fn" + ], + "metadata": { + "id": "a-v-7f0op0tG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Prepare device agnostic code\n", + "# device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "# Create model by subclassing nn.Module\n", + "\n", + "\n", + "\n", + "# Instantiate model and send it to device\n" + ], + "metadata": { + "id": "DB3u3ldumapf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup data to be device agnostic\n", + "\n", + "\n", + "# Print out first 10 untrained model outputs (forward pass)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "\n", + "print(\"Pred labels:\")\n", + "## Your code here ##" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QE7XWSSunMTS", + "outputId": "00b31909-87c9-41e3-9dbb-fb4c4bd3aabd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Logits:\n", + "Pred probs:\n", + "Pred labels:\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function and optimizer\n", + "# loss_fn =\n", + "# optimizer =" + ], + "metadata": { + "id": "54EqLRKLo0AW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Build a training loop for the model\n", + "\n", + "# Loop over data\n", + "\n", + "\n", + " ## Training\n", + "\n", + " # 1. Forward pass\n", + "\n", + "\n", + " # 2. Calculate the loss\n", + "\n", + "\n", + " # 3. Optimizer zero grad\n", + "\n", + "\n", + " # 4. Loss backward\n", + "\n", + "\n", + " # 5. Optimizer step\n", + "\n", + "\n", + " ## Testing\n", + "\n", + "\n", + " # 1. Forward pass\n", + "\n", + " # 2. Caculate loss and acc\n", + "\n", + " # Print out what's happening every 100 epochs\n", + "" + ], + "metadata": { + "id": "vIlExkUHnmxi" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n" + ], + "metadata": { + "id": "JrwVRbaE0keT" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From bc7544bc7d07524d8cac6a047e38e1da13a5f8b0 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 15 Feb 2025 22:15:56 +0000 Subject: [PATCH 05/17] Created using Colab --- .../exercise_submissions/week3.ipynb | 1126 +++++++++++++++++ 1 file changed, 1126 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb new file mode 100644 index 0000000..b86b108 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb @@ -0,0 +1,1126 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "02_pytorch_classification_exercises.ipynb", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 02. PyTorch Classification Exercises\n", + "\n", + "The following is a template for 02. PyTorch Classification exercises.\n", + "\n", + "It's only starter code and it's your job to fill in the blanks.\n", + "\n", + "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n", + "\n", + "Don't worry about trying to be *right* just try writing code that suffices the question.\n", + "\n", + "## Resources\n", + "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n", + "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)." + ], + "metadata": { + "id": "ZKJFt7YxH8yl" + } + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Setup device agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n", + "\n", + "# Setup random seed\n", + "RANDOM_SEED = 42" + ], + "metadata": { + "id": "CSrUPgapO0tf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n", + " * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n", + " * Turn the data into PyTorch tensors.\n", + " * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing." + ], + "metadata": { + "id": "pH7jIZ2SPFee" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a dataset with Scikit-Learn's make_moons()\n", + "from sklearn.datasets import make_moons\n", + "NUM_SAMPLES = 1000\n", + "X, y = make_moons(n_samples=NUM_SAMPLES,\n", + " noise=0.07,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "X[:10], y[:10]" + ], + "metadata": { + "id": "5t4VhPV1PX1X", + "outputId": "ed1efa82-95db-4ac0-c5b0-86b9f97b8fbd", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(array([[-0.03341062, 0.4213911 ],\n", + " [ 0.99882703, -0.4428903 ],\n", + " [ 0.88959204, -0.32784256],\n", + " [ 0.34195829, -0.41768975],\n", + " [-0.83853099, 0.53237483],\n", + " [ 0.59906425, -0.28977331],\n", + " [ 0.29009023, -0.2046885 ],\n", + " [-0.03826868, 0.45942924],\n", + " [ 1.61377123, -0.2939697 ],\n", + " [ 0.693337 , 0.82781911]]),\n", + " array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0]))" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into a DataFrame\n", + "import pandas as pd\n", + "data_df = pd.DataFrame({\"X0\": X[:, 0],\n", + " \"X1\": X[:, 1],\n", + " \"y\": y})\n", + "data_df.head()" + ], + "metadata": { + "id": "SUeHZ3-3P9C7", + "outputId": "f0344982-1235-4973-85eb-8728806c6cd5", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " X0 X1 y\n", + "0 -0.033411 0.421391 1\n", + "1 0.998827 -0.442890 1\n", + "2 0.889592 -0.327843 1\n", + "3 0.341958 -0.417690 1\n", + "4 -0.838531 0.532375 0" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X0X1y
0-0.0334110.4213911
10.998827-0.4428901
20.889592-0.3278431
30.341958-0.4176901
4-0.8385310.5323750
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "data_df", + "summary": "{\n \"name\": \"data_df\",\n \"rows\": 1000,\n \"fields\": [\n {\n \"column\": \"X0\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.8694818021016458,\n \"min\": -1.1517146477802855,\n \"max\": 2.1819758362649324,\n \"num_unique_values\": 1000,\n \"samples\": [\n 0.5424909907290043,\n 0.8410600562502046,\n 1.274536542513856\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"X1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.4984727335666475,\n \"min\": -0.6690694860909892,\n \"max\": 1.132945524956193,\n \"num_unique_values\": 1000,\n \"samples\": [\n -0.39644452406089203,\n 0.6354459945668033,\n -0.4373423036321222\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Visualize the data on a scatter plot\n", + "import matplotlib.pyplot as plt\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlGn_r);" + ], + "metadata": { + "id": "owrkPSFvQPFI", + "outputId": "9e3a4075-43f2-4a72-e702-15460cfb665d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAGdCAYAAADuR1K7AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd8FNUWx78zs2lAEkJLCITee0c60pUqoCAggiIIgiICUqQ9UKQj0ptUAZFepPfee+8tCSSk992Z90dIJCZbkuwmAe73ffIkM3fuPQPJzplzz/kdSdM0DYFAIBAIBIK3BDm9DRAIBAKBQCCwJsK5EQgEAoFA8FYhnBuBQCAQCARvFcK5EQgEAoFA8FYhnBuBQCAQCARvFcK5EQgEAoFA8FYhnBuBQCAQCARvFcK5EQgEAoFA8FahS28D0gNVVXn27BnOzs5IkpTe5ggEAoFAILAATdMICQnB09MTWTYen3knnZtnz57h5eWV3mYIBAKBQCBIAY8fPyZv3rxGz7+Tzo2zszMQ+5fj4uKSztYIBAKBQCCwhODgYLy8vOKf48Z4J52buK0oFxcX4dwIBAKBQPCGYS6lRCQUCwQCgUAgeKsQzo1AIBAIBIK3CuHcCAQCgUAgeKsQzo1AIBAIBIK3CuHcCAQCgUAgeKsQzo1AIBAIBIK3CuHcCAQCgUAgeKsQzo1AIBAIBIK3indSxE8gEKQ9PkH+HLh1Dr2qp1qB0hRzz5feJgkEgrcU4dwIBAKbEhYVQd/Vk1lxagd61RB/vFGJqiz5fAR5suZKR+sEAsHbiNiWEggENkNVVVrNGcSyk/8kcGwADtw6R61JPXkZFpRO1gkEgrcV4dwIBAKbsePaCfbdPIOqqYnO6VUDjwOeM+fQ+nSwTCAQvM0I50YgyEBomkZQRCihkeHpbYpVWHpiG4qsGD2vaioLj25OQ4sEAsG7gMi5EQgyAKqqMv/IRqbtXc2t548AqORVnMFNutChSuM0tSUwPIR15/fzLMgPD5dstK/YALfMLima61mgH4b/bEf9l+chASmaWyAQCIwhnBuBIJ3RNI3uy8ay7OQ/SK8dv/DkFh0XjeCq933+17Jnmtgybe8qhm2cQ5Q+BkWWMagq/dZMYUyLrxjc5DMkSTI/yWvkdcsVP48xPF1zpNZsgUAgSIDYlhII0pkNFw6w7OQ/AGivHVe12O/Gbl/M2Yc3bG7HvMMbGPD3b0Tqo9HQ0KsGNDSi9DEM2Tib3/f/leia69736bNqIvmHtSbvkJZ0WDico3cvxp/vXqOFScdGliS+qt3aJvcjEAjeXYRzIxCkMzMP/I0iGf9V1MkKcw7bNuk2Wh/DT5vnmRwzcusCImOi4r9ff34/5cZ1YcGRTTwK8OVp0AvWnz9A7cm9mLBzGRBb7t2iTC3kJCI+iqxQOGdeetX5yLo3IxAI3nmEcyMQpDMXn97GkEQ1URx61cCFx7cSHAuNDGf+4Y10WDic9vOHMnXPn6kqqT50+zx+oYEmxwRFhLLnxmkAHr/0peOiERhUNUGJd9yfh2yczf6bZ5Flmb97jqdPvfY46Ozix0mSRMuytTnywzxcnbKk2G6BQCBICpFzI3jjUVWVKH00jnYOyc4JSW+uPrtHVEyM2XHh0REsPraFcnmKANDs9/74hwUhSzIaGusvHGDE5nms6/UrzUrXSLYdAeEhFo0LfDVu3uENqKqKlmAj7V90ssL0fat5v3hlHOzs+b3DD4xt2ZMjdy+iNxionK8EXtnck22nQCAQWIJwbgRvLHeeP+bXXctZeXIHkfposmV2oWftNgxs1JnsWVzT2zyzLDq6ma9WjseIf5CA6z4P+XL5zwAokoz2Kh/ndf2YCH00beYO5u+vxuMfFoS9zo6GxauQyyWb2fkL58xjkc2FcsSOO3Tngtlo06Hb5xMcy5rJmRZlaxMVE42dIj56BAKB7RCfMII3knOPblB/ah8iYqLit0JehgUzafcK/jq7l2OD5uPukj2drTTO2Yc3+Grl+HgnJTkYcyo0LTb5t+WcgfHHdLJC9xotmNFhAI52DkbnLOtZmNwu2fEO9k/yvAQUzZWPGoXKxn5vQYTs9TGRMVH8vn8tsw7+zcOXPuhkhdbl6/Bjk65ULVDK7FwCgUCQHIRzI3jj0DSNjotGEB4dmehBb1BVHr304fu10/nzy7HJnltv0LP50mGO3r2EJEk0KF6FpqWqmxSiSwm/7V+DIsnoNdMaMKlFrxpYdGwzz4JesKXPlAQOx+7rJ5mx7y+O379CaFQ4UXrj22Ma8EnlBvHXNy5RlSN3LiapPAyxTlXjktWAWMem6YzvOHL3YnwFmF41sOniYTZdPMzar36hTYV6VrpjgUAgEAnFgjeQg7fPcfv5Y6MRDL1qYO25fTwPfpmseS88vkWBnz6i3fyh/H5gLTP2raH5rAGUHNOR26+E9axBaGQ4Wy4dTtRryVaomsa2K8c4ePtc/LGfNs2lyYzv2HHtBP5hQSYdmzjWnN0bH2nqUas1jjo7oxEcg2rg+wafAjBp98oEjk0cetWAQTXQ+Y9RBEeEmV1f0zSeBDznlu8jIqIjzY4XCATvLsK5EbxxXHxyB9lE6TTEPjiv+zyweE7vID8aTP8Gn1fbMjEGPTGvnI97fs+oP7UPQRGhSa9l0LPp4iH+t20Rk3at4IaRdTVNY/yOpbj/+CGBRuayFTpZYdmJWC2d7VeO8fOOJQDJcrBuP3/MTd+HAHi4Zmdj74k46uwTlLHrZAUJiTmdfuS9QmVQVZVZB/5O5NjEoQER0VGsPLXD5Nrrzu2jws+f4TWsFcVHf0KuwR/Q/69pRv9NBALBu43YlhK8cTja2aOZSGZ9fZylzD64juCIsCSjQQbVgHeQP0uPb+PbBh0SnDty5wIdFv7EsyA/dLKCpmkM3jCTVuXqsKL7aJwdM8ePHbt9MaO2LrDIHglAklKUk5MUetUQ77hN37farGqwMcJfi5g0LlmdW2PWMvfQev65epwYg546RSrQp147SnsWAsA/LAjfENMRNJ2scOHJbaPnZ+xbw3drpyXQygmNimDmwbXsvXmGowPn4+KU2ej1AoHg3UNEbgRvHB+UrgFmElpzObtROV8Ji+dcfWa3yeof0Fhzdk+CI1ef3aPxjO/webX9pVcN8XNsu3KUNnN/jHdO/EODGPfPHxbbI79WEWUNZEmK15M5fu9yihwbe8UuvloqjrxuuRjX+mvODlvKpRErmfXpoHjHBsBBZ97B1NCMOqLPAl8wYN1vAImiPwZV5br3fSbtXpHcWxEIBG85wrkRvHHky+ZBp6pNTG5NDW36ObpklBuHRpnuwq0BwZEJ80LG71iK3qBPMqnWoKrsu3mGw3cuALDu/H70BvNbQIoko5MV/vzyf3xTr73F9ptD1TRWn9lNhwXDzW7pJYUsSXSq2oSsmZyTdZ2LU2ZqFS5nUoFZrxpoWbZ2kueWHN9mslTeoKnMfaW5IxAIBHGIbSnBG8n8zkMJCAth+9Vj6GQFVVORJRm9amBgo85895/tI3OUyl2IFyGBRqM3OlmhjGfh+O8NqoG/zu01mbMiITFkwyz0ryq4kDCradO6fF3GtupFqdwFaV+xAR4u2Zi0e2UixyqlrD23D3cXN8KjI5OVb5MvmwcTPvomRWsOb9aND2cNSPKcTlYom6cwDUtUTfL8Td9HsVE6E39vfqGBBEeGJdvxEggEby/CuRG8kWSyd2TrN1M4fu8yK0/txD8siPzZPfiiRkuKe+RP9nzda7Rg380zRs/rVQNfv9YDKTImmhiD3uScGhrH719Jlh0zOgzA0zUn+26c4fTDa2R2cOLA97PxDwtiz43TTNi1PFnzJWWTTzKqyCQkutVozugWPVKc1/JBmZrM+XQwfddMBi3WT5ElCb1qoGTuAmz7ZqrRqisXp0yYU9SRJRknExo+AoHg3UM4N4I3FkmSqFm4HDULl0vxHJqmMX3fakYYaRopIaGh0btuW+oWrRh/PJO9I1kcnAiNikjx2q+jyDINi1fBPzSIBtP6cuv5IxRZRtNiVYg/KF2DJV1HsOfGac4+sl2HcAloWLwqed1yUadIBSJioph18G/yD28DQM1CZRnc5DNal68bf83LsCBCoyJwd86Gg5Hcma/rtqVludosOrqFa973yWTvSNuK9fmgdA2TGkIfV2rIzAN/Gz2vkxValqtjdF2BQPBuImnWzFp8QwgODsbV1ZWgoCBcXFzS2xxBOjJt7yoG/P2b0fO5XbIzqkUPetZukyi6UOHnz7hoosonOSiSzLZvpvLp4hEER4YlSvhVZJkq+UoyrNnntJ472CprGmNMi68Y8eEXdF82lqUntsc7eK/joLOjoldxwqMjufT0DgCZ7Z34slZLRn74pdXaX2iaRv2pvTl671KivxNJklAkmeODF1Ilf0mrrCcQCDI2lj6/ReRGkK4Ehoew8Ohm/ji2heehgeTP5kHP2m3o+t4HJtsFWIPQyHB+MhKxiSNrJuckHRuAcnmKWM25MWgqf5/fR3BkeJKVTAZV5eSDq8w+uM6S1J1U8b/ti8me2ZWlJ7YDJNkcM0ofw4n/bLmFRUcw6+Df/HP1OMcHLUyWg3Pf7xmzD65j+9VjGFQDtYtUoG+99lTwKsam3pPosPAndl0/GaujI0nEGPS4Ombmzy/+JxwbgUCQCBG5EZGbdONp4HNqT+7Fo5c+8WW+kiSBplE5Xwn29p9lU/2SVad30WnxSLPjLgxbjl414BvykjxZc1IuTxEkSbL4ektxdshEiImqLVmSsFfsiNRHW21NY+TI7EpAeIiZ8vikUWSZr+u0ZWbHgeYHA9suH6XtvCEYNBXDqyRnnaxgUA383mEg39SPrRo7//gmmy4eIiImirKehWlX8X2c7B2TbZ9AIHhzsfT5LZwb4dykG/Wn9ubo3UtJVu0osszn7zVn0WfDbbb+jH1r+P7v6UbVc+PImzUXTwKfx39fxrMQMz75gZqFylJoRFueBflZxR5FklPkTGREMtk74jdph1nn42ngcwqPaEe0Xp9khAjg6MD5qcqrEggEbw+WPr9tqnNz6NAhWrZsiaenJ5IksXHjRrPXHDhwgEqVKuHg4ECRIkVYsmRJojGzZs2iQIECODo6Ur16dU6dOmV94wUpIlofw5E7F9h9/SRPX3MI/svVZ/c4ePu80XJkg6qy/OQ/+IcG2cpUvLK5m3VsgASODcA17/s0ntGPI3cvsqPfdOwVO6vY42T/9lT8hEdH8jTwhdlx8w9vQm8wGHVsdLLCb/vXWNs8gUDwlmNT5yYsLIzy5csza9Ysi8bfv3+f5s2b8/7773PhwgX69+9Pjx492LlzZ/yYNWvWMGDAAEaNGsW5c+coX748TZs25flz4w9Sge3RNI2pe/7Ec0gL6kz5miYzvsNrWGtazxnEk4DE/zbH7l0yO2eMQc+5x7arDPqwdE3cUqCNomoamqbxzerJZMvkQt/61hHbs1blVUZh380znHt0w6jS8kN/b9acNa0MrVcN7LlxOslzmqax+/pJ2s8fQqkxHak16StmHlhrURNOgUDwdpNm21KSJLFhwwbatGljdMyPP/7Itm3buHLl30TFjh07EhgYyI4dsY31qlevTtWqVZk5cyYAqqri5eVFv379GDJkiEW2iG0p6zN4/e9M2r0y0XFFVvBwycaZIUvwcM0ef3zR0c30WPGL2Xn3fPe7UYE3a/DnqZ10/mOUzZN0Xyct18oIlMtThHmdhvBeoTIAbLhwgO/XTufhSx+Lrs+WyQX/KbsSHFNVlS+Wj2Ppie3oZAW9anilhyOR1y0XBwfMoWAOT+veiEAgSHcyxLZUcjl+/DiNGjVKcKxp06YcP34cgOjoaM6ePZtgjCzLNGrUKH5MUkRFRREcHJzgS2A9bj9/lKRjA7FKvj7BLxOJz9UvVsnsvE52DlTNXyrV9gWEBTPn4DqGbpzNlD0rE0SSOlVryrqe423+IJQliQ9L12RKu2+pWqAUHs7ZkM3K01lz/dhfdUVO+1/5K8/uUX9ab848vM6sA3/Tdt4Qix0bnazQoHjlRMen71sdX80Vt7WpEVvZ5R3kR8vZA63am0sgELxZZCjnxsfHB3d39wTH3N3dCQ4OJiIiAj8/PwwGQ5JjfHyMf1iOHz8eV1fX+C8vLy+b2P+usvT4dpMPTYNqYNHRzfGVMACFc+alZbnaRq+TJYmv636U6mqpmQfWkntIc75ZPZkpe/5k8PpZ5B/ehv5rp2FQDUTGRBEaFZGge3dqkADHJJpFqprGrusnmXngb7Z9M5WBTTobzTOxBaqmkiOLK9/W/4SetVujk4wL59libb1q4Lu/ptF/7bRkXatXDYlaaRhUA1P2/Gnymqve9zhw61yK7BUIBG8+74TOzdChQxkw4N/eNsHBwcLBsSKPAnzBTBQiJCqckMjwBP1/lnQdQaPp/Tj/5BayJKNqKoosY1BVmpZ6j/Gt+6TKruUn/6Hfminx37/eLmHGvjVExUSz49oJHvh7p2qd19HAaKm2XjXwKMCXn/9ZwqUnt9N8a+plWDAbLh7k9pi19KjVmhqTeqSoO3hKMKgqx+5dQrIwWhX3czC+dR+uPLvHylM7cbJ3oHW5uuR2zW62Qk1CYs+NU7yfRNRHIBC8/WQo58bDwwNfX98Ex3x9fXFxccHJyQlFUVAUJckxHh4eRud1cHDAweHtqUTJaOTI4mr2kWWv2JHFwQmA/TfP8vuBtZy8fwU7RUfTktUJjY4gJDKcAtlz81Xt1nxYuiZyCrdQVFVl57UT9Fs92egYDZh7eEOab9MYVAMLj26iXJ6iNpnf0zWH0Qe/qmk88Pfm73P76Vi1MX3rfczMA2vTtvzcwoSjBsWq0LhUNUZvXUhEdBQ6RUHTNKbtXU25PEXMXq+hceXpXU7cu4IsS5TLU8TmopACgSDjkKGcmxo1arB9+/YEx3bv3k2NGjUAsLe3p3Llyuzduzc+MVlVVfbu3Uvfvn3T2lzBK7pUa8a0vauNntfJCp2qNkGn6Php01x+3rEkPgkU4GngC2RJZuPXE/igTM0U2RAYHsLSE9tZeWoHl57eIUofY9F1aRW5eJ3QqAjK5ynCiftXUK3oWEhgkebOpN0r6Fi1MWNb9eTI3Yucf3zTopJ4a5BUK4ek+LzGh3y+5H+omopGwqjbVe/7FvlIW64cZfPlIwBkdcrCt+93YMSH3dEpGepjTyAQ2ACbvraGhoZy4cIFLly4AMSWel+4cIFHjx4BsdtFXbt2jR//9ddfc+/ePQYPHsyNGzeYPXs2f/31F99//338mAEDBrBgwQKWLl3K9evX6d27N2FhYXTv3t2WtyIwQaV8Jfi4UkPkJFoUKLKMo509Q5t9zpZLh/l5xxKABPo2etVAjEFPu/lDeRESkOz1zz++SeGR7fh+7XROP7xusWOTXsiSRO96ba0+r6XuyZVnd4mKicbZMTMHB8xhfJs+uFgp58gYsiRTLk8Ri5y5Mp6FWHt2H0hSkvdkUA0W3evrCcWBEaGM3b6YTotHikRjgeAdwKbOzZkzZ6hYsSIVK8Z2Ux4wYAAVK1Zk5MhYyXpvb+94RwegYMGCbNu2jd27d1O+fHmmTJnCwoULadq0afyYDh06MHnyZEaOHEmFChW4cOECO3bsSJRkLEhblncbxVe12sRv88TlVhTJ6cXBAXMo5p6PqXtXGd0G0tCI0kez+NiWxOc0jWve9zl+7zI+Qf4JzoVFRdBkxncEhYemaYJuSlFkmRZla1M2TxHmdvrRoms8XXPg6pTF4nwVc0Qb9PHChJkdnBjc5DOODDTdYyu1KLLMnE8HU79YJZP3IQET2vRly+UjCRLQrYGGxtpz+9h57YRV5xUIBBkP0X5B6NxYFZ8gf/65epyImEjKehahdpHy8U0nHfrWIdpgOqrSvEwttn7zbxLw+vP7Gb55Ljd8HgKxEYCW5Woztd13FMqZhwVHNtJz5a+2uyErIksSiqxwbNACquQvyeyD6/hm9SSjY50dM3Pw+zmUyVOIe35PqTulNz7B/kmOTy5Pxm8mT9ZcCY7VndKLw3cuWmX+13G0s2dH3+nUK1aJU/evUmNSD6PbYIVz5OHs0CVk/aGxyTklSUpRBEYnK7QuX4e/e74ZPzMCgSAhb6TOjeDNx8M1O91rtqBPvfbUKVohQTftJHatEiBBgq2txce20G7+UG76/BvdUzWVrZePUm3CF9z3e8au66eS3A7LKMiSjBKvMaNQvUBp7jx/QlRMNMM3zTF6nappBEWEsuL0DmRJpmiufEz46JtU2yMBZfMUxtM1Z6JzdlZqI/Ff/vlmGvVe6RrNPbzBZOTmrt9TDt25gKdrDpNzSki4OGZKti161cDt50+SfZ1AIHizEM6NIM1oULyKmeokiQbFqwAQHBFG31fVTv/dbjKoBgIjQhm6cTYG1ZBmybCWokgy7Sq8z+0xa2lQvDIGTUWWZGIMeo7du8yni0dQfPQnBEaEmp1r8u6VdFo0Ar1BT1anLKm2TQN++qB7AqczjicBvokvSCVNS71H/dfKsf88vdNkdZYiK6w9t49v6rU36bTKkkT/Bp8m2x5Zksjl7Jbs6wQCwZuFKBsQpBkDGn7KP1eTVpKWJZksDk50q9EcgL/O7iEyJmm9GIh1cNad389PH3Rnw4WDNrE3pWTPkpU+9dpx7N7l+L5IcYm0cf999NJyR2LN2b2U9izE9w0/JYuDU4p7UEnAiA+/5JPKjZI875bJelu0Olnh8/eaU6NQGdrNG0KUPoZCOTzNJnsbVAObLx3mjsdjHHT2RMREJTluZseUKRCrmkaXas2SfZ1AIHizEM6NIM1oVLIaU9p9yw/rZsSLtMWhairNy9Qk+tXD777/M3SKkqAE+L/oVUNsG4dtNjc9WbwMC6Lhb33J7ZrDaOlzcpKfNTTG/bOEp4F+tClflxWndpq/yAhT9vzJ+8UrUb9YYnG7nrXbcPLB1RTPDbGRkar5SzH700G0mD2QRcc2I0tSsqJrQRGhHL9/xeh5JzsHGpWoyvNkVtYpskKxXF50qJK0cycQCN4exLaUIE0Z0KgT63v9ik5OLP//17m9VBr/OQ/8nnHp6R2Tjk0cRXLlpXCOPLYwNcXElbl7B/lZrYIrSh/NgiMbU+XYaEBETCTNZ/2AdxJ6ON1qNCd7ZtdUWPmqYzoaLWYP5HnIy/hj1iTGoGfKnj95r2CZZHV1r1ukAge+ny3E/ASCdwDh3AjSnJ//WYI+CfE8g6riE+RPzclfsfXyUZNzyJJMrcLlyJM1F4OadLGVqRkKaygJq5pGVEw0C45sSnROlmVGNf8yVQnaOllBJyt4B/nZTCBRrxpYcXIHkiQxq+Mgs+M/rdKYk4MXsfWbKeRyyWYTmwQCQcZCODeCNGXX9ZOcfXTDqIaJQVPxDjJd7hz36B3bshcAXat/QCmPgtY0M81IKrHX1hg0lS2vlHshVkdo/82ztJo9iG//mpqqSIteNWCvs4vvQm4rQqLCUVWVT6s2oUetVkbHSUhsv3qc6hO/JPN39Sk7thN/HNuaKiG/aH0Mq0/vpt28ITSa3pd+ayZz+emdFM8nEAisj9C5ETo3acb2K8doPWdQAnXilGCv6Fj71S+0Kl83/lhQRCiVx3fj7os3o8xXlmSyZXKmtGchDt4+n+brl89blAvDl3Pd+z5t5w3hhu/DVM8pAV3f+5CA8BA2XzqceiNNkDdrLh6P3wzEOmeLj23h153LuGPm3z+ubcNXtVozr/OQZDuXzwJf0PC3vtzweRjf7DWulcjwZt0Y26pXujisAsG7gtC5EWQo7r14ykdzf0y1YwNQMLsntYuUZ82Z3Sw5vpVzj27g6pSF66NW80WNFvFRg4ygf1PcPR8SJNB20ckKjnb2bOw9kQMD5nBu2FK+b9CRLA5OafJg1MkKtQuXxyfIn7pTe3P7xeNUz+lk58DPrXuz6LPhlLWgsWVqkCWZ3nX/bV8hSRJf1mrFvE5DzF4b9ya34Ogmtr4WvbIETdNoOXsgd17p5MRVvsX9TP+8YwlLT2Sw7HaB4B1FVEsJUoRfaCDnHt1EliSqFSiNi5Pp3kRzDq23WvfpwMhQcv/YIoHacSWv4izvPppFXX/ilza92XzpMKFREWy/coz9N8+mbefr1xjd/CsCwoOZdfBvbj9/QmYHRz6t0oT+DTtQNFc+ACp6FaeiV3GGfdCNeYc3sOzEdu76PbVZzopBVeldty0zD6wlICzYKn83UfpoutdogSIreNgwr0WRZUq45yciJoq6U75GlmTaV6pP7zrt+N+2RRZXZkmSxMwDf9OyXB2L1z585wLnHt80PicSv+5czufvNRfRG4EgnRHbUmJbKlkERYTy3V9TWXlqZ/wbq6OdPV/XacuvbfrgYGef5HWlxnTkus8Dm9mlyDIujpk5O3QpBXN4xh8fvP53pu1dnaqIUUql/mUkahYux2ETfZt8g/15EvCC7FlcKJD9X7ut1Vbi9Yd93PbJmBZfMeLDL8g/vA2PrSTcJ0sS49v0IU/WnCw4solDt8+nuk7sv3/vjjp7ahcpz76bZxI5MJZ2G3+dnFmy8nzSDovHD9s4h0m7V5j9WXr08ya8soledwKBLbD0+S0iNwKLiYiOpMG0b7j49HaCqEJkTDQz9q/hhs8Dtn4zBeU/Zd6qquIb/NKmthlUlYDwEMr/3IXi7vn5rFozulT7gA9K12DS7pUpnleRFQrl8KRF2VpM27s6WdeqaBy5e5HgiLBEka0bPg8YtH4m264cjX+Av1ewNL+07sP7xSvTvUYLNl88zLarx1KV/FrcPT+PXvoQY9DH/5uN2rqAlad28iI0+R3YjSFLMiO3zCdKH4MiyVYpgLeTdfHRuXxu7nxcqQFT9q5KcmxKSu6j9Xq6Lf0fUfoYKuQtSvcaLUxWU8UY9BZFZCyRMBAIBLZFRG5E5MZi5h5aT59VE00+Rrb0mUyLsrUTHBu8/vdkOxgpeRNPNEcKIy6vX9+ybG0WdB5KTmc3Oi0eweoze5I9z/OJ/5DzNcn/a973qTGxB2HRkQmqxuJyhTb1nkiLsrWJMeiZsX8NM/b9xaMURlhOD/mD3n9O4PzjWwm2n+ISa62JLea09dyKJKNqGpIU68gu+3wUHasmbtoZGRPFwHUzmHVwncn5smd2xXvCNuwU8d4oENgCS5/fwrkRzo3FVPqlKxce3zbqdCiyTIuytdn49cT4Y08CnpNveOtUORlphSIrZM/kwtT23+FgZ0/V/CXJnz13/Pm7Lx5TfFSHZOWoeLhk5+n4Lciv9dRq/Fs/9t86m2ROjYRETuesPBm/Jf4BqWka/mFBbL9yjM+X/s+idXWyQr2iFWlcshrDNs1JVXl3tkwuFM3lxZmH19MtdyktsVd0FMzhSa86H9Grzkf4BPnT8Le+PPD3NnmdLEn89MEXjGn5VRpZKhC8e4hqKYHVefTS12Q0xaCqiR4AK0/tQDbRBTqtcbJzYFDjzvHKtnaygt2rbTQvt1wc/GEOnas3o32lBgkcm3svnlJnyteoyYgfyJJEv/ofJ3BsHvp7s+fGaaPJwhoaz0MC2PFaDy5JksiRJStV8pe0eO1i7vn484v/MfvgulQ5Nv3qfcyzX7eyoMtQ7HV28R3OU4siyXxSqWGSStXpTbRBzy3fx/ywbga1J/Wk8Yx+PAl4bvIaCahXtBLDmn2eNkYKBAKTiNipwGLcnd3wDwsyel6WZHK7ZE9wzCf4JbIsYzBkjDf+iJgoSuUuiM+E7aw/f4Cj9y4iSzINileheZma6IxsJ3y2ZDQvQgItikBJSCBB3aIV+aFRpwTn7vk9M3u9LMncffE00fFSuQtSo2AZTj28ZtQ5yuLgxIxPfqBjlUbY6+xSvJ0Fsfex4vQOJrXrR9k8RTj0w1y+XP4zl14TrHN2yERIVHiK5jenSZOeaGigwcWnt806h5nsHZncth9f1mqFvc4ujSwUCASmEM6NwGK612zJjxtmGv2wVzWVz99rnuBYnqw5bVbSnBLsFB3XvO9jr7OjY9XGSeZX/JdLT25z7N5ls+PiqpEKZM9N3/rt+aZe+0TVY5b0QlI1layZsiR5btFnw6k1uSchkeEJqnZ0skIme0cO/zCXcnmLArHbWU52DkY7a5tDQyMgPIStl4/QrlIDquQvyYXhyzn76Aa3fB/h4pSZBsUqU+Cnj3gRGpisudVXMUBjStUZBUuiXuHRkXxeo7lwbASCDITYlhJYzFe1W5M/W+4ktxIUWaZyvhK0rVg/wfFOVZuQkSQ/VE0jk71jsq45/fC6ReM29JpA9Mwj3Bu3ngGNOiVZFl8+b1EK58xjcqPOXrGjlRH9lZK5C3JmyBK6VGuGvRL7MLWTFTpWacyZoX/EOzYQu53VoUqjVG39KLLMw5c+Ceaskr8knao1pUXZ2mRycKJ33XbJ3q6SJZni7vnI7OCUYtsyEqJCSiDIWAjnRmAxrk5ZODxwLrULl09wXAJalq3N7m9nJHp79cyak2HNuqWdkWYwqAY+qlA/WddY+kbuYGdntkpGkiR+ad3bZObOwMadyGaiO3ehnHn44/MRBE3bw7NftxI0bS/Lu4+OFwV8ncGNu6BTdEn2erKk/5NBVc12Ch/YuBOlPAslSxHaoBr4uFID5nc2rypsCc4OmawyT3KRkCiY3RMXR9MilgKBIG0R1VKiWipFXPO+z7G7l5BlmfeLVU4gnPdfNE1j6t4/Gbd9CYERIWloZUKUV7k1bSvWZ/Olw4RHR1EpXzF61f6I4h75jV73LPAFXsNax8vtJ0Vme0d8Jmwni6NlD9lFRzfz7V9TiYiORKfoMKgGJCQalqhCYHgo3sF+5M2aix61W9OpahMc7RySe7vxHL59gfYLhvI8JAA7RYeqaRhUA/WKVMQnxJ9bzx8bzSVy1NnjPWEbWc1sp70MC+KDmd9z6sE1s/boZIVCOfJwZeSfxBj0ZPnu/RSX/a/vOZ4ahcrhaGdP5V8+556/+ZymlGBMVkBCYtrH/fmuQQebrCsQCBIiSsFNIJyb9CEqJpqDt8/jFxpIt2Vj0zyUX6NQWe69eMrzkJfw6mGlkxUMqmr2AdV1yRj+PLUzyVJoCYkfm37G+DZ9kmVPaGQ4687v54G/N452Diw5sZWbPg/jbYtrzFglXwn29J+Jq1PSeTiWEGPQs/HCQc4/voWDzo4WZWtTOX8Jtl4+QqvZA8GIrtD/WvZkxIdfmJ3/y+U/88exLRa5KCU9CrCz32/xKr4fzf2RLZePJDv/JouDEyHT98d//yIkgH5rJrPm7N5kzWMKCfis+gesOrMbTdPi85zidHdalavDup7jjSaiCwQC6yJKwQUZDgc7e5qUqk6nak3pXLVpmja27N+gA49e+uAXFogG8W/hetWAhkb/tdMSlF//lzmfDub94pWB2DwUID6X5ZPKDRjbsqdFdhhUA6ceXGXvjdO8DA/m8xrNGdWiB8fvXeL28ycJbIuLFJ1/cou+qyen5LbjsVN0fFy5Ib+06c2oFj2onL8EAC3K1mZ1j3G4ZY6NzMTlzjjq7BnT4it++qC72blPP7jGYjOOjSzJ1C9Wia19pnB5xMoE7QlGNv8CRZKT9fOgkxU6VW2a4FhOZzdW9/iZYc26pVh8IK7Bady/7efvNWdx15/Y2e+3BNtzcfd6+/njDF31JRC8q4jIjYjc2JTgiDDmHFrH/CMbeRr4ghyZs9K9ZgtalatD09+/IyDc9ttUOllhxicD6LN6ktExlvSBUlWVPTdOs+zkdnyC/MmXzYMvaragVuHyFsnyLzq6mVFbF/A08AUQ+/bftNR7DGnalfen9THpHOhkhSfjN+P+n1J7axEVE83Wy0d48NKb7JldaVO+ntmtqDj6rJrIgiObTPZcyu2SnWcTjHfM3n/zLJ0Wj8Qn2B+drKBqqtFKJVmScdDZcX7YsiS3E58Hv6TgiLZExkQlS+NHkWSKuecjp7MbhXPk4ctaLalZqBzR+hiq/Nqd6z4PEkWXFFkhWyYXLo9YYbN/G4FA8C9iW8oEwrlJG/xCA6kzpRe3fB8leMgoskwuZzeWdh1Jr1UTuG+B9ktqGN6sG48CfPnz9C6zWx+1CpdjdPMeNCpZzao2TN69kkHrf090XJEVnOzsCY2KMDvHhl4TaFOhnlXtsgYtZ/3A1itHTY6RkDDMPmbSCdQb9Gy/coyr3vfJZO9I7cLl+X7tNA7fvYhOVpAkiRiDHneXbKzrOZ5a/0lsf519N87QYvYPRMZEJSubp1guL56HBODilJnOVZvRt3579t86S5c/Rhu9RpFkhn/QXSgTCwRpgHBuTCCcm7Th00UjWHtuX5IOhU5WqJK/BMcGLaTPnxOZe2SD1dd3snNgaLPP+emD7nRePIq/zu4x2z5AlmQ0NFZ2H8OnVZtYxY4XIQF4DmlhNLIRl1tjjo1fT6R1+bpWscmafLFsHMtP/mMycuOWyZmXU3anaP7TD66x/coxovQxVM5XnFbl61rUu+lpwHMK/PRRsjrCv95FXZFkXJwyUyp3QY7fu2wyClQge27uj4v9GQ4MD2Hh0c0sPb6NF6GB5M/uQa86H9G5atMk5QEEAoHliK7ggnTFN9iftWf3GnUm9KqBE/evcvHJbeZ0/pEGJarwycLhqV5XQsLFKTOTPupLx6qNcX5Volu9YGlWnzX/cFU1FQmJHst/pkXZWvHXp4aVp3aadF4scWzAMgHA9KBLtWb8cXyr0fOKrNC9RguTc2iaxoYLB5ix/y/OPLyOnaKjRdnafN+wI1ULlKJqgVLJtiu3a45kOTaQULTPoMV2mj9295LZ6E/c9uqTgOfUmdKLRy994ud6ERrIqQc/s+joZnZ9O+Ot0fYRCDIyIqFYYBMuPLltUZPF0w9jS4creBU1MzLWcYn7n7Hk05qFynJh+DLeK1SGg7fPc+LeFVRVpXHJahYnmWpoRMREs+p0yiIN/+XhSx+UVPZQkpBYdXqXVeyxNu8Xr0zTUtWT1M1RZIWsTlkY0OhTo9drmka/NVNoN38oR+5cJCw6ksCIUFaf2U21X7/gr7OWdWI3qAZehAQQ9mqLT5ZliuTMm7Kbet0+M+clSaLQKymETxeN4EnA8wROUpzzevL+1SS3JgUCgfURkRuBVdA0jd3XTzHn0HouPr1t8XVx2wtFcnpROGce7r14avRhoqGx+7sZ3Hn+hNCoCMp4FqJU7oIcuHWOGIOeqvlLEhYdSdt5Qzj/+Fb8dfnc3F+9wccV8JpHpyjc8H1g8X2YIkcWV4ujM8bQ0Nh384xV7LE2kiSxvtcEvv5zQqIoVbk8hVn1xVjyZM1l9Pq/z+1j1sG/ARI4xPpX2j9d/hhN7cLl8cyaM8nrQyLDmLBzOXMPb8A/LAgJiSalqjG8WXcq5Stu82omTdP4uk5bLj65zZG7F42OM2gqfxzbyi+te1ucrC0QCFKGcG4EqUbTNHqt/JUFRzfF91eylAKvOm9LksTwZt35Yvm4JMcpskyjEtXiv16n63sfAnDi3hXqT+2TaP2UNI/UNA1nB+uozn5apQkjNhuvwlJkGQedPeHRkSbnsaQiK73IZO/Ism6jGN+mN7uunSJKH03lfCUs2k76bd8ao3lHGhqqqrLw6GZGNv8SiBVVXHh0M2cf3UCSJM49usmzwBfxjpGGxs5rJ9l57aR1b9IErk6ZOXr3IpIRvaA4IvXRXHhyi/rFKqeZbQLBu4hwbgSpZv6RjSw4ugkg2TkOzWb0Z+/3M6lVuDzdajTncYAvo7cuRJZjEzsVSUavGnivYBlWfzk20fUhkWEsP/kPq07v5uyjG0QbYqxyT3rVQLuK9a0yV6GceehZ+yPmH9mY6MEnSzKKpNC8TE02XDho9O9PJys0KVndKvbYkjxZc9G9pun8mv9y+uF1k5Etg6Zy4v4VAP48tZNuS/+HQdNSHQ2zFhIS/ddOp3K+EhYpLUspVuERCASWIpwbQarQNI3Ju1cmY8MnIVGGGNrPH8ajXzZhp+gY2fxLOldryqKjW7jz4gmuTpnpWKUxDYpXSRS5eOjvTb2pvXn00jfF8v3GaFGmVoImlKllZscfyOTgyMwDa4kx6OOrcvJkzcmybiNxd87G+gsHTM7xTb32VrMnI6HIMpjwiSVJwk7RcfL+FT5bMibDODVxaGj4BPuz3Uw5PMS26aicr0QaWCUQvNsI50ZglkcvfZh7aANbLh9Bb9BTo1BZ+tZvT6V8JXgREpDqnAafYH+2Xj4S39CycM68/NKmt8lrNE2j9dzBPA18YXXHBrC6noxO0TG1/XcMa/Y5Wy8fISQynOLu+WlUoiryK8XjFd3G0GXJKCSk+AiOIitIwIruo032v3qTaVa6BlsuHTYe9dM0mpV6jyl7/nzlFKatfZZiiVm967azuP+YQCBIOcK5EZhkz/VTtJoziGh9THxOw50XT/jj+FamtPuWLtWapXoNRZY5+/BGsrp1H7lzkYtPLE9cTg6SJPH3uX18WauV1efOkSUr3YyURXes2phK+Yoz++A69t48DUg0KlGVPvXaJtnx+23hh0afstFI1EqRZLJmcqZL9WYM+Pu3ZG97ZjQ+yoAijALB24hwbt5xvIP82HfzDHqDgaoFSlEqd8H4cy9CAmg9ZxCR+ugEHZHjHjA/rJuBh0t2Mtk7mk2GNYWmkWxxs303zyQ7edlyezT8QoOsPq8lFHPPx/RPvk+XtdOLWoXLs/Cz4Xy1YjySBAZVfZWVIuGaKQu7vv0NZ8fMxKhp22jVFpx9dIOahcultxkCwVuPcG7eUcKjI+mzaiIrTu5IUH5bt0gFlnUbRf7suVl8bEsix+Z1FEmm+7Jx6FP50FE1lQbFKxMeHUkme0eLrknJVlSb8nU58/AGTwKfmxynkxWK5vJK9vyClPNFzZa8X6wy8w5v4OT9qzjY2dG8TC26vvdhfDf0CnmLcf7xzWT1i0otObNkRScrlMtbhIO3zhOj6jGoKc/5uffiqRWtEwgExhDOzTuIqqq0njOI/TfPJhLaO3bvMrUm9+TC8OXsu3nG5IPEoKkYDNZJ7qw9uRcA1QuUZnCTLrSt+L7p8YXLWxy1cXHMxP9a9uLb9z9B1VR++WcpI7fONzperxr4qnZry40XWIWCOTz59aNvjJ7/rkEHui4Zk4YWQZ967RjdIrZn1AP/Z8w+uI41Z/akSF4A4NbzR9Y0TyAQGCFNFIpnzZpFgQIFcHR0pHr16pw6dcro2Pr16yNJUqKv5s2bx4/p1q1bovPNmqU+9+NdYdf1k+y5cTpJBWG9asAnyJ/f968lPbqOnXpwjXbzhzJ2+2KiYqKZd3gDFX/+DNfvG5J/eBtGbJ6HT5A/DYpXobh7fnQmlH9blK3Fup7j8Zmwne8adECSJBRZYXCTLtQuXD5JRV2J2HYC9YtVsuFdClJC56pN+ax62v6eX3j8b15XgeyeTGzbj4e/bOLjSg1M/uwZ47rPQ2uaJxAIjGBz52bNmjUMGDCAUaNGce7cOcqXL0/Tpk15/jzprYH169fj7e0d/3XlyhUUReHjjz9OMK5Zs2YJxq1atcrWt/LWsPzkPybbARg0lcXHNlOvWEWjbQ5sRdx208gt8yk5piO9/5zAxad3CI4M49FLH8bvXErZcZ256fuQjV9PIFtmlwROivLqzy3K1GJ9rwm0rfg+DrqE+TwOdvbs/PY3vn3/EzK/tg2WPbMr41p9zZLPR2Rowbx3FVmWWdJ1JJ2rNjU7tmahskk6r8ll06VDzD20PtHxKe2+I8erLavkEBIZlmqbBAKBeWzeFbx69epUrVqVmTNnArFbIl5eXvTr148hQ4aYvX769OmMHDkSb29vMmeOVYzt1q0bgYGBbNy4MUU2vetdwRtM68P+W+dMjnHQ2VG3SAV23zidRlZZjiIrFM2Vl2sjV+MfFsT8wxtZcWoHgeEhFHfPz9d1P6KiVzGm7V3NilM7CI2KIG/WnHxdty3fvv9JgmaYYVERXPO+j05RKJ27EPY6u3S8M4EllBrTkRs+D43mXelkha9qt6Z7jRa0mjMIn2B/FFmOz5XJZO9IjCGGGINl25qyJHF91BqKuSesWHsa+JwRm+fz5+mdROktE498vXu4QCBIPhmiK3h0dDRnz55l6NCh8cdkWaZRo0YcP37cojkWLVpEx44d4x2bOA4cOECuXLlwc3OjQYMGjBs3juzZsyc5R1RUFFFRUfHfBwcHp+Bu3h683DzMVhopssy+m2fT0CrLMagGbvg85ODtc9QvVplhH3Rj2Afd4s+ffXiDKuO7ExETFX+PTwJfMHLLAlaf2cPhH+bG9/bJ7OCUoo7TgvTj7ounJhPK9aqBW76PqFqgFI9+2cTGCwc5du8yOlmhUcmqNC5RjXH//MGorQssWk+SJOYeXs/U9v0THM+TNRc/NvkMg6ry17k9RMZEm52reoHSFq0pEAhSh023pfz8/DAYDLi7uyc47u7ujo+Pj9nrT506xZUrV+jRo0eC482aNWPZsmXs3buXCRMmcPDgQT744AMMRt7Exo8fj6ura/yXl9e7XQnTvWZzk46NLEmER0dZ1NU7vVBkmeP3riQ6rqoqHy8YRnh0ZKJ7VDWV6z4PGLR+ZlqZKbABzmZE8BRJxu2V82qn6Pi4ckOmfdyfSe360bTUe8iyzE8fdGdQ484WtUIwqCqLj23lzMPrCY4fv3eZSuM/58/TOy1ybAB6121r0TiBQJA60iShOKUsWrSIsmXLUq1awkaJHTt2pFWrVpQtW5Y2bdqwdetWTp8+zYEDB5KcZ+jQoQQFBcV/PX78OA2sz7jUK1qJthXrG82nSctS2xSjkWS+w54bp7nv/8yoY2ZQDSw/uZ2giFBbWyiwEZ2rNTWZ62LQVDpUaWxyDlmWY5ODf96YIO/KGEERodSe3JMjdy5w/vFNPl86htqTeyXpRBvji5otqVu0okVjBQJB6rCpc5MjRw4URcHXN2HZpK+vLx4eHiavDQsLY/Xq1Xz55Zdm1ylUqBA5cuTgzp07SZ53cHDAxcUlwde7jCRJrPpiLN83/BQnO4dUz6eTFVZ9OZZOVZtYwTrLMGgqjUtWS3T83OObsb2KTBClj+Gmr6haeVPp36AjTnYO8cnjr6OTFcrmKULr8nUtmssrmzufVG5kUWJwjMFA+/nDqDy+GytO7rS4x1Vu1+xMafctcz8dzJZLh/li2Tg6LvyJX/5Zgk+Qv0VzCASC5GFT58be3p7KlSuzd+/e+GOqqrJ3715q1Khh8tq1a9cSFRVFly5dzK7z5MkT/P39yZ07d6ptflew19kxud23DGnaNdU9ioc160bHKo35tv4nVrHNHDpZoV7RilTwKpbonL2is6iE/b8VVII3h4I5PNn//Ww8s+YEwE5W4p2TGgXLsOfbGdgplqcT9m/QAcDs74GqqfiGvERLZkfyHFmyoqFR/ufPaD13MMtP/sPac/sYsWU++Ya14o9jWy2eSyAQWIbNq6XWrFnD559/zrx586hWrRrTp0/nr7/+4saNG7i7u9O1a1fy5MnD+PHjE1xXp04d8uTJw+rVqxMcDw0NZcyYMbRr1w4PDw/u3r3L4MGDCQkJ4fLlyzg4mI9EvOvVUnGoqkq+4a15GvgiRddntndkWLNuDGzcmZ4rx7P0xHYrWxhLXPKzLMmomkrp3IXY138muVyyJRp70+chJcZ0MDmfp2sOHv2yyWQ5vCDjY1AN/HP1OKcfXMdOUWhWugZV8pdM0Vzrz++nw8KfbNLOI64DvETSzTUlYM93M2lQoorV1xYI3jYyRLUUQIcOHXjx4gUjR47Ex8eHChUqsGPHjvgk40ePHsV3RY7j5s2bHDlyhF27diWaT1EULl26xNKlSwkMDMTT05MmTZowduxYixwbwb8ERoSk2LHxypqL44MXksctF/3XTmPZiX+salsuZzemtvsOr2zuLDiyidvPH5M9iyudqzalXcX3jfaiKu6Rn5blarP9yjGjMvlDmnYVjs1bgCIrtChbmxZla6d6rrYV32f1l2Npv2CYFSxLSFwOm7G3SFmWGb9zqXBuBAIrYvPITUZERG5iCY0Mx/n7Bim+vlAOT7b2mUr5n7sQY0hdfylZkqjoVYx+9T/BwzU7DYpXSdbWwusERYTScvZADt+5EB/1ifvvD406MaltPyHS947yPPglK07t4L7/M7JlcuXTqo0p4VEAgBiDHs8hLfALDUwX2yJmHMTRCjlwAsHbjKXPb+HcvMPODUCdyb04fu9yisq+FUmmfN6inHt80yq2bO0zheZla1llLlVV2XPjNKvO7OJlWDCFcuShR61WlPYsZJX5BRkXTdOI0kfjoLNP4MRO27uKwetnomoqiqygahoG1UDnak1Z/NlP2OvsmHNwHX1WT0oXu4Om7sXFKbP5gQLBO0yG2ZYSZGyGNfucD2cNSNG1Bk3lvJUcm0GNO1vNsYHYUH+TUtVpUqq61eYUZGx8gvyZuHs5i49uISgyjCwOTnSr0ZzBjT/jwO1zDPj7t/ix6muRxlWnd5HJzpH5XYbydd22hEZFMHzz3PiIn0E1IEkyBhvk48Th5eZuVr9HIBBYjojcvOORG4DZB/+m7+opJlVfbcmqL8fS0YwuiUBgiof+3tSY9BXPQ14myLXSyQquTllwsnPgSWDS/ewAZEnm0S8byZM1FwD+oUGsObubJwEvyOWclRUnd3DWSo584rUlfm3zDYOamK8MFQjedSx9fmdoET9B2tCnXnse/ryRukVSJjCWz809Sc0RcyiSTKMSVYVjI0g1X60cz/OQgERJ5HrVQGB4iEnHBmIbtm66eCj+++xZXOlTrz2/tOlNCY8CVnNspAR/lpAkifeLV+G7BqYr/AQCQfIQzo0AiBUz2/ntdN4vVhkJLJKlh1h5+2XdRpHJ3jGREJpOVrBX7JJUQo6bf1Rz8yKNAoEp7r14yu7rp4xuG1mSTyZLMiGR4UmeW31md7K7fxvj9diou4sbk9v2Y/s3U0XDVoHAygjn5g3n8tM79Fr5K4V++oiCwz/ii2XjuPD4VormcrRzYEe/6cz+dDClPQvioLPDzsyHeoxBz0fzfqRu0Yo0KlEtvsLJyc6Br2q35sqIP2lb4X0gth9U3HkXp0z83XM8tYtUSJGtAkEcl54mrUyeHAyqgeDIMPRJVP0FhIdYXf9GAvxCg6hWoJRwbAQCGyBybt7gnJtlJ7bTfdk4ZEmK//CNEwqzV3RULVCKb9//hI8rNUxx6fOFx7eo+EtXs+MkSULTNMa27MnXddvi6pQFO0UX+9CICONp4Au2XD5CaFQ4JT0K0K7i+zhZ0NNHIDDHP1eOWZQUHyemZwp352ys6D6aRq+19hjw93R+37/W6g6OLMnUKFSGIwPnW3VegeBtRuTcvOVc975P92XjUDU1wYdu3Ed3tEHP8XtX6LDwJ3qs+JmU+rDrLxywKJ8mbv4RW+Zz4fEtXoYF0f+vaWQd0IhsA5tQafznXPd5QNfqH9Kl+gfCsRFYjTpFKphtfmmn6MiZxc3s9tKL0AA+nDUgQQfwHrVa20S5WNVUjt69xEN/b6vPLRC86wjn5g0jWh/DmYfXGbFlvkW9cAAWH9vK8pPJUxAOj45kwZGNzD+8MVkaODpZ4ZcdS6k8vhszD/5NaFQEELt9ter0LiqP75bgwSEQpJYsjpn4vuGnRvPEJEmid922nB22hO41W2BvQhxSfdU36n/bFsUfK5W7ID82+czqdsfxIp1EAwWCtxmxLfWGbEsZVAMTdi5nyt4/eRkWnKxrZUmKFdsbtsyi8S9CAqg/rQ/XvO8b7YdjCkWWkZCSfNtVJJlCOfNwc/RfQiVYYDUMqoGeK39l8bEt6GQFVVORJRm9aqBj5UYs6z46Pt9r0LrfmbZvldH2HBD7OxM4dQ/OjrGiepqmMffQesbvXMbjAF+r2v75e81xtLOnZqGyfFK5oVApFghMIBSKTfCmOTeaptF92ViWndieYiUaCQn9rKOJ+nglxYczv2eXieoTa7D/+1nUL1bZZvML3k0uPrnNkuPbeBr4Ag+XbHxW/QOqFiiVYEzvPyew6NgWsy1DnozfHK97E4eqqlzzvk+buYO56/fUKjbbKTrQNGJUA9kzu7Klz2RqFCprlbkFgrcNoVD8FnHkzsVUd9yWpNjwfHBEGEtPbGPL5SNExkRTJX8Jvq7TlmLu+QC4/fwR/1w9nuJ1FEk2u40lSRJXnt0Tzo3A6pTPW5RpH/c3OaZQjjwmozYAmewdyZE5a6Ljt54/4tPFI6zm2AAJnKyA8BAa//YtV0f+Sf7sua22hkDwriFybt4AFh7dlGqdjaxOzpx7dIPCI9vx3V/T2HP9FIfvXGDG/rWUGN2BWQf+BuDQ7QupWseS/BxN03ASoXdBOtH1vQ+S1F6KQycrdHuveaLO8z5B/tSc1JOrz+7bzDZVUwmPjmT6vtU2W0MgeBcQzs0bwJ0XT1JdrfEyPJgG078hIDwY7bVGCwbVgIZG3zWT2XvjNLuvn0rR/PKriqop7b4ll7ObybGKJPNhmZopWkcgSC3uLtmZ8NE3SZ7TyQoeLtkZ2fyLBMcNqoHmswbE//6kFlPZZhoacw6tT1JzRyAQWIZwbt4AcmTJGu88pBQJieDIcKPheEWW+XbNVNac3ZOCucHRzp6cWbJy7tFNOldrZnSsLEl8UbMluV1zJHsdgcBaDGjUieXdRlE4Z574YzpZ4eNKDTj54yLcXbInGD9yy3zOWakFg5Odg1n3KEofw9bLR1FVlbCoCFQz22gCgSAhIqH4DUgoXnt2L58sHG5yjFsmFwLCk1dFZUvcXbLhG/wSRZaJa7agVw18XKkhy7uNShTyFwjSA03TuOZ9n9CocArnzEuOLFkTjQmOCMPjxw+JiImyypqWViAWzOGJX0ggIVHhZLJ3pNt7zfmx6Wfky+ZhFTsEgjcRkVD8FtGyXG3sFJ3J6g4nO3sCX6kEZwR8g18CUKtQeQpkz02OLK50rtaUSvlKpLNlAsG/SJJEac9CJsfsuXHKao4NWC6tcN/vWfyfw6MjmX9kI6vP7ubowPmU8ChgNXsEgrcR4dy8Aey5cdps2WpgRChkEMfmdQ7dOc/gJl1oXrZWepsiEKSI8OhIi8dmy+RCQHiIVfJy/oteNRAUEcrnS//HyR8X8/ilL4uObeaGz0OcHTPRvlIDGpeoZpHcg0DwtiOcmzeAE/euYCcrxJhIKg6PjqRgdk8eB/jaRCo+pSiSzNS9q4RzI3hjKeNZ2KJxrcrVYV6nITSe8S1Xnt21iS0GVeXUg2uUH9eFS0/vvEpMllBkmYVHN1M1f0m2952W5PaaQPAuIVz8NwBFVix6D/zzizFUzV/S5vYkB4Omcvj2+QyzXSYQWIKqqhy/d5mNFw6iVw1UzlfiVf5Y0uTP5sH6Xr/i4Zqdc8OW8vl7H1q0jiV925IirhO6Rmx1VdwLzbnHt/ho7o/i903wziOcmzeAxiWrmo3G5HNzp1qB0rQoWxvZbNep5CFLMrIkmdQGEQjeFjZcOECRke2pOekrPpr3I1V/7c7LsCAcdfaJ9KYUScYtkzM7+/2G8uqcnaJjVPMeFv0W5nZNWJWV2qpIg2rgyN2LnLx/NVXzCARvOsK5eQOoVbg8lbyKmxTyG9SkC7Is8yzID0VJneDff3mvYGmqFSiNmoK3QUWWqVeskugjJXgj+PvcPtrNG8ID/2cJjj986UNETBQNi1fBXrEDwEFnx8eVG/JJ5YY0mP4Nzv3fp8K4z5h3eAN5suakQ+XGZtd7Evgi/s/uztlY2X0MWRycUnUPOllh86XDqZpDIHjTEc7NG4AkSWzqPYmCOTwB4iMocc5On3rt+KZeewA8XLLFdwNPLW5OztwcvYaDA+ZQKIdniiI3BlVlQMNPrWKPQGBL9AY9fVdPfrXVkxBVi00RfhTgS9DUPfhO2M6RgfPZee0EC49u5lmQH6FREVx8epuv/5yA24BG3H3xJFnrPw95yWdLRvNJ5Uapir1KkkSk3nrVXQLBm4hIKM7A3PR5yOLjW3jg7032zK7M/XQwj176svrsHgLDQyjpUYCeddokaLLXuVozRm5ZkOq1JSTmdR7CylO7mH1oHX6hgcm6Xicr6FUD41r14gOhRix4A9hz4zS+IS+Nntc0jes+D7jqfZ+KXsV4b2IPgiPDkhTGDI+J4vSj68laXyO2Iuruiyf0qNWaBa/arsRGTDWLI6cxBj3l8xRN1toCwduGcG4yIJqmMXj9TCbvWfnqw01FlmTmHFrPh6VrsL7Xr2Syd0zy2oI5POnfsAPT9qa8N40iK6zt8TOT96zkxP2ryY4EFcruSc3C5ehbvz3VC5ZJsR0CQVry9LUtIlP8tn8Nnao24f5/tq6sxcHb51n15Vj6vf8xS09s52ngCxRJZuXpnWavlQAXpyx8UrmhTWwTCN4UhHOTAflt3xom71kJEJ9IrGqx/91x7SQ9V45nRfcxRq+f3PZbXBwy8+uuZUTpY5K9votDJg7fucCJ+1eSlWcjSzLVCpTk+OBFyV5TIEhv3F2yWTRu+cl/AC0+OmkLzj++yYdlajG53bfxx+68eMLZRzdMrqlTdKz+cixORl5+BIJ3BZFzk8GIMegZv3Op0fOqpvLn6V08euljdMw17/usOrMrRY4NQEBECNP2rU52ArGqqQxt+nmK1hQI0pvGJaqRLbP5diyKrHDy/lUbyPT9y4XHtwmOCOPuiycEhocAsLz7KNwyucRXZf2XVmXrcPLHRTQrXcOGlgkEbwait1QG6y116sFVqk/40uw4nSzTpOR7DGj0KQ1LVI0//iTgOaX/9ynBkWG2NBP4t0eOIstomsaUdt/Rv2FHm68rSIimaXjvPMzt2X8ScOE6SiYn8rVvStHenciUxz29zXujWHxsC18u/9nsOEc7eyJjom1mR7k8hbnqfR+DGrsl3bJcbca27Em2zC5M3bOKxce2EhgRQs4sWelWowUDG3Uil4WRJ4HAWgRdv8uNaUt4vG4nhogoXMsUpXi/LhTo3ArJRkrZlj6/hXOTwZybQ7fPU29qb4vGKrKCQTUw/ePv+a5BBwD6rprErEPrbGkiELsFVSB7bsrmKUwpj4J8Vbt1fDWXIO3QNI0z3/yP23P+RNIpaPrYLQtJkVEyOVFuXH9Cbj3AEBFJ1nLFKdS1DfZurulsdcam7P86ccX7nskxme0dKZe3KKfuX8VgperE15ElOUGumyIr2Cs6Dg6YQ9UCpYBYoUHRakFgDE1V8d55mPsrNhPp60/m/J4U6t4OfVg4t2etxP/MFRQHe7zaNqHYN53JUsgrWfN77zrCwZZfo6lq/OcOsgyqSr6Pm1Fz1VRkK8uSgHBuTJKRnZsXIQF4DmmR7L38Sz+toGyeIjj2q5Pi7ajksu2bqXwoKqHSlbt/rOPkF8NMD1IUJAk0g4psb0eNpRPI38EyBd13kV93LmP4pjlGt2UVWaFZqfdY2GUYDaZ/w3WfB2lilyLJlPAowOURK4VulMAkMaFhHGzZm+cHTiIpCprBkODlJ84JAZAUBdlOR72t8/BoaNmWZkxIKBs866APjwA1id8TSaLK7yMo9k1na91SPJY+v4Xbn8HI6ezGx5UamBTs+y86WWHuoQ0AaebY5MjsSv5sHmmy1puCISqaoGt3CLpxF1VvutGptbgx5Q8w96AzGGI/1DQNNSqaox2/53j3IQRcSF6p8rvClzVb4qizN6rrZFANfN+wIx6u2Tk/bBnLu43CXrF9bYZBU7nqfY/qE76g2q/d6b50LMfvXbb5uoI3j1M9R/Di8GkANEOsQxPv2EC8YxN33hAdzaE2fYgOCrFo/gcrNqMPM+LYvOLG9CXp2gZEODcZkGkf9ydfNg+TvWxeR68aOH7/MoY0bJgZEBFChZ8/Y925fWm2ZkbFEB3NpZG/sSF3bbaVbs62kh+y0ase1ycvQktCA8VaxISEEnT1doq6wd9fsoF/KrZh/4dfERMcagPr3lxyOruxsfdE7BW7BL+DcS8cEz/qG5/n5mBnT5fqH/B84j8UzJ47Tew7/fA6px9eZ8WpHdSc9BX9104TvaQE8YQ99ubh6u1ohmR89qga+rAI7i/baNFw3/2nTL9UaRqhdx6hD7V97qcxhHOTAXF3yc7pIYsZ3Pgzi6o3IDb3IrYHVNr8kxpUFYOq8umiETz0906TNTMiql7PoTbfcOXnOUQHBMUfj/Tx4/ygiZz4crjtHjxW2Jrw2XWUw+36iYfjf2hcsjo3Rq9hUOMulMpdkKI589KlWjNO/biYQU26JBrvmsmZu2PXs6//LJqVeo8ynoVs3pk7buv6t31rWHh0k03XErw5+Ow5lqIXHjSNZ9sPmhwS9tibg61782jtPwmiP8aQbJBzYyki5yaD5dz8F03T6L1qIgsOb0Q1UXyaxcGJ22P+5ts1U1h7Pu2iKYos82OTz/i5tWVJ0G8b91ds4vhng02OabB3CR4NbFOeu71CawIv37Log8YUTU78RY7q5a1klSCOi09us+bMHibtXmEzTRwJKJwzL7fGrBW5OAJuz1vN6a9Hpeha2d6OFjd3kKVA3kTnInz92FG5LZE+fvFbXcYnkslRowJNjqxKkR2mEDk3byiaprHr2klazxlEvmGtKDG6Q2yfGTMfWhHRUfx+4C8qeBVLEzvjMKgq+2+eTdM1MxK3566OTc4zgqRTuDP/L5utX3LQl6l2bCSdjkdrd1jJIsHrlM9blF/a2Nbx14gV+HsS8Nym6wjeDLJXLWt+kBFUvYHLY2Ylee7a+HmWOTYAqkqpwT1SbIc1SBPnZtasWRQoUABHR0eqV6/OqVOnjI5dsmQJkiQl+HJ0TKi2qWkaI0eOJHfu3Dg5OdGoUSNu375t69uwOZqm0XfNZJr+/h3brxzjccBzbj1/xIIjm8w20jNoKn8c28qGi6bDirbgXX5bDLl536RzoekNBN8wXVacGgp0aknJgV8AsY5UipAQeTc2xtM1h83XiDbYTndH8OaQrVJpslUtm7ItIVXlwYpNHGrXl121PuVIx+/x3nUEQ0wMdxevM+/YvHoWVJg4iLyt0rcFiM2dmzVr1jBgwABGjRrFuXPnKF++PE2bNuX5c+NvGS4uLnh7e8d/PXz4MMH5iRMnMmPGDObOncvJkyfJnDkzTZs2JTIy0ta3Y1OWndjO7IOxGjWvh7ANmmqRloZfWBC3fB/ZzL6kkCWZxiWrpemaGQk7V2fTAyQJezfrbH3GhIRyZ+Fazg+awOX/zSTw6m0kSaLipB9pdGglXu2b4Vy8IG6VSpGnteUfLJrBgEvxglaxUZA0X9VubfN8uPrTvmH7lWM2XUOQPqgxMdxfvpHddTqxIW8dtldozY1pS4xWN9X6cwoOOdyQlOT/zGl6A0827sXv2Dke/72T/U2/5GCLr9GHmE8OdilekObXtlNqUPpGbSANcm6qV69O1apVmTlzJhArPOXl5UW/fv0YMmRIovFLliyhf//+BAYGJjmfpml4enryww8/MHDgQACCgoJwd3dnyZIldOxoXiE3o+bclBvbmave95Ld9iCO/Nlyo1f1FjcATC0SEg46O+6OXYdn1pxpsmZG49Lo37k6brbJyoRq88dS5KtPUrXOg1VbOdnjJwwREUg6HagamsGAV7sm1Fg2EV0mp0TX7KjWjpenr5idW7bT0ebZYRxzCIVbWxEYHkLVX7vzwN/bdrk3koSExM5+02n0Dr9wvG3owyM48GFPnh889a8+zasISeb8njQ6tJLMXokr9SJ8XnBzxnLu/bGOaP9AnDzdyVIkH777T5gs4U4SCZBkk1FqSadQrN9nVJ46NHlzJ5MMkXMTHR3N2bNnadSo0b8LyjKNGjXi+PHjRq8LDQ0lf/78eHl50bp1a65evRp/7v79+/j4+CSY09XVlerVqxudMyoqiuDg4ARfGY3QyHAuP7ubYsdGliR61WlDp6pNLC4hTy6va+8osoy9Tse6Xr++s44NQLE+nbB3c00yBCzpFLIU8qJApxapWsN791GOdR6IITwCNNBi9PHh4ccb9nC8a9IJzVVmjLBoq6rKzJHCsbExWTM5c3TgfMp4FkryfLZMlr1kmdoAjn1P1Riw7jdR/fYWcWHoFF4cPhP7TZxzoWmgaYQ/8eFoh++TvM7JIycVfhlAW++jdIy+SusH+6g6Z3TyHRuITexCM7nVpekNFOzSKvlz2wibOjd+fn4YDAbc3RP2t3F3d8fHJ+nGj8WLF2fx4sVs2rSJFStWoKoqNWvW5MmTJwDx1yVnzvHjx+Pq6hr/5eWVPJnptMCSvBVjIxRZoUhOL/rUa0e/+p+QxcEJ2cTHYJzgWNwIV8fMlMtTxKRT9HOrr/mqdmtK5S5IuTxFGNS4CzdH//XOKxQ75spOo4MryFIotrpA0inxDkXWciVoeGA5usyZUrXG5TEzjSeUqyqP1+0i6NqdRKeyVy9PpalD0WV5tf5/5nCrVIr3lv5K3o8ai4dhGnDywVUuPEk6NzAgPBjJTGadk50DlbxKmByjahqXn97lmvf9FNspyDjEhIRyd8Fao3pZmt6A3/HzvDx/zaL5XIoWoEivDimTkVA1ZHtd0g6OLJPv42Zkq1Q6+fPaCNvLaiaTGjVqUKPGv2WzNWvWpGTJksybN4+xY8emaM6hQ4cyYMCA+O+Dg4MznIOT2cGJCnmLcenpbaPRGw1oWa42+2+eJTQqAoiVZG9YvArda7bgnt9TKuQtxr7+s2g9ZzBPAp+jyDKqqqGhoZMVcjpnpWB2TyrlK0GRnHnxcsvFB6VroFcNtJn7I/tunkEnK7EPOyn2w3Jcy14M+6Bb2v1lvGG4lipCixs78NlzjBfHziPJEh4Na5CjZqVUJ1tH+Prhd/ScyTGSovDo7x2UHdk3/pjfyYuc6jmCwEs3448pjvZ4NK5F0b6d8T92gbuL/+bE50Pi76Hk4B4U7NrmnU4QtyXjdyxN1DMqDu21/zdGp6pNWXRss0Vr+Qa/pLSRKJHgzSHg4g0MEWZySWWJF4fPkK1iqSRPq3o9T7ce4MmG3ejDInApWYgiPTtwb8l61KjkJaGX+19/7i5aG1skIUmgaUg6hcJftqfybz8lay5bY1PnJkeOHCiKgq+vb4Ljvr6+eHhYJt1vZ2dHxYoVuXMn9s007jpfX19y5/53n9HX15cKFSokOYeDgwMODg4puIO0ZVDjznT+I2l9AkWSyZ7Flb96/IxBVTl5/yqnH15j9qH17Lp+kl3XTwJQIHtuZnccxP1x69l25RhH7lxk/YX93PN7hqqpeAf54xv8kmP3LlMqd0EOfD8bJ/vYarQ93/3OkTsXWXN2D4ERIRTOkZfuNZtTILtoiGkOSZbJ3aQ2uZvUtuq8liTxSbJETPC/416eu8qe+l3QohO2gDBERPF08z5C7z8h6EpCZeOg63c50W0IQdfuUHHCIOvdgACAoIhQjt83n/+UFA46O35u3Zt5r1qsWIJfaCCnHlylXJ4iONpl/M8+QdJY9KKhYTQSE/7Ml/1NviTo6u3Y3lIGFUmW0DSo8OsPZMrrgT40HF2WTBzr9IM5Y8jX4QNK/NCdF0fPEnjpJoqTI54f1MXJI+OlJth0W8re3p7KlSuzd+/e+GOqqrJ3794E0RlTGAwGLl++HO/IFCxYEA8PjwRzBgcHc/LkSYvnzKh8WrUJ3zeMTYh+Pb9FlmRcnDLzT99pONo5kNnBiSh9DEM2zubRy4RbcQ/8vflw1gC2XTlK6/J1MWgGHrxSEI6LCMX996bvI7r8MTr+WkmSqFO0AjM7DmRF9zGMafmVcGzSGUmnM5s3o+oNuBQrEP/9hR8nx+blGAllB12+lVjB9NX31ycuxO/UpVTZLEhMdCp6vnm4ZqdukQrcfvHYovGyJNFh0U9Un/AlHj82Z8TmecQY0qbXmcC6uFUo+e+2sjE0Dff3qyc+rKoc+LAnwTdjpSji+stpBhVUlQuDJ2HnkoUiX31CgU9b4NGoptHPGkmnkLd1QzJ75UaSJHLVrkKxPp0p3L1dhnRsIA1KwQcMGMCCBQtYunQp169fp3fv3oSFhdG9e3cAunbtytCh/2ZX/+9//2PXrl3cu3ePc+fO0aVLFx4+fEiPHrGlZZIk0b9/f8aNG8fmzZu5fPkyXbt2xdPTkzZt2tj6dmzG9ivHqD+1N9P2rgbA0c6eXM5uVPQqxtiWPbkxag2V8sXut2uaRsdFpkOAny/5H4Hhwcw7vNHoNpdBNbDr+kluWNDV2KAa8AsNJOzVdpjA9rw4epbt5VombHiXBIqTA/k/bQ7Evqn57DmWvL4yryHpFO7MXZ2iawXGyZ7Zldyu2VN07UN/H5ad2G7x+Nd/34MiQvl5xxI+WTAc1YZ9zgS2QZc5E0X7dAI56ciMpFPI9X51spZJLN7qs/c4gRdvGP/8kGWujp8X/+17S34lU16PxKKkskyWQl5Um/e/FN9HemDznJsOHTrw4sULRo4ciY+PDxUqVGDHjh3xCcGPHj1Cfu0vMyAggK+++gofHx/c3NyoXLkyx44do1Spf/cTBw8eTFhYGD179iQwMJDatWuzY8eORGJ/bwq/7VtD/7XTUF7TwQiLiiQsKoI6RSrwY9PPUF6L5Gy/cozgSNPbFUGRYcw7vJHwaNP7tRJw4NY5SngUSPJ8aGQ4E3YtZ86h9fiHBSEh0bhkVYZ/0J26RStafI+C5BEdEMSBD3vGdt41hiyBFltqbuecBYjtaZUaNL2BwMs3zQ8UJAtZlvn2/Q4M3Tg7RdfPPPh3itfWNI2NFw+y/eoxWpS17rapwPaUG/sdQVdu82z7QSRFia2UlCVQNZyL5KfWqqlJXvd0y34knQ5NbyRqp6r4HT1HTHAodi5ZyJTHnQ/ObeD2nFXcWbiWyOf+OOXORcHPW2Pn4szxbj9iCIska4USFO3VEddSRWx416lH9JZKZ52b288fUXxUBzQTyYR/dP2JbjX+LSfus2oicw6tNzv3p1WasOrMLrPjPF1z4OyYieoFyvBN/XZUKxCb8R4SGUa9qb259OROAhFBRZbRNFj15f/4pHIjY9MKUsGNaUs498OvJhvg2bu5UHPVVDyb1ok/Fv7Ul41566Z8YUnC/f3qNNy7NOVzCJIkWh9DgZ8+wjsodQ5oSlBkheZlarKp96Q0X1uQelSDgadb9nN3wV+E3H2EY65sFOz6EQU6tUhS4wrgVK+RsarCxpybV7R9fhzHnElLQQTfus/eBp8T8dQ3QQKxpjdQYeKgdBHryxA6NwLzzD+8KUHk6r/Ikszv+9cmOOaos7do7mi9ZZnwz4L8uOn7iD9P76T6hC/55Z8lAPyyY2kixwZi+0lpmka3pWMJihCy/bbAks6+hqjoBI4NQKY87rg3eC9FyqSxaORr3zSF1wqMYVAN7L5+Cndnt3Rb/87zJ+mytiD1yIqCV5tG1N82n5Y3dtD40J8U6fGxUccGwK1CCbPtEhw9cuCQPWuS59SYGPY3/fLfaPCrz6O4ba4LgyfxZPPeJK/NCAjnJp25+OQ2BhOKpaqmcvnZnQQ6JB9VrG/R3OsuHEiWLXHKqcM3zyXzt/WYsHO50bYPGhqRMdGsPCUaLtqCKP9As2MMEVEcatuXSyN/I+Tuv203Kvz6Q6wWhRGnWba3gyScH0lRcPJ0p0AGEuJ6G/APDaLGxB60mP0Dl5/eTRcbJEkiRxbXdFlbkD4U6NwKJZOJVA0JCn/1CcG37hP+1DfR6Seb9hL24KlxB0mRuTZxoZWstT7CuUlnMtk7Ipsp94sxGKjw82c88H/Gfb9nbL54CDvFtulS4TFRJrfKAHSKwtVnQizM2kT4+hFw4br5gZrGkw27uTJ2NluKNOb8oAlomkb2quVouG8pTh6JmzXK9nYU7dMJh2xZAZDsdEh2sT9LmQvkoeH+ZfH5OwLr0H7+UM4/vgVgUY84W6BpGl3f+zBd1hakD3YuWchepYzxARpc/XkO20p+yMa8ddlRrT3P/vm38bL3ziOmKzUNsTk7+vCMWWSS4UT83jVal6/LpkuHzI675n2far9+QUBYMJoUuzWU3miaRib7NzOJOyNzd8FfqDHJL929PnkxDrmyU2pQDyJ9/Yl4lrg5rRodw83pS6k0bSiO7jl4cfQcsk7Bo1FNcn9QFzklnYQFRjnz8DoHbpsWYQSwkxXeL16FUw+uEmjlrV5FViicIw+fVm1i1XkFGZuwR894fuiM6UGvtWJ4efYqB5r3osbSXyn4WRuzVZpxmO0Unk6IyE0607FKI7zc3BPo2iSFXjXwIjQQvaZmCMcGYm36qEK99DbjrePxht0mG9SZ4tqv89FHRHJu4ASTEuuXRv1O3jaNqDpzJJWnDydPi/eFY2MDtl85ZvZ3G+DUj3+w89vfcLAwn84csiTHdyGvWbAMBwbMFi8i7xjP/jH/0pwAVQVN41SvkcQEh5K9WlnTkhKShHPR/OiyZE6doTZCRG7SGSd7R/b1n0mTGd9x3/9ZeptjMYosU7NQWWoUKpveprx1GCKjUnxt9Msgrk9aSNh908mj+uBQvP85hFdb8TZvS6L00RapzPqFBzHn4DqT+XfmkCWZ/Nk8WNl9DMfuX0JCokHxKlTwSqyBInjz0EdE8vDPLTz4cytRfgE4Fy9I0Z4dcG9YI9HPWODV29xduNZsUUJSGCKjebBqKwU6t+L84Emx205Gmm0W7/95hm3XIpybDECRXF7cHPMXuQY1s3pI+nUUSY7f85clGU3TzObVvI6EhCLL6FUDNQqWZePXEzPsD3ZGIvK5P0FXbyM72JOtShkUe9Nv59mrlCXk1gOLw8L/5fKo3y2z68XLFM0vsJyKXsUtUgdu/Fs/wHTX79eRkBL87iqygp2ssKL7aGoULkuNwuKl420i/Jkve+t/Rsjth/EaN0HX7vB47Q7yd2pBjWUTifIL4OnmfQRcuM6dBX+ZLQE3hqxTCLn1ADuXLNRZP5ODLb9GMxj+/TySZVBV8n3SjCK9OlrxLq2LcG4yCDpZwdUpi02cG0VWaFqqOqu+GMuzoBe4ZXLmyrN7tJw9kGhDjMXbXLWLlKOSVwnaVqxPnSIVhGNjhsjn/pz57mce/70j/oPBPpsrJQf1oNTgHkhGqpmKftOZ+8s22ty+zPlymx8kSBWty9cll7MbfqFBSTbM/C+Wvmp4Zs3Bi5BAog0xyJJMy7K1Gd2iB+XzFk2dwYIMyeH23xIaF41VE5ZkP/xzK6H3nvDyzOXYbaRUStdpqoadS2xRQe7GtfjgwkZuTl/Ko793YoiMImuZYhTr14UCn7Yw+hmWERAifuks4hfHlD0rGbjOsjfu5KDIMpntnTgxeCElcxdMcO6B/zPmHFrPxguHCIwI4XlIgNE5smd25f64DWLf3kKiA4LYUa19bCllEhGYor07UXV20k1SAS4Mm8K18fNtZp+je3baPDmErBPvN7bm8O0LNPn9O/QGfbzcQmpxsnPAb/JOXoQE4JbJBRenjJn3IEg9/qcvsbPax2m6ZvOr2zKsArEQ8XuDiIyJYuz2P6w+rwQ0KlE1SccGoEB2TyZ81JebY/7Cd+I/TGvfH0jYtFNCIquTMzv7/SYcm2RwY/pSwu4/Mbq1dHvOnwRcumH0+twfpEJl2AIUJ0eLOo4LUk+dohU4N3QJHayo5q0RW6mYP3tuix0bTdMIDA8hwkxLFkHGwnffiVSIciYTWcbr42bxjo2mabw8d5Unm/fid+KC0Wa8GRHx2pYBOHj7vFWVfovm9OKX1l9TvWAZvLK5W3xd/4YdaVKqOnMPref0w+tksnOgVfm6fP7eh2TN5Gw1+94F7sxbbbLSQNIp3Fu8jsrThyc69+LoWfY1+NyW5hH+2IdTvUdRe/V0m64jiKVk7oKMbtGDlad3pnouCYlq+UsxZMMs9t08iyRB4xLV6FXnoyR/36Niopm2bzUzD6zlaeALIPalZ1izbrxfvHKq7RHYFk3VUrvTZDH5Pm7Ge3+MB8Bn33HO9htH0LU78eczF8xLpalD8WqT8dvuiG2pDLAt9fe5fXy8YJjV5vvzi/8JTYt0RDUYWK0rZXZc3tYNqfufRoqaprG9XEuCrtw2e71dVmeci+Tn5ZkrKTNUlmnz+ACZPC13gAUpJzgijOwDm1hla0p5lesQly+nyDKKpPB3z19oWe7flhxRMdE0/f07Dt+5kKBbuCLLqKrKH11H8HmN5qm2R2A7nu08zIFmtu3hlLVCSWounxjfXdx3/wn2NfkiNlLzeqXUqzzL2mumke/jD+IPB1y4zvWpf/Bk0x7U6BjcypWg2Lef2SQvR2xLvUEUd89ntblkSWLU1oWM2/4H36+dzvS9q3keLKpi0hJZUdC5mN4qkHQKDkk0qws4f80ixwZAjYohk1fu2FYLKUFV8T9xMWXXCizmRUgA687t45+rx/iwdM14/ZmUIiFhUBPqXRlUlRhDDO3nD+O+37+SEjP2/5XIsYkbrwFfrRwvPh8yOI/W2r7FTeDFG9z6fQUQ+4J1pu/YxI5N7EnQNM58Ow71VTXW44172FG1HQ9XbUUfHIYaGY3/mSsc7zKI411/TLetLOHcZADsFTurzaVqGrefP2L01gXMOvg3P6z7jTxDWzJ590qrrSEwT6GuH5mULtf0hiR7OIWa0ad5ncwF81Dgs1apUwgVFW82IyI6kp4rxuM5pAXtFwyj46IRbL58OFXVLPaKnVH5Bg0waAZmH1wX+72m8fuBtYkcm9cxqAb+OL41xfYIbEvkc3/uL91o+4U0jTsL/iL0wRMCLlyP3Yoyom0DEOnjh8+eY0T5B3D00wFoBjVhfuErh+bBys3c+2Odra1PEuHcZAAWHN2Eksq3uf9i0FRiDHpUTUOvGhi0/ncWH9ti1TUExik58AsURwej57MUyU+uulUTHXfIZnlzw6K9OhLp/SJF9kFs9ChnrUopvl5gHFVV+Wjejyw6tiXRNpSaDG2p/xJtiDF53qCq/HP1OABhURE8DkjcEPF1JCSuPLuXYnsEtuX5wVMp1qtJNprG9YkLCX/iY9Hw8Mc+3PtjPWp0tHGHXZa48dsyKxppOcK5yQBc93mQJg31Rm9dkCoFVIHlOOTMFt+QMilC7zzk2bYDiY7nrFMFR/fsFq3hc+Ak1yctSpF9kiJToHMrHHNZtpYgeey6fpKd105apG1jbZ6HvGTc9sXsv3XOrCigJEk42Rt3wgXpi2qq/YENuD1nFYEXb1o01tE9O/6nLmFSelLVCLp8CzXGtFNuC4RzkwFwdshk9chNUjwOeM65R5b94ApSx8PV24gJCDZ6XlLkJB0TWaej/PgfLFrj6aa9hD14mjzDXiX3ZS6QB+ci+Xi0bieG6OjkzSEwy5Lj21As6CllKbIkIVuoX+wXGsSYbYtoNWcgjnYOJnN89KqBNuVFf7iMSo7q5dJ86/jSqBk45s5pcl17N1dyN62DbG9n3jxZSnleYCoQzk0aExUTzZ3nj3n00oe4QrV2Fd9Pk8gNQEhkeJqs867js/e4SW0KzaDy/PAZ1CTyZQp3b0fV2aPQZXaKPWDs08PEnnhS6FyykDlfbAJy6L0nXB49kyPtv2VD7to8Xr8rWXMJTPM08IVVo6T2ip3FiuAaWvxWWJQ+2mj0SCcrlM1TmKalqlvNToF1yVLQC88P6qStc6CqRPr4mcwNqzBxEIqDPbmb1TEteaEo5G5cK12UjIVzk0aER0cydONs3H/8kKKjPib/8DaU/t+nrDy1gzYV6lHSo0CS3YMt9dldHc0LeUnAgdvnmLrnT848vJ68GxAkC82gms8bfVV5kBRFe3eire8xqs4dY7U3NzUyKlYx2WAATYtPRI4OCOZw+295tvOwVdYRQJ6sOa0auVFkJUVbXKqmxXcIlyQJRVbiP2dK5S7Izn6/WdVOgfWpNG1YbD+ptETTUDI54vCfLXJ7N1eqLRhHkR6xisn52jfDKY+7UedLMxgoOci2ZezGECJ+aUBEdCSNpvfl1INrCSI0N3we0uWP0dz3e8ae736n5eyBnHt881VTy+SlHTYtXYO1Z/eabISpAT//swQAVVOpVqAUf381PllCfwLLyFmrEo/++sf4AFnGrUJJk+0PdJkz4VaxVHzlQWpRo43se2sayBIXh07Fs2mdpMcIkkW3Gs1Zc3aP0fMSUNqzMFef3TX7e66TFeoXrci2q8dSZIuqqTg7ZmJMi6+49PQOjjp7WpevS5OS1ZEzcG8gQSwPVm4xXxEpSanuKfVfDOGRVPl9BE6euQh/4ouje3ZyN6mN4vBv41/F0YEGu/9gb8PPY4sbXtkhKQqaplJ15kg8Gtawql2WIkT80kDEb8qelQxeP9NkSebN0X9RJGdeWs4ZyPYrx5CwrImeLEmxzhCaxQ0w49DJCnndcnFx+ArRm8bKRAeFsDFvXfThEUa3j2qsmETBzonLwV8n8MottpdtmXqDLPyBanl7F85F8qd+vXccVVVpPmsAu66fShRxkZBwsLOjacn3aFb6PbyD/Bi7/Q+TLyYruo+myx+jU2yPhIRh9jHR7PYNQ9M01nvUIuq5v9ExkqKgc85ETGCIVdeW7HQU7/cZlaYMMTtWHxbOg1XbeLp5H4aISNwqlaJIzw44F7aehlscQsQvAzH74DqTjo0iK4zeuoBqE7qz/Urs25kljo1OVl5FeZLv2EBsMuFDfx+hc2ED7F2dqbthVmzC3Wsh27g/F/2mMwU6mXdaXEsVwSlPLvMLmus9oxGfTGyKKP9A82sJzCLLMhu+nsBXtVpjp/w3OqcRGRPN1stH6L1qItuvHGNmxx+QJTnB1nTcn39t04dbvo9TZU/+7B7CsXkDUaNjTDo2AJqqYufibHkOg6VoGoqTZZV0usyZKNLjY+ptnkOD3X9QccIgmzg2yUE4NzZG0zTuvaYYmhQG1cCqM7s5m8xKpqalqqNqaqqSkTU0lp3YnuLrBcbxaFST5le2UaxvZzJ55cYhZzY8Gtek3tZ5VPl9hEUPG0mWKfnDF+YX08CzRX2jpzMXzGt+e0uSyJwvt/m1BBbhaOfA3M4/4v3rNrpW/1eqPu7FJe739vyTW2y5dIQzQ/+gS7VmuDtnI2eWrLQuX4eDA+bwY9Ou3PNLZlXca8iSxNd1PkrNrQjSCdneDtmEXhbEVl7GBIVY9kacDDS9gbytG1p30jRE5NzYGEmSyGTvSLgNOvFmzeRsMiJkKX6hgak3RpAkzoXzUXn68CQbZFpKie+7c+O3ZYQ/NO0k52len2dbDyR5Luz+ExQnRwwRSf8cSopC7mZ1cMptQZRIkCxcnDLHC+slhUFV2XHtBCM+/II6RStQNk9hiuTMywdlasZHfVydsiBLcrKTihVZpqxnEfrW/zhV9yBIHyRJokCnltxftiGhAvBraHoD9m4usQ6OtZBlctWtQvaq5aw3ZxojIjc2RFVV9AY9HSo3SrISKrV4B5oOV1qKW+b0bx4qME3NZRONl5ZLUKxvZy6PmWl8AklClyXp0nJJUdBldqLi5MFWslbwOpef3uGFBS8Qdad8TY/lPzNo/Uxazx1M3qEt2Xr5CAAdKjdKUbVUi7K1OThgDpkdnJJ9rSBjUOrHHigO9kn+/kuKjHuD98j3yQcmpSeSS/bq5aiz7nerzZceCOfGBhy4dZYPZ36PXd/a2PWtzaE750GSkKy8KRoYEYKzQ6ZUz3PpyR02XjhoBYsEtiJX3arU3TwX+2yJHdHczeqSu2mdWG0KY2gaUS8CKD9+AC4lCv17XJLwaFSDJif+wrVEYRtYLrC0C7jhVYVknBPzIiSQ1nMGs//mWWoXKU+RnHmTta4E7Lp2Ev+woGRaLMhIuBQrSIN9y3DK4wHEtk2Jy5/L06ohdTfOolifTrGK6KnNq5Ik8n/anCZHV+OQLWsqLU9fxLaUlVlwZCO9Vv6K/JouxT2/Z2iahr1iR7QhBjtFh/aq55OdoiPGkLLeIecf3zJZYWEpGhpfrRxP87K1kkh+FGQUYgKDiQ4Mjf1gi8ufkSW8/zlE8M37Fs3hXCQ/za9uI+jaHaJfBpG5QB4ye4k8G1tSwr0Ajnb2RMYkTwlaQ0NCYvimORwbvJCu1T9k5Nb5ybg+thfV7IPrmNSuXzKtFmQkclQrR+v7e/HedYSACzdQHO3xbF4fl6IFCH/qy5PN+8jfoTkPVm1Fi9EnLgu3oFpSUmRcSham2tz/vRXJ5+JJZkUe+nvz9Z8TY7vzvva2FldtH22I4es6H+HsmAkHnT3Ny9Ri3uENrDi1w+K3u9f5r2MjS7EC7ZIkoVcNydLL8QsNZNvlo7SpIKTYMyIR3s853m1I4qTgV2XmYfcsq6Zxyp0TSZLIWrqotU0UGMHFKTPda7Rg/pGNya5qVDWV4/ev8NDfm7pFKyR7bYOqsv7CfuHcvAVIsoxns7p4NqsLgKrXc/qbMdyeuxrQkGQFTa9HcXLEuWgBHHNlwz6bK4+37EOLiDI7f7F+n1F2dD/sXLLY+E7SBuHcWJGFRzfHRgWNNkiVOfngKueG/dsl1cHOjmUnTYi9WYgEZHFwpG6RShTMkZsu1ZvhHeRP+/lDY0vFzezXK5KcqooMgW25OWOZ0YRCS8lcMC85alS0kkWC5PBrm2849eBafG+3uBcTS/Ws/MOCqF24PHmz5uJp4ItkRWyTW8wQEBbM0hPbOff4JvaKjuZla9GybG10IqqboTj77bhYx+bVy7Omxu4AGCKjCLxyi/LjB3BxyBSLxf3c61fD3tXZZvamNeKn1Yqce3zT5JuZqqlcenonwbGKXsX5o+tPdF82DkmSUtyPRgOCI8PZeuUI7xerjLNDJqqVL835YcsYtXUB6y8cMHm9QVNxyyQSi9MDTdN4vH4XN6Ytwf/kRSRZxqNRTUoO/AJ9WAQXf5pO4MUbqV6n8vRh6dLjRRAbvTn0w1zmHd7AvMMbeODvTVYnZyp6FWPHtRMmr5UkCTtZR+Vfu/Ek8Hmy186Zxc3isRsvHKTT4pFE6qORX+UJLjq2hSI587Lr2xkUzOGZ7PUFlqEPC8dn73FiQsJwKV6QbJXLGN0eCnv0LIFjk4BXbV2ujJ6ZLOXiCO8XqTE/wyEUiq2oUNx+/lA2XDhgsjzbyc6B8BmJk3dvP3/E4PUz2XjxUKrtUGSZLA5OnPrxD4q550PTNIqP/oQ7zx8bfd+zV+zwnrCVbJldU72+wHI0TePcgPHcnL40QS6NpCjmJdeTgaRTaOtzFIfslj/oBLYnJDIMjx+bG42uKLLCh6Vr8CjAl6vP7qVo+7pLtaYs7z7G7Lhzj25QfcKXGFRDos8Jnazg5ebO9VGrcbCzT/J6QcrQNI1r4+dxdfw89KH/NjZ2LVuM9xb/QvYqZRNdc33KYs4PnmS11iwAdTfNJm+rjK9rIxSK04GWZWubdGx0skKb8nWTPFcoRx5OPbhmlYoqg6oSGhXJ8E1zgNg3v1/b9DEZyB7UuLNwbNKBZ/8cinVsIMEHlTUdG4jVwjgs8i4yHM6OmZnxyQAgscCsIitkcXCkVbk6XHxyO0WODUDdIrFbkaceXGX8jqWM276Y/TfP8t/32sm7VwJJb5PpVQP3/Z+ZjQALks/F4dO4OHxaAscGIPjaHfbU+4zAK7cSXRMdEGTV0m+AZzuPoFrpcyfssTcvz18j0oy6si0Rzo0V+aRyQ/JmzZVkl10JCU3TGNCoU5LX7rp2kmdBflapfoLYhOYNFw8SEBYMQNuK77Ok6wiyvNK70MkKEhI6WWFo08/5X8ueVllXkDxu/rbMaEdda/P84Gn8T19Kk7UElvNlrVas/nJsgi0fCWhYvDLHBy3kyN2LKX7lcdDZU6doBWpM7EH1CV8yYss8xmxbRIPp31Dqfx254fMgfuyGCwdNOlCyJLPJCpFlwb+EP/Xl2oQFSZ7TDCpqVDSXRvyW6FyWQl6xVVFW5M6cP7k0fFqq5nh++Ay7an/Kpnz12VHpI9Z71OJAi14EXbtj/mIrI3JurIiTvSN7+8+k0W/9eBzgiyLL8W9HOlnHyi/GUCV/ySSvvev3NNYBsqKGtkFV8Q72jxfp+7xGc9pXasCGCwd4+NKH7JldaVfxfXI6i62K9OLl6ctWj9IYQ9IpPN164I1WHX3beOjvzcRdK1h6Yjth0RE4O2aieZlaDG7chYr5ihMVE83mS4dT/Knwv5Y9aTVnEPdftYB5PSfw9vMn1Jvam8s/rSSnsxvRBiNd41+haioRMearbgSW8+DPLSaTyjWDgSeb9xEdEIS927+R9XwfN+P0N2NQI5MnL2ASDW5MW0LJwT2S1LiJDgrhwYrNBFy4juxgT54W9cndpHZ8Ht+znYc52KJXwkbBmob3jsM8P3SaJsdWk7VMMevZawbh3FiZYu75uD1mLesvHGDblaNE6/VUyV+C7jVamHQi3DI5W+zYlHDPzw3fhxaNzf4f9eHMDk50ea3PjSB9ke3t0m4xScIQKR5OGYVr3vepPbkXIZFh8RGTkMhw1p7by9G7lzg+eAH7bp4lIDz5svruztkY16oXkfpobj9PWibAoBrwDw1i7uENjGz+JaVyF+Sq9/1E21VxKLJMuTxFkm2LwDiRPn6xTW9N5c6oKpF+AQmcGzvnLJQc/BVX/zfL/CLJSCpWo2N4tu0ABT9rk+D4k017ONrpBwwRUfGR5tuzVuJapijv71iEo0cOTn45HM2gJlpLMxgwhEdypu9YGh1YbpEd1kBsS9kABzt7Pq3ahBXdx/DXVz8zuMlnZqMjLcrWtlhAb3HXn1jSdYTZcQWz58bdJbtFcwrSh7ytG8YqjqaAzAXzUmXWSOxcLdOl0GL0uFUslaK1BNZF0zQ6Lx5FcGRooq0gg6ryLMiPPqsmsezE9mTn4U1r358n4zfTruL7/LjB9MPPoKksfyVF0a/+JyYfgpoGPWq1SpYtAtM45c4Z6xCYQpZxzJkt0eGyI/pgl9VM6bYs4d7gPcuViyWJmOCwBIf8z1zmcPtvMUREgaah6fVo+tgtseAb99jXqBvPdhwi4qmv0Z8fzWDg+cFThNx9ZJkdViBNnJtZs2ZRoEABHB0dqV69OqdOnTI6dsGCBdSpUwc3Nzfc3Nxo1KhRovHdunVDkqQEX82aNbP1bdgUV6csNClZ3aKxgeEhnH+cOMnsvzx66ctLIb2eoSn+XVdASpFsepFeHYh4+hy9haFph+xZ8fqocbLXEVifMw+vc+HJLaPSEQbVwJbLR5KlaaNIsZGV7xp0QKfoGLV1gUUaN4ERoQB8UbMFLcvVQSJhqxhFin1MzOo4kPzZhZq1NcnfqYXJX31JUfD6qBH2WRNXBck6HeXG9jd+sSxTqFtbGu5ZwkdPD1FnvQW9ojQN52IFEhy6PmlR/LlEw/UGgm/c48nGvRZ9hoVaKDZqDWzu3KxZs4YBAwYwatQozp07R/ny5WnatCnPnyet13DgwAE+/fRT9u/fz/Hjx/Hy8qJJkyY8fZpQYK5Zs2Z4e3vHf61atcrWt2JTgiPCKJIzj0VjC+XIw63n5j1gg6Yy++C61JomsCGupYpQZ92M2O2pOA0aCx2di0OncvWXuWhRljk3tf6ajuIgyngzAheemH850TQNV6csKBZqEymywpY+k5EkiYjoSBYf22L2GgkpvmeVTtGxrud4pn/cP0Fyc71ildjZ7ze+rtvWIjsElpPJ053Sw3sneU5SZBQnB5MOTLFvOlN6+NexvQsVBUmnxEeCvdo0ouqsUQA45c6F10dNyFW/mkl7HHJkxaNhjfjvNU3jyYbdJgVEJZ1C8PW7Fm192ZuLNFkRm+fcTJ06la+++oru3bsDMHfuXLZt28bixYsZMmRIovErV65M8P3ChQtZt24de/fupWvXrvHHHRwc8PDwsK3xacTiY1vou3qy2WQ9RZaplr8UxT3yk9XJsh+SRce28NOHX1jDTIGNyNuqIW0eHeDuor/xO34eSVHwaFQTt/IlONplIOEPnyV9YTIlqq6Nn0+O9yqgyyQ6RKc3DjrLnMyWZWtz4v4Vi8ZGG2IIDA/BN/gl0/auJsyCqI2Gxtd1Por/Xqfo+LZBB/q9/wlhURHYKTqha2Njyo7uh51zZq6Mm0NM0L/5VW4VS1F94c+4ljTe0FaSJMqP+57CX7bn3pINhD14ikMONwp0bkm2SqUTjXcpXojnB4zvnEQHhRIdGByfUKwZDKhmqrI0g4pD9qzIjvYmE5wz5ctNtsplTM5lTWzq3ERHR3P27FmGDh0af0yWZRo1asTx48ctmiM8PJyYmBiyZUu453jgwAFy5cqFm5sbDRo0YNy4cWTPnnR+SVRUFFFR/zoOwcHBKbgb27D+/H6+XP6z2XGKLOOgs2dwk8/4fu10zj22TLH2RUhAak0UpAGOubJTemgvAPQRkTzZuIfnh07j6J6DiCc+5vflLcB33wlO9RpJzeWTUj2XIHU0KVkdnayYLL12dcxM/wYdOH7vMtuuHLNoe6rfmikcunMhfivJHAWze9KpWtNExyVJIotjJovmEKQOSZIoOfBLivXtgu+Bk+hDwnAuXhC3ciWMXhMTHMqjdTsJun4XfXAYOWpVpNg3nXHMlfQzMOj6XR6v38W9pRtM2qLF6Lm/fBMlvvsciN36ylIkH6F3Hxt9mZJkCbeKpXCrUJIrJhKcy/8yIE0V0m3q3Pj5+WEwGHB3d09w3N3dnRs3LHs4//jjj3h6etKoUaP4Y82aNaNt27YULFiQu3fvMmzYMD744AOOHz+OkoRmyPjx4xkzxrxCZ1qjaRojtsxHkiSjFQoQq3nRuEQ1KnkVp+28IciybHGbBg+RUPxG8WDVVk73GU1MYAiSTkl1P6nX0VSVB39upcKvA8mUx938BQKb4eGane41WrDo2Gajwp8/NO5MJgcn1vX6laYzvuPA7XNm5z185wKA2V5ycfz0YXd0SehyCdIexdEhvimmKW7NWsm5gRNQX6t8vDNvNcgSBbq0purMEdg5xxYZ6MPCOdZ1ME/W77bYDp/dx+KdG4Bifbtw7vvxRsdrGhTp8TFOnrlQY/Rcn7QQTVVjVdb1ehRHBypNGULBzmmbjG7T9gvPnj0jT548HDt2jBo1/t3HGzx4MAcPHuTkyZMmr//111+ZOHEiBw4coFw549oc9+7do3DhwuzZs4eGDRPLRycVufHy8rJ6+4XkctPnISXGdDA5RiJWq6JW4fI0mP5NstdQJJmu733I5Hb9hAJxBufp1v0cbNU72dtNyaX64l8o3L2dTdcQmCcyJopPF41k48WD6GQFg6aiSDJ61UCvOh8xu+MgZFnmps9DKvz8GZF6K2qavEaxXPmY8+lgGpSoYpP5Bdbj3pL1nOg+1PgASSJHjQo0OrAc2c6OXbU/xe+oeaf4dTIXykvru3vjvzdER3Pgw5747j+RQMNGUmQ0g0qVWSMp1qdz/PEIXz8erd1B1IuXZM6Xm3wff2DVTuOWtl+waeQmR44cKIqCr69vguO+vr5m82UmT57Mr7/+yp49e0w6NgCFChUiR44c3LlzJ0nnxsHBAQcHh+TfgI0Jigw1O0aRFZ4EPOfjBcNStIZBU1l28h+O37/MicGLcHV6O9rZv21omsaFoVNsv5AEqoUJyALb4mjnwPpev3Ly/lWWn/yH56EBeLnlonuNFpR9TU9mzLaFROlNC+ylhtsvHtP09+/Y/d0M6herbLN1BKlDNRi4MGyq6UGaht+x8zz6eydB1+8k27EBiPYLTPC9Ym9P/W3zuTFtCbd+X07Es9hioBw1K1F6aE88P6iXYLyTew6K9+2S7HWtjU2dG3t7eypXrszevXtp06YNAKqqsnfvXvr27Wv0uokTJ/Lzzz+zc+dOqlQx/zbx5MkT/P39yZ37zSpTLJjdE0WWTXYS16sG5h3ZmKp1DKqBW76Pmb53NaNa9EjVXALbEHzzHkFXbtt+IQ3uLPgLxcmR/B2bi+qpdEaSJN4rVIb3CiWdaBkWFcHac/usqlz+XzRNQ0VlwN+/cW7YMputI0gdfsfOE2lJ525J4uaM5fifuJCideQkPhMUB3tKD+lJqcE9iA4IQnawxy5L5hTNn1bYPLtnwIABLFiwgKVLl3L9+nV69+5NWFhYfPVU165dEyQcT5gwgREjRrB48WIKFCiAj48PPj4+hIbGRjlCQ0MZNGgQJ06c4MGDB+zdu5fWrVtTpEgRmjZNnBiXkcnp7EbbCvWT7EVlbVRNZdw/f1BydAc++2M0x+9dtvmaAsuJfpl2ekQBF25wotsQdtXsQHRA7LqG6GirNc0TWI+A8JAUN8xMDqqmcf7xLa4+u2fztQQpI+531SyaRvCNlP07SjoFz+b1jJ+XZRyyu2V4xwbSoBS8Q4cOvHjxgpEjR+Lj40OFChXYsWNHfJLxo0ePkF/LoJ4zZw7R0dG0b98+wTyjRo1i9OjRKIrCpUuXWLp0KYGBgXh6etKkSRPGjh2bIbeezDGpbT8O3j7Py7Bgm3+I6VUDN3wfcufFE1ac2sGwZp/zc+ukNRYEaUN0QBAPVm0l8LJ53RMgVu9PUWL7UaX0Zf5VpDDw4k32NuqGGh0TGzWSJNwbVKfkoB54Nq2TwskF1iRbZhezVVWWYK5oIY59N89Q2rNQqtYS2IYshfNZNlCWUtxUU1O1BMnEbzI2TSjOqFiakJRWPHrpw/BNc/nz9E6jlROWICOhJvOJt/arX2hfqUGK1xSknNtz/uRM/1/QomMw2T3vP3h93Ixn2w5iCI+wuk1xjlPl34ZT/Nuu5i8Q2Jwui0ex5uyeFDs4siSTxcGJ4Mgw84OB7xt2ZEq775BSoJotsC07qrXn5ZkrZosOHD1zEfksaaFco0gSFSYMpNSgjJ26YOnzW/SWygDky+bB8u6jqVW4PHIqPlCS69jIkszk3SvNDxRYnYdrtnO6z5hYxwaSFYV5vHaHTRwbIL5D+dn+vxB8+4FN1hAkj9EtepDZ3tFipeL/ksXBiTND/sDF0bKthGl7VzM/lXl+AttQdfYos73oMhfKi3Nhr+RPLsGlkb/FVkW9BQjnJgPhFxqYqshNGc/CyfoAVDWVkw+uEhUjqmfSEk3TuPjTtPQ2wySSLHNn3pr0NkMAFMzhybhWX+PikLI8h+DIMH5YN4OPKhjPpXgdCYkJO5ejmupULUgX3CqWSrLP1OuEP/Lh5bnryZ9c1VAjozn40TfoI8yrW2d0hHOTgcifzcNiZdH/4mhnz6ovxlCvSEUAZMnyXsK2rMQQJCbo6m1C76Rdd9yUoBkMvDxrmey/wHaER0fS7Pf+9PtrCgERIeYvMML2K8dYemI7me0dcdDZmRyroXHf/xmPAnxSvJ7AumiaRsidh9xbsoGoFy9Nj9XrMYSFp3gtfVAoD1ZsSvH1GQXh3GQgetRqZbGy6H/xcnOnwi9d2XfrLAB5suaiZiHT+kCyJFHRqxiOdm9eIvabTEyIZbkP6YokoTg5prcV7zzfr53OnhunUz1P3OdKREw0eoMB2YKXKL2onssQPFr7D9vLtGBL0Sac6jE8Tda8t3RjmqxjS4Rzk4FoVa4ODYtXMfrB89+oTlxkRicr3PN7lkAv52ngc47dv0wme0ej86maxoCGn1rFdoHlZCnkZXHn7/RDI2/rxIKYgrTDLzTQos7eyUHVYjPzVDMvUdkzu5I/+5ulG/Y2cnPmCo580p+g63fTdN000dyyMcK5SWcCw0MYs3Uhnj82x75fHc48vE4Zz0IJQsd2io4varbk5ZRdfFv/43inJm4zSa8aEvWaUjUNTdOQJQlHnX2CXJy4XjL96n9C52rNbHl7giRwcs+Be4P30tsMkzjkyEaBzi3T24x3msN3LthEHkLVVGRJMroFLksSfeu3x06xuVKIwASRz/05N+BVT6c0LmqOCQ61SDogIyN+etORFyEB1Jrck7svnsa/SQVFhnHN+z6ZHTLxe4eB5MvmTpV8JcmexZUFhzcy48DaZK0RGhXBzA4/8DTQj7/P7yMyJoqKXsX5pl57GpesJso904nqC8expVhT43oUsvTq30aKr2BKFbKUoC+MOTwa13wjhLreZqKT0XLB0zUHz4L8LB7voLNHliTCoyPjX5Li1AgalqjKsGbdkmOqwAbcX74JzSCSulOKcG7Ske/+msp9v2eJQsR61UBoVBi/7/+Liz+tQJIkVFXl27/M9BVJAp2sEBgRyi9tevNLGyHYlxFQDQbuzF1t/M1IknAtWYSaKyfxYMVm7v6xnmj/wBSv51K6CGEPnmIIs7x8/NHaHeSsVYkCnVqarc4Q2Ib15w9YPDY5jg3EivqFRUcivybupwGdqzblj89HiKhNBiDkzsPY5pTpUbWmafidvEjO9yqk/dpWQmxLpRPPg1+y9tw+o2Fng6py+dldTtyPrVj56+yeFHUFVjWVrE7OqbJVYF3OD5zAtYkLQJ/0v32xbz+jyYk1uJUvScVJP1J6aC8sLn1LgkgfPwzhkcnK89Fi9Jz55n+s96jFjd+WpnxxQYq4/PQOf53ba35gCgmPji31/a/0xMrTO9l88ZDN1hVYjn1WF4u2o2qunESBTi1S9RmRFLdmvNl9xoRzk05ceXbP7H66hMTZRzcA2HPzTIrWkZAs1rcQ2J7wJz7c/G2ZcdE+RSbo8q0EW0LORfOnvNUCxEZ9NC1F+/ZqVDTn+v/C3cV/p9wAQbJZfvKf+Ny4tESSJEZvW/TG51u8DeTv8CGakRcgiFUT92xenwKdWlF98XhyN6kdf9waRKVhvztbIJybdMJeZz7sq6HFJxZntkt+Wa6ERJ967fHMmjPZ1wpsw8M1201HUAwqvvtOEOHzb/dfzw/q4pArexpYZ5xLI34TjTVtjKZp6A2xOVi+wQHpoj6laRpXnt3l4UvvdFhd8DpuFUri2apB0p8XkgSSRJkRfYDYrt31ts2n9trfyFmnilWqMbOWLZbqOdITsbGaTlTNX4qsTs4EmhHmql+0EgFhwey8dtyieXWy8iqHR6J33bZMbf+tFawVWIsovwCL9tGj/ANx8oh1SmU7O95b/AsHW32drKRgaxLx7Dn+Jy6Qs1bldFn/TUfTNI7du8SROxeRJIkGxatQJX9JAM4/vsnEXStYf/4A0YYYCuXwpGB2zzSvkHmdsKg3X6H2Tcf/zGWCrtxK8ufALqsLtVZOIkf18kBsHt+zbQd4tv0gMcEhqf/ZkYjdDn+DEc5NOuFgZ8+gxp0ZvnmuyXEfzhqAk70DN58/NjvnewXL0LRUdbI6OdO+UgPyuuWylrkCK5E5X26ToWYASZFxyp0w2paneX0a7lvGpZ+m8+LIWVuaaJTooNB0WfdN596Lp7SdP4SLT27HSzIYVJX3Cpahd922fLn8Z4D4ber7ft7c9/dOt60hB509+bN5pMvagliCb91nb/3PMERGJT4pSeSsWYHczeoCEP7Ul/1NviDo2h0knWL288USSg7+CodsWVM9T3oiuoKnY1dwVVXpvWqiySZ1siSbFdwCsFfsCJ62Fwc7eytaKLA20QFBrM9dGzUq6eRwSVHI27Yxdf76zegc4U98iPIP5NG6nVwdOzvVNsn2dqjR5suOW9zcgUuxgqle713iZVgQ5cZ1wTf4ZaIcO0WSY5vdakm3QElGo3ir4uXmzqNf3nz5/TeZ492H8mDFJpOOSpPja8hWtSz/lG9N8M17VnFqlExOlB3Tj1IDv0z1XLbC0ue3iNykA5qm4RcaiCRJzOo4kA0XDvAiNDDJsZY4NgDRhhiCI8PI+cq5iYiOZO25fZx7dBN7nY7mZWpRt2hFoWuTzti7uVJx0mDOfjsu0TlJUdA5Z6L8z9+bnCNTXg8y5fXAtXQRHqzYTPgj71Rp4ajRMdi7ucRGZpLYLpMUmRw1KgrHJgUsPLoZ7yC/JBvimmu1ohEbRYnWRyfLydHJCpIkoVcNKJKcbCHAxwG+PPT3FgrF6YRqMPBw1VbTycQ6hQd/biXKP5Cgq9ZRE3Z0z05bn2NWmSsjIJybNERVVeYeXs+0vau58+IJAIVy5DHq2CQXnaygaRozD/zN0I2zCIuOxE7RoWkak3avpHK+EmztMwUP1/RNTn3XKd7vM+xcsnBp5G+EP/o3cTPX+9Wo8vsIXIoWsGgeWafj/Z2L2FntY2ICg1Nlk/b/9u47rKnrjQP4996bkLD3VJClKA7cCG5Fce+9rdVq1Wq1Wu3Qqm2t1tpftba2zmq17r1xL0RFVEREQGTI3huS3Pv7IxhFyIKEeT7Pw9OSnHvuSQzJm3PPeV8OoGgKHEUD7yUOoxgGjK4A7besqFT/9dXee+fLDWxUVaRG+geaorGo93jo6giQVZALV8uGmNChL+Yd2IADgZfVOm9IQhQJbqqJpKBQ7syuDMehKC0Db05f1cilKIrHoNH4QZXqo6YhwU0V4TgOM/b+gN33zuL9et2vUt9opH8HUxs8eROO6XvW4HXau2q+Ism7DLhP4sLRZ9NnCPrqH/BIkq5q5Tx1OJwmD0V64DOIsvNg4GIPA8eGavdj1NgRDqN9EblNvczVH3obHOlYmKI4NUN6I0XBbmB3tF67GMburpXqv75Ky6u67bQcx8LJwhafdh9V6vaebu3VDm50STHdasPT1wPf1AiiDEVfWCjoN2qAgvjkyl+7pChQDIMmcydWsqOahWwFryJngm9j972zAMq/vl5Z/Zp3Qp/fPisV2HxIzErwLD4Sp4Nva/z8hPoomoZ5h1aw6e1VocAGkAbNSVfuaWxMxakZMGjsiP6PT2JE0l10P/knCWwqobGVvUoVuDVlYIvOsv+PSo3H0mObsfTYZrX6MNE1hJdzC00PjVARRVFwnTlGYb4aTiKB8/QRMPVoCk7FpQsfnET6Q1NgdAXofupPGLo2qsSoax7y9V0LYtOT8Net4zgXchciiRhdXDzwLP4VGJouVblbkx6+fq7S9DdD0zjy6CqGt+6hlXEQVSv7xSvkvlK+k04dueGvkXjFH80WTVf5mOLMbLz8/V9EbDuMwsQUCCxN4Tx9JNw+mwKhpZlGx1ebfNJ1OG5GPFbYRtVNA8q0sXeTXUo6/+wuhv/1ZUlRXfX6Xtp3EoRk5qZaNVsyAzGHLyA/NqHcS07uX86EUWNHCKYMxePlv0g3BKjw/k8xDKy6d4COiRE4loVl1/Zwnja81u+MKg8JbjTMLzQAQ/9cimKxSLZg8EVitMqL+miKkgUpb6v2Klt4CACP4l6q1L+EZZFbpHqNIaJmS/UP0kq/LzbuUjm4KUhKhV/n8ciNipMtSC54k4zna//Cq13H0Of2/grPTNV2Y9r1xu57Z3HlxYMyXz4oUOjfwgsxaYl4lvAKPJqBpKRiN8tKc1WpM8v784h5AIDErDSM+GsZiiVitbeTL+g5Fl/2nazWMUTlcSyLtAfBKE7PhIGLA4yaOKHv3QMI/HwtYo9ckAU4jJ4QJi3dILCxQHFGFgTmpvDasw53xi+W5s9SsghZx8wEXnvXQ8/OuqoeWrUhwY0GJWWnYdifS1EkLi71RqZqYONkbgcLAxNEpMTCSKiPSR37IasgF1tuHFX4JqevI0ResWpJtxiaRjMbR5XaEjXfq93HtNJvQXwyOI5TaXfdg9krkRf9psxOK07CojApFf5Tv0SfG/u0Ms6ajsfwcHrOBqw8sw1/3jyK7MJ8AICpniE+6zkG3/SXBpBnn93FsaDryC3Kh7utE3zdPdHtl9kqnYOhaDSzdURPt/YAgO13Tqod2DS3dcbRWWvhZlO3Lk3UBq/3n8bj5b+U2lxg4d0G7X9fgS7/bUTm13Nwa+R85LyMgqRIhPTAZ0i7/xRPlm9Ep11r4ThuIPQa2uD5um14c+Y6wLLgGehBUlBYqqq4ecdW8PpnXb0IbAAS3GjUttsnUSgWVWh3BE1RmNtjJBb7lF7U9SrlDbbcOKrwWFUDGwBgWQ4fdx6i9viImoeVSJBy+5FqjRnpLiiTNu7IDHquvL2KKQPy4xIRd/KK3ClxTixBys2HyAwJh0nzxqqNtY4R8HXw0/C5WDlwBp4nvAZFSYOJtzmp4jKS8TwhCno6AjiYWWNiR180tXHEx52HYvvdU0qDFIqi0NutPZJz0mFtZI5rLwPVvsz1kfcgEthUg4hth3B/1rdlbk8LeAK/zuPR585/CJjxNXIio6V3SCSyr7lsYRHuTliM5Ov3YeHVGt57fwajrwtOJAYjFKAwNR2Jl/3BFhXDrK07TFq6Vd0DqwFIcKNBl188rNC1c4amYaZnjOleZbfiOVs2QJ9mHXAp9L4mhoi1w+bA1cpeI30R1YstLFI5zbr7FzNgP8oXRakZuD5gltLjLDp5qDRrk/4oRKUxpD98Vm+Dm7d0dYRo16ip7HeO47Dm3E6sOrsDFACapsFyHL4/vwvTvQbh93FfgMcw+OvWCQAcKFCQcCyoDy5XiVkJNl8/gh13T+P8vF8rlHl/YAvvSj8+Qj3ivHw8+vzHcu/jJCzYYhECPv4aGYq+jHAcIv4+gIi/DuDBnO/g8cPnaPr5NACA0MIMjuMGftCcQ/KN+0i99wQUQ8O2bxeYejQtp+PajwQ3GiR+b9u1PG/fmPglW7FFEjHsjC1xft6vMNM3LtP+p4t7NBLYNDCxxMZRCzCmnU+l+yKq3ttaVBT93s4bHgOKzwcnUpxdmNLhw2PtYuRFxcGvywSVgpGW380HAIjy8hF/5hrE+YUw79iqTIBC6/BVGj/NJ281H/rjxlGsPLNN9rvkvUsIu/3PwkCghz/GL8XX/afhWNB1ZBfmoVgswupzO8v0xXIs8osLMXDLYsztPhI3woNU/qJlJNSHG7lUXeVij12COE/++kdOIkHGIxVmWUv+nCUFhXi0aC1oAR9NPi27rTsrNBK3RsxD9otXoBgGHMvi8dKfYdTMBW03Loetb5c6leSVvONowMukGKw8sw13XwUrbMejGfi6d8Kkjv1wMyIIFCj0cmuHIR7dZMHO+y49D8DyE5VPrw8AH3kNJoFNLRR36gpCf9kpqydl6d0WTRdNh00fb1zznaE0sAEAx4mDQVEUXv6xX6VkX63XfQHzjq1wbcBMJFy4VSoYMnCxh/f+jbDo2Eo2HkZXCEmB/EujFI+Bda9OSs9bn4glYqwpJ0h5iwOHP28exbcDpqOBiRXm9xwDABi0ZbHc3VUsxyGnMB8CngA6DA9FYpFKC5INdIQ49eQmBrbsDIaWv/2Y0Ky8mASN1YJ639NvfoPLjNFgBO9K8RQkJONyt4koLsmd835G8+zQSFzv/zGMmrnAc/v3sPRuq9HxVBeS56aSgt9EoMNP03H40VWlbyRiVoJFvcdjXIc++GP8UmwZvwQj2/YqN7DJyMvG6G1faWycP/v9i8x8xRXIiZrl6XebcXPop0i980haDZzlkOIfhFsj5uFy14lIC3iitA9GV4hWJbMwb05fVVqmwcDZAY3njMfZFoOQcP5mmVme3MhY+HUeh7SH0kCeb2SAJnMnyF+jQ9NwnDxUVuGckLr/+jmSctIVthGzEpx79i4d/v3XITgfclfJjAyHhzGhOPrJT+W+r5QnITsdQ7cuhdt3YxBZkjmd0D6hpVmpBb+aUpyRhcQr/qVue7llH4ozshT+/We/eIUrvabK/rZrOxLcVNLMf9cir7gAEgU7ongl34bWDvsUvZq2V6nfr07+iezCPI2MEQAKxcU4Q5L31Rop/kF4tup3ACj9Bljy/xmPQ5W+MeraWaFf4DHoO9gBAFiRCpdNeTRCftqGgjj5ySA5sQQP566W/e7x4yLYD+9TcjxT6r82Pl7o8Dsp3fChvGLl6RgoULK0DVdfPESXDZ8o3azAQXqJakALb4SuPABniwZKz/P2S9nr1AT0/HUu8kiqiCphP7Kv1i7XFqdnlvo9as9J5YEUx4ETi/F42S9aGVNVI5elKiEk/hUCXocobdezSTusHDQDnV08VOo3pzBPls1YU2iKQmZBrkb7JLQnfMu+Sk9ZN//qE+RERCPt/lMYONvDwruN3KRggDQgMe/kgbD/7Vbad9r9p8h9FQsDZ3vQfD66HNmElFsP8WrXMeTFxEPX1hJOU4fDprdX6XVCBADAzbqR0qrfHDi42zpBwkowefd3Cr9AvUVTFLqUvM84WzbAP1O/RbdfZquULUfCsYjNSMJ/Dy7h4y5DVXocRFmSwiLEHD6P9KBQMAId2A3sDsvO7cqsZxGYm8JtwVSE/rxd42MoeltCpUSxirXnOAmLpCv+yI9PqvVbxklwUwmhia9Vaje5U3+VAxsAiEx5g0KR6gXzVMFyHFxU+BZH1AxpD4IrfS0+aMnPpdbC6DawVtgnJ5bg9b7TpQpnKpIflwihjQXC/9iP8K3/Ie91PPhG+nCcOARNF02DgRPZlSePg5kN+jf3xsXQgHKDFpqi4WRhix5N2uJ8iD/is1JV6pehGCTnpOPjvT/AzsQSUzz7Y9eUbzHj3x8ATrWEoEeDrpHgpoISL9/F7TELUJyRDYrPA8eyeP7T3zD39ED3U39CaFW6aHHW8wiApqSXnTXo6YpNcPl4NPgG+uBYFoyuEOIc1a8EFCam1vrghnylqgRDoZ5q7QSqtXtLwFNxB4oaK9ttjc3R191TrXEQ1ef9xYAV9eEi34L4ZNnaGIqR86evxhoARl+Iy90nIejLn5EbGQtOIkFxRjbCt/6Hc62HIT3wWYXHXh/8Pu4LmOkZyS5bv8XQDAQ8PvZO+w4URSEsKVrl+lQiVozfrh7CP/fO4ccL/6DxytF4FBuGV6uP4ev+01TqIy4zWd2HQgDIDA7D9YGzZLMknEgs+3tKu/8Uft0ngX1vzUvuq1jEn7uh8cAGAMS5edIvKgAeLf4JRclpah0vtLHQ+JiqGgluKqF74zYw1jVQ2EZfR4g+zTqq1a+bdSPYm1opbfeR92CV+qMpCjsmfU12QtQiDYf5yA9AAJWT7JXCcbIFwpVdyGjg6oCof05Kc3B88ObMiSWQ5OXj1sj5EBcUQlKk2VnIusLJwg6By3djuvcgCHnSYJahaQz36IZ7S7eDpij8438WL5Ni1MqfxYErqSkl/SDddO0Q/gk4h0+6Dlfp+A+DLUI1z9dvlwYv5cUqHIecF68Q9ts/sptS7j5SOU+VuiiGQfqDYOTFxCPsf/8oP0B2HA1rH69aP2sDkOCmUoR8Ab7qN1Vhm6V9J0NfoKtWvyIVUqd3dW2D38YsgoGSvg0Euri6cAv6kyRdtYrrJ+PACAVAeetVaBqMrgAWndsAeG8Whq66HBVtNy5H5I7DcoMkTsIiLzoeh/Q8cFDYEhc8RyPm8PkqG19tYW9mjb8nLkfGRj/ErT2FrI1X8KXvFEzYuRKd1n+MaXvWYOut45U+z/pLe5FTUvpBmRZ2zpU+X33DcRxijlxUOvMZvGKTLGdVhb6gqIwCxech5Ke/VT+EpkHxeGi9drH2hlWFSHBTSUv6TMJX/aaCpmgwFA0+wwND0aAoCot9Jshqx6jjSNBVxGWmKGzTxaUV9HSE+HnE/HLvp0CBRzM4P+9XdG9SN/IW1Cd6DazR48J28A31pW+CdMkPRYGnr4se57bB5/q/6HL4N9j4eMOwiSMsO7dDwxF9ZTuVtIEW8OH930boNbSBJF/1sh/pD5/h9piFePLNr1obW20m5AvQwMQKr9MS0H3jHLxQcT2fqnKLCvAyOQY2RuZK2w5q2UWj564POJaVZgxXQpxXgIRL0l2rVl3bay3A4cRiWPf0xKudikv3vM+4mQt6X9sD8/YttTKmqkYWFFcSRVH4YegcfNp9JP4NuIA3mSmwNbbAxI6+cDCzqVCf/wZcKFUdvDwHAy/jx2FzMLvbCOjw+Fh+4g8k57xbIe9m44A/xy9FF9fWFRoDUf2surTHsJjriPr3JJKv3wfHcbDq3hFOk4dCx9gQAOAwqh8cRvWTHfPqn+OIO3ZJK+OxG9gD3U7+AZphkBkSrt7BJd9WQ37YCrsB3etMojBNW3nmbxSJihUu/JWXxE+ZIrEIC3qNxVcn/yx3ZpimKFgYmGB46x5q913f0QwDoa0lChMUfykFRSEjKBR2/bpB38EO9iP7Iu74ZaX5p9RBMQz0HRtAlJUDVsVLwj0v7YSNjzfJUEyU1cDECl/6Tin3vmKxCMcfX8fJJ7eQLypESzsXfNx5CBqZ25bbPjU3U2k+i/S8LNn/f+Q9GJM9++NmeBDS8rLgaG6LDo3c69QLtb7iGxmgyacTy02nXh77EX3w4NNVkORrOFcJBXT48zsUJach/K+DiD16UZrCXc03ZYrHIPyP/SS4KUd2QR6OP76h9G+/Z5O2uBEeBLEKW8Pf527rhKEe3XA38ilOB98u9QWKoWno8gU4Nedn6Ki4oYEozXHcQLz4dbfiRhRAv7dZwHPb98iNikNGYIj0EjSrRtBKUQDHvfs7LPldt4E1el7cgQeffqdyP3UtsAFIcKN10WkJ8PltPiJS4sBQNCQcizPBt/HjhX+weewifNp9VJljXK3s8TguXOGbl5OFXanf+QwPvZt20Pj4idqFb2iA1uu+QOD8NRrtt8WKuSiIT8a1vh9BnJv/bt2AmjixRFpskygjPT9LaWADANZGZvik63D8deu4SgEOQzPo5NQc7rZOAIDjs9dh/4NL2HL9CEITX0NfoIvx7ftgfs/RcDS3U9IbIU/LNQvwcss+sMUKSqKwHGz7dUVxZjZ4+rrQMTFC3zsHEHP4PF7tPIrM5xEoSlK+s8ltwRS4fzkTxVk5iPj7EDKfhoGnrwf74T5wGDsAPF0hRFmq5TWrazWl3qqSNTdbtmyBo6MjhEIhPD09cf++4kKQhw8fRtOmTSEUCtGyZUucO3eu1P0cx2HFihWwtbWFrq4ufHx8EB6u5jR5FZCwEvhuXojXaQnS30umkiUsC5ZjMffABlwI8S9z3Medhyh903KzaiT7f5Zlcel5ANac24kfz+9GYPQLDT4KorbRtTaHvlND1Q9Q9MZGU2ixYi6aLfkY1wbMhCgnr8KBzVuMrrBSx9dV+jqqPS/xman4qt9UWBiYKN3ZxKMZGAn1sX3Su1IuDM1gsmd/3PtyB7J+vYL4n87gl1ELSGBTSXx9PXj8JH8xLsXQ0HdqiEsdR+GIaQccMmgD/+nLkR+bAMcJg2HRuS2K07PkHv++l7//iyff/A/6jRqg3cbl6H15N7qf/APO00aAV/L3Zdy8MaBox2WJVmsWqPYAaxmtBzcHDx7EokWLsHLlSjx69AgeHh7w9fVFcnL5uRTu3r2L8ePHY8aMGQgKCsKwYcMwbNgwPHv2LmfG+vXrsWnTJmzduhUBAQHQ19eHr68vCgtVX+BYFc49u4uwpGi5gQpD0fjp4p4yt/dya4/eSso0HAz0w5O4cAS/iUCT70bDd/MCrD67AyvO/I32P01D1w2fIClbvdwGRO335JtfcXvMQuRFxytvzNCgBTqw7NpOWt2bpsE3MYTAwgT6rg5oMn8ShifeQatVnyFq9zGI0rMUbl3lGxnAqJlL+Tu83qJpOIz0rcAjq/tUmbUBgNDEKCTnZMB/6Tb0adYR74emOgwPTMnzL+DxMaXTAAQu342mpOp3lWi6cBrcv5wJQLr2BdS7UiSgGeRFx8sqgbPFIrz+9yQutBuBB3O+Q8j3f0pz46iAk7B4tfs4bo9ZIHdnbePZY5Xu3nJbMKXOLCD+EMUp23NcSZ6enujQoQN+/11aJ4dlWdjb22P+/PlYtmxZmfZjx45FXl4ezpw5I7utU6dOaN26NbZu3QqO42BnZ4fFixfjiy++AABkZWXB2toau3fvxrhx45SOKTs7G8bGxsjKyoKRkZGGHmlZs/evw447p5TOwuT9dh16Jd/aJKwEG/z24bsz21Eolr8YjEczGN22Ny48v4fswlxIPvg2zaMZNLF2wKPl/0DAr3xCOKLmS/EPgp+38tf/WwYu9uAZ6CPziXSmjxbowLR1U5h4NIOhiz0cJw6BXgNpvouTLj7IexWrtM/B4X4433oIxAVFZdYPUAwNnqE+BoddLJOplZCuzTP6vBeKxIorvVMUBSFPB7cW/4V2jZoiOi0BoYmvoacjRCenFuA4DlkFuTDWNSB/+9UkKzQSkTuOIPdVLARmxsgMfom0h8/KX1ND06VyUKnL5+Y+6c6r9+TFJuDR4p8Qe+RC+Xl3KMCmbxf0OPMXaF7tWp2i6ue3VmduiouLERgYCB8fn3cnpGn4+PjA37/s5RgA8Pf3L9UeAHx9fWXto6KikJiYWKqNsbExPD095fZZVFSE7OzsUj9VoVjJm9SH7TiOw6Rd32H5iT8UBjaAtGLwscfXkZGfXSaweXv/84QoHA26pv7AiVop/M//FG4Dp3gMzDq0hPf+X+CxdhFyI2ORGfxSdj9bVIy0gKeI/PsgHi/7BScceuDx8l9QkJyGvCjVqkXr2dug58Ud4BvpS7+1Moz0GywAHTNj9PLbRQIbOXR4fHzkPRiMkmzEHMehWCzCvIMbAACNzG3Rr7kXujVuAx0eHwK+DqyMzEhgU42Mm7mg7YYv0e3Y72ixYi7SHgTLXyzMshUObCgeg6i9J0vdlv8mCRc9RyPuuF+5gQ3PSB8ePyxCj9Nba11gow6tBjepqamQSCSwti6d7dDa2hqJieVXHU5MTFTY/u1/1elz7dq1MDY2lv3Y21dNzZu2Dm7lBh7va2RmI8tyfD7EHwce+qlU5A4AipQEQDRF478H2tkWTNQ86YHPlNaOKohPQsMhvRDyw1bpWht5r0+OA0rq4jxesl6lN199xwZgBDqw7NwOw+NuouPW1Wg0fiAaTRgEz50/Ymj09To7Ba4p3/SfDisjU6XlFiQci3tRzzSeD4fQvKyQcK1lIubEkjKlFYJXbkZRSrrc9wJJfiFcZ40Bza/bu+LqRRK/5cuXIysrS/YTG6t8el0TJnv2hy5fB/KWa1IUhc96jpGtVN9685jserkmsByLtPyqmaUiqh9PT3kmbEYoRPSh8xDn5qv8hhutYmZhUW4+znkMwYO5q5D7+g1cZ42F996f4b1nPVymj5QtdCTkszOxxL2lO1TOEvwqVYW1VUS1ooUCrfVN8Rjo2b9LKSLOy0fUvycVf8lhWVndqbpMq8GNhYUFGIZBUlJSqduTkpJgY1N+gjsbGxuF7d/+V50+BQIBjIyMSv1UBWNdA/w3Yw0Ymil3V0M/906Y33OM7PcXia+VzvSog0czcLNy0Fh/RM1mP6KvwsW8FEPDYZQvcsKiQPFVn45mC4pkl5YUKU7NQObTMET8fRDnWg5G+F8HVD4H8Y6DmY3KRS7N9KrmvYyohErWcVOEE0tA6/CRdEOa5LMwKU1p4j6aYZCrwvq52k6rwY2Ojg7atWuHK1euyG5jWRZXrlyBl5dXucd4eXmVag8Afn5+svZOTk6wsbEp1SY7OxsBAQFy+6xOQzy64eistTDRK11gk6YoWBuaQSR5tzreRMNvVGJWgpldhmq0T6Lmcvl4NHSMDcovuEnTYIQCNP50AniG+uolCwNg0aWt4kKe7+HEEoDj8GDOd0i991it8xBSA5p7yzYZyNPIzAYdHd2raEREReWEv9Zq/y/+9w+u9JiMs+4DkKLC3xvHctAxM9bqmGoCrV+WWrRoEbZt24Z//vkHoaGhmDNnDvLy8jB9urTm0pQpU7B8+XJZ+wULFuDChQv45Zdf8OLFC3z33Xd4+PAh5s2bB0B6KWfhwoX4/vvvcerUKQQHB2PKlCmws7PDsGHDtP1w1JaUnYZP9q9DRn7phEosx2FPwHmM/GsZOI4Dy7IY3EqzNV1mdRkGL2eyxqG+EFqaodfl3dAxMwEgnbJ+O+PCCAXQa2SHU6598Oz7P9SuCl6YlAZ9R2nuHOrt7JCSvF8UQ+OFGhWJiXcMhHpK69L9OHQOaBUvYydnp2PT1YNYdnwL/nflABKzSJqIqsKocLlYpiK59Eq+qOSER8N/ylKlzTmJBI3GDqjAiWoXrS+VHjt2LFJSUrBixQokJiaidevWuHDhgmxBcExMTKk/UG9vb+zfvx/ffPMNvvrqKzRu3BgnTpxAixYtZG2WLl2KvLw8zJo1C5mZmejSpQsuXLgAobDmXdP/7eohpORmlHu5ieVYXHh+D7P2rcW5Z3cRn5WqkXPyaAbrhs/Fwl7j6mTmSUI+s7bNMTT6GmIOnUfcqSvIi45HUUo68mMSkP0iCmBZcCLIUrWrKufFKwAA38QQRm5OKErNQFFKBkTZ8rOgcmIJEkuKBBLqW+Y7BWJWgu/P7YJIIgZD0xCzEhgIdLFx1AJM6Kg8XxDHcfjxwm58d2Y7WI4FQzOQsBJ8cWwTlvtOxerBs8h7hJbZDegOiscDJ1Yhh00l1h2rWgql4bDeMHKr+5XftZ7npiaqqjw3AGD75QAkZqfLvZ9CpV7P5dr/0SqM70ASpdVXksIiBMz6Fq//PSW9QZN/4hQFXVtLDI7wwzXfGUi59VBhc76JIUZnKG5DKJael4VjQdeRnJMBezNrjGjdA/oC1WYDNl09iAWH5VdiXzvsUyyTUxOP0JyHn32Pl5v3VvcwAADe+3+B4/hB1T2MClP187vubnKvIVJzFafTruzHDgUKHDjwaAZiVoI5XUegR5N2leyVqM38pyxFzNFL2tl+ynEoiE9GzKHzsOrWHql3H8m9xEXxGFh1I/XOKstM3xgfV2DtXJGoGKvO7VDY5sfzu/FZzzFK1/cQldP2ly9RlJmN6A9y0lQHvqF+dQ+hStSLreDVycbIrFLHlzdhzKMZ2BqZ45eRn6F30/Zo1cAVDUwsQYHCn7eOwW7ZIPT6dS4Cop6VczRRl2UGhyHm8AW1FwyrhaLw5sw1uM4aK11/I+eyBieWoOnCqdobB6HQzYggpOcpTgWRU5QPv1DFtf6IyqP5fHjt/BGMgV61joPRE8Kqe/34wkGCGy2b2WWY0oRcigh40iyjvPe2k7tYNsSNxX9ikc8E/DLyM7xKfYO4zBRw780D3QwPQtdfZuP6y8DKPQCiVok+cE5hlmKN4DiwRcXQMTFC2/99BYqmS53z7f97rF0M656dtDsWQq6sgjyV2mUXqtaOUA3HcUi86o+7U5bico/JuDNhEeIv3MTzddshyc2vvoFRFNwWTAXf0EB52zqAXJbSsvk9RuOfe+cQk56otMZUeayNzPDn+KW4GfEYFCj0aNIWPk07yBZhz/lvPQqKi2QVx9+ScCw4lsNHe35AxOojKu+qIGq34owsxVW+NYGmkBMRjcOmHaQzRAwNg0YNIc4vAEVRsOzSDk3mT4JVF2m9G47jkHTtHlLvBoFiGFj39oJ5h5ZkIauWNbFSLRN7Y8uqydheH0iKi3Fn7OeIO3EZFI8BJ5aAYhhE/3dWcUFZTSpZyEnxGHAsB4qmwIklcJo6HK1Wf1Y1Y6gBSHCjZab6Rrjzxd+Y8996nHx6U1bBVU9HiMZW9ngSF67w+Oj0RDSzdUT/Ft5l7nuR+Bp3XwXLPZblOESlxeNGeBB6upF1OPWBgYuD2tu81cZyyA57/e7Sl4RF3us34Onros/t/TBp6SZrmvUiEreGz0P2i1fSGR0O4L7aCHNPD3Q9thl6dtbln4MAx3E4E3wbv18/gidx4dDVEWB0216Y230UGpnbKj2+VcPGaGvvhidx4WW+/ADS8ixu1g7wdGqujeHXOzmRMbgzdiHSA0MAQJYlWLaLSZuXit9D8/lwnDgYNJ+H4swc6NpZwXnqcJi2blYl568pyG6pKspWDABxGckIig2DDo+Pzs6t8Cg2DN03zlF4DE3RWDtsDpb2nVzmvjPBtzH4jy+Unvfvicsws8uwig6bqEUKk9NwvEE31badVpScLX4UQ8OsfQv43jssG8vZFoNQnJ5VZpsqxWNg4GSP/o9PqFQ2or7hOA6z9q3F9junZNu3AYChaQh4Org4/3/o4tpaaT9BsWHosuETFIlFsj7e9sOnebj2+R/o5NxCQQ+EKl7tOYF705cBbM34OKUYBvqN7NDn7gHoWltU93A0qkZUBSdKa2hqhcGtusLXvRMMhHqwMDBRegxD03IXBRoLVbt2+rYwJ1H3Ca3M0WZDSSKvDy/7UBRooQC2/buh+befVvzylZz3b07CIi3gKTKfSSuNh//5H4rTM8vNv8GJJcgJf43oA2crNoY6bufd09h+R7qV//2gRMKyKBQVY8ifS5BXVKC0nzb2bghYugMDW3jLLgNSoODbrBP8l24ngY0GpD0Mxr1pNSewAaSzRXkx8Qhc+GN1D6XakOCmGjUwsSy35tT7xBIJnC0alHufl3ML2BqbKzxely9A/+Y1rywFoT1NF0yF9/5fYNi4kew2iseD44RBGPrqMnqe2wa2oFBr588uSfgX9e8pxZfIaKpeFPCriI1X/pO7JonlWGTk5+DAQz+V+mrRwAUn5/yMlPUXELLiPyStP4ez8zaitX0TTQ653gr73z8qlyapDHXPwYkliD1yAYXJ9TMbNQluqpGxrgHGtOutMMAR8nUwrn2fcu/jMTysGfyJwnMs7zcVhsL6kdeAeMdx/CAMenEBA0PPwffBEYxIugPvfzdA19YK4rx8hG89oJ08OIC0dhVKFjcrwnIoTlfSph7KLczH84QoKFoxQFMUbrwMUqtfcwNjuNs6wdLQtLJDJN4Tf+GWwirclUbTMG7ZBDwjg9IFbFWYeeXEEmSFRmpvbDUYCW6q2Y9D58BUzwjMBwEOVZLhZtOYRTDSlR+czOg8BBtHLYCAxwcFCnyGB5qiwKMZLPediq/7TdPm8IkajKIoGDd1gXn7lhCU1JsCgMxn4RBraUsq38QI1t07AgAMXRsprlLOY2Do5qSVcdRmquwiYzkOhx5dxp3IJ1UwIkIRVcseVBjLwuOHz9H/0XHYDugGWsAHKErllA+sSIvr72owEtxUs0bmtri/bAeGeXQtlQ+nqU0jHJn5o0qZST/vPR4JP53FH+OXYEmfifh11ELErT2FH4epXliPqFk4llX4zb1StLgFu/lXn4ARCgAAjeeMV7hDhBNL4DpzjNbGUlvpC3TR3qGp0vxYxWIxfDctxOu0+CoaGVEey87ttJNbiqYAmka7zd/CxscbAR99hfjT18CJJADHgVMxaLk+cBYCZn2rsA5cXUS2gtcAjuZ2ODLrJyRnpyMqLR5GQn00tXFUKw+Iqb4RZncbocVREtrGSiR4teMIwjbvRVZIBGg+Dw0G90SzJR/DwtNDY+cxadkEfGMDiLIq+WZHSXdlgOPAcUDz5bPQ7IsZAKS7fViRGIyeEJL8ctb3UIDjpKGw7kWS/JVnSd9JGLv9G4VtOHAoFBdhy/Wj+Hnk/CoaGfEhtwVTEH/2usb7pXk89Ly4A9Y9PBH4+Y9IuvEAgPSLjzq4YhFe7TyC9Ech6HNrP3i69aPUBvlaX4NYGZnB06kFmtk6kQRn9QwrkeD26AW4/8kKZIVESLMAF4sQd/IKLnmPQ/TBcxo7F09XiCbzJ1d+BoeTzr4IrS3Q585+eHz/uex1+/Sb/+H+zG/KDWwoPh+tvl+ITrvWkte5HGPa+ah0SVnCsjj06LL2B0TIZdunM1qsnAcA5WbqRgUXG3MSFuF//gdRTi4i/jqoPE8OLf9viZOwyHj0HJE7jlRoLLURCW4IogaI/Psg4k6UfEi9dzmKE0unoP2nLEVhivzq8upquWIuGgzpBQClFylWQGFyGu6M/RzFWTkAgIynLxDy41a57TmRCEILM9CVPG9d9/3Q2XCzdlDaLr+4qApGQyjS6rv56HV5N2z7dYWOmTEElmZwnDgYTtNHSOuvVQAnkSD26EWk3H0EibLdjRQFHTMTpV9YIv4+WKGx1EYkuCGIGuDFb3vk38lxYMVivNqpuW9dNJ+Pbsd+R7eTf8C2f1dQOvwK98WJJciPTcSrnUcBABF/H1K8BoGi8HLLvgqfrz7xdm6lcDclQ9NoaedShSMi5LHp7YUep//CqLT7GJnsD6/d62A/tLfKa2PKw0lYJJy/pVJbnr6u4h2QHIe8128qPJbahgQ3BFHNJMXFyAmLUrI1m0L6o+caPS9F02g4pDe896wHKluygeMQuUsafGU9j1C8NZbjkP0ySsHdHIqzclCcma29RdW1xJxuIxTWpJOwLOZ2H1mFIyLUYTewB/TsbSuVByfstz1gdAWKG3EcDBo1UFq/SmBuUuFx1DYkuCGIakYxjNI3JYqiQAt0tHL+qL0nNbKdNSskEm/OXgffyEDp4+EblE1vwHEcXu0+hnMtB+OISXscMe2As80HInLnkXob5HRwdJetvaHfu+TwNlXEZM9+GNGmZ3UMrV6TFBcjctdRXPQai2O2nXHOYwhCN+6SXZp9i+bx0O3kH+AZ6lcqwNFzsJO7pobiMbDq0RGN505QvC6HpuE8rf5sOiHBDUFUM5phYNevq8K1L5xEggaDemjl/FmhkaD4Gtg4ybK4MegTpN4JVPgmS/EYNBo/qNRtHMchcMEPuDd9ObKeR8huz37xCgEzvsbDeavrbYCzZsgn2P/RarRq0Fh2m4tlA/wxbgl2T1lBFmVXMXFePq70nIKAj75C2v2nKExMRWbwSwR9sQ7n2wxDflwiAOlruig9EwbO9hgYfAZNF02Hrp0V+EYGMOvQUq2dgrlRsbDt2wXAe5mKKQqgAANne3T+byPsh/eBabvmct9H+CaGcJ0zvnIPvhYhhTOrsHAmQciTdOM+rvScUu6lKYphoOdgi0EvzoPR0fzszaMv1iHstz2aLbZJSS97lSm/QFGg+Tz0ufMfzNu3lN2ceNUfV3tPU9hlz0s7Yduns+bGWAtlFeRCwkpgqmdEgppqcn/Od4jcdrDc0iIUj4FFp9ZoNG4gXmzchdxXsQAAoY0FxHkFEOfkAQAM3ZzQfNksFGXnImjBD8pPSlEYW/wMb05eQeT2w8iNjIXAygzOU4bBceJg8PT1AEizgt8asxBJl++W243jpCHotPunWr2YX9XPbxLckOCGqCEidx3F/ZnfluSN4UDRFDgJC33HBuh1eTcMXZTvnClPetBzvPhlJ+JOXgFbLIJJKzc0mT8ZTpOGgKJppNx9BL/O8r/RUQwNy24dkHLzoVqXr/hGBtLEYTRdZiaH4vPQ4ps5aPHtXFAUhVujP0Pcicty1+pQPAYNBvVEt+NbVD4/QWhacWY2jtl0BltUrLwxRSktcWLTxxuJfuUHIu8zcHXAkHDVaon5dZ+I1DtB5f+tUoDH95+j+VezVeqrJiJVwQmilnGZPhJDo6+hxYq5aDi0NxxG94f3vg0Y9OJChQOb2GOXcLHjKEQfPAdxbj7YYhHSHz3Hvalf4u6kJeBYFhZebWDVo6Pc6WyO5dB04VTwjdWrLi/KzoXb4o/KvUTFicQIXrkZz9dtAwBkBIUqXITMiSXIeByq1vkJQtMyHoeqFtgAKtVuUyWwAQD3ZbNUapce9FzxlxAOePHrbkiKVXwMtRjJUEwQNYheA2u0LEkIVlmFqem4M2GxdPr8/TfakmAj+r8zsOndCS4zRqPbsd9xc8Q8JF+/L93GTVHgRGJQAj7MWrvj1sjPKnTZKmzjLoX3P/v+DzSZNxE8Az2lfanShiC0qhouBVJ8Hlymq7YjLvHyXenlYAVr3opSM5AVEgGzNu6aGmKNRGZuCKKOerXrGFiRSP43SIrCi//9AwDQMTVG76t70Nf/IBwnDoZeQxtpgFMkQlrAk4qvx1Hy7VWSV4CE8zfhMMpX8Q4rmobDqH4VGwNBqEiUk4uwzXtxocNInHTqhat9piPm8HmwJTMhZu2ag9Gr2vIFPH09lRMBchJWtWrh2i72WQOQ4IYg6qj0B8EAFLzRcRyynoWDLQlcKIoCx3GIOXQe+TEJKk2ra0JxRjZcZ42FjrFhudtlKYYG30gfrp+MrZLxEPVTXmwCznkMReCCH5AeGIK812+QdO0ebo9ZiBuDZ0NSVAy+gT4azx6vsNSBpvEMdFVua+HVWmngwjPQg3Gzup/4kQQ3BFFH0Tp85TtqaFr2rZBjWfhPXgpJkahKv9kZuDhAaGWOXld2Q2BhBkC6gPhtlmMdc1P0vrwbujaWVTYmov65PXoB8mNLgvqSwP7tjqiEi7cRvHITAMDjx0Ww9e1aficUpfFLV+rsirPq1gHG7q5y189RNA3XWWNlu6vqMhLcEEQdZduvq8IghWIY2PbtLAtukm/cR25kjPICfZpCU9BzsIV1T08AgFkbdwyNvgbvfRvg8tEoOE8fCa9/f8awmOswa9eiasZE1EtpD4NLLr/K+XthWbz8Yz/E+QVgBDrS2Zvygo63gZEGA5z82ESI8wtUaktRFLoe2wwdc5PSl7JKZposOrdFq+8XamxsNRlZUEwQdZTD6P54snwjChJSyg1yOIkEzZbMkP2eFRqp0vZVjaEoeG7/odSbMCPQgeOEwXCcMLhqxkAQAJJvPiw3ZcH7xDl5yHwWDvMOLRG0ZJ2SHjX8N6RGsGTk5oyBwacR/ud/iNpzAkUZWTB0tofr7PFwmjJUK7myaiIS3BBEHcUIdNDTbyeu9p6GgvhkWeBCMTQ4jkOHP76DTS8vWXuevl7lAhs1AyPz9i0rvMWdIKpLxqMQ5Lx8rbgRBxg0boTciJjK/U3RNMzauoOnq94iZqGVOVqunKexnZe1EQluCKIOM27qgsHhlxB94CzenL4GSUEhTNu4w3XWGBg42ZdqazewOyg+T7UqxhRg0qopCpPTUJiQAkBalVicm6/y2NLuP8Up1z5ouXIeWqyYSzLuEtXGqlt7pZdjeUb6MGnRGEnX76vUJ1tQpHpgI++LAcui6eKPVOuDKIUENwRRx/H0dOHy0Si4fDRKdlthchpe/PYPCuISIbAyh+P4QdBraIMmcyci7Lc9yt+UOWmNnaaLpiM98BliDp5XK7CR9iE9R/B3m6HbwBquH49W96ERhEaYt28J806tkf4wuPx1NxSFxrMngKenC70G1ir1yTM2AOJUaMjQoHk8sCKxLMCieAw4sQTuy2ah0dgBajwS4i1SfoGUXyDqEY7j8Pynv/F0xSZwrAQ0w4CTsOAANFs0Da1++BwP565G5PbDJdXKKembfXlvExpcn6Pv2ABDIi+rnM+DIDQtLzYBl7tNRN7rN+Xeb+PbBd1P/Qmaz8c5jyHIComQO9vDNzYEo6+Lwvhklc7dZMEU6FpbIObIBUjyC2Ha1h1NPp0Ay87tKvx46ipSW0oBEtwQ9dXLP/bh4dzVcu9vsWIuWq36DNnhr/Fq1zG82nUUhYmpVTK2Ac/OwKR5Y+UN35P1IhJR/5xAflwihFbmcJo8FKatm2lphERdd/+TFYjYdkhu0K7v1BB9/Q8iOzQSV/tMl7+7ioJaa4obTRwM770/k0uzKiDBjQIkuCHqI1YkwvEG3VCUki63DaMrxIjEO+AbGUirhf9vd7nVj7XBpo83dO2s0XBobzQY3BM0T/5Vc45lEbjwR7zcvFeaD4cDQElrUDUc7oMGQ3qDoihYdPKAkZtzlYyfqBk4jkNawBNkh0WBb6gPmz7e4Bsqr4tWlJaB43ZdwRaLFLbTd7JH/6DjeDh/DV7vPampYQMAhNbmcJk5Bk0XToXA3FSjfdcVJLhRgAQ3RH2UdOM+rvSYrLRd54O/osHgXjhm7Q1xTl4VjOwdimHASSQwdHNCL79d0Le3LbddyI9b8eTrX1Xq07pXJ3jtWa/yWgmi9kq9/xT3pi1Ddmik7DZGTwj3pTPR4ttP3yWs5DhkPg1DXkw8BBamsPD0QOxxP9we9Znyk1AUPNYuQujPO1Cclqnxx0AxNPQa2qDP3QPQsyOv2Q+p+vlNFhQTRD0hys5VsV0eciOiqzywAd7VvMmNjME13xno9/gEeB/k5RAXFOL5+m0q95l88wH8uk5A/0fHoWNCvszUVRlPX+BKj8llqnZL8gsR/N1mZD2PQOu1i5Efn4SHc1cj82mYrI2eg63qrw2Ow5PlG7WWD4qTsMh/k4QHs1ei+6mtWjlHfaC11Xvp6emYOHEijIyMYGJighkzZiA3V/6ba3p6OubPnw83Nzfo6urCwcEBn332GbKyskq1oyiqzM+BAwe09TAIos4wauKoWjs3J1AKLglVBU4sQXZoJA4JWuKIWUcELV2PgkTplvPUO48gylItUHvbV170G0T8Rd4naqOChGTkRERDXFBY7v2SwiJkBofh0edrwRaL5FbEjjl0HqdcfHC520RkBr8sdV9+TEKpYEcpLV/w4MQSvDlzHXkx8Vo9T12mteBm4sSJCAkJgZ+fH86cOYObN29i1qxZctvHx8cjPj4eGzZswLNnz7B7925cuHABM2bMKNN2165dSEhIkP0MGzZMWw+DIOoMIzdnWHZpJ7fuDGgaho0bwbJLOwhtLKp2cAoUZ2ThxcbdON92OHJfx8n9kFOI5RC546jmB0dozZuz13Gh4ygct+uK04374qiFJx7OX4Oi9EwA0qDm8fJfcMzGG+daDUHS1Xuq1UTjUHVZuMspBKsyjkPGkxeaG0s9o5U1N6GhoXB3d8eDBw/Qvn17AMCFCxcwYMAAxMXFwc7OTqV+Dh8+jEmTJiEvLw+8km+SFEXh+PHjlQpoyJobor7KfPYSfp3HQ5xXUOqDgGKkhSp7X9kNy87tkPHkBc63HqpSn7RQB2xhsfKGlUQxDKy6tYfnjh9wytlH7eP5xoYYnflQCyMjNC1y5xEEzPi6TEkEimFg4OqAPjf/xZ1xi5B040HV1UJTB03B2L0x9OytkXD+VoW76XlxB2z7dtHgwGo/VT+/tTJz4+/vDxMTE1lgAwA+Pj6gaRoBAQEq9/N28LwPpsjnzp0LCwsLdOzYETt37oSy+KyoqAjZ2dmlfgiiPjJp0QS+9w+j4Yg+oN5+q6Qo2Pbrir53D8jyajB6qqV7F9payt8Oq2GcRIKkawFgi0Ww9e0ifwaqPBRFFhTXEkXpmXgw5zvpLx8ELpxEgtyIGNydvBRJ1wJqZmADACyH7BeRMO/ogUHhl8Do66rdBU9fF5ad22phcPWDVi6sJyYmwsrKqvSJeDyYmZkhMTFRpT5SU1OxZs2aMpeyVq9ejV69ekFPTw+XLl3Cp59+itzcXHz2mfxV7mvXrsWqVavUfyAEUQcZuTmj66HfUJyZjcKkVAgsTMtsOzV0bQRDNydpDR0FXx7ell6oShmPX6DD1lW45DUWRakZKgdXLrPGaHlkhCZE7T0JViy/BAgnkSDxsr/auWSqGieW4Nmq35EfEw87366IPXFZ9WCMouC2YKq03htRIWrN3CxbtqzcBb3v/7x4UflrhNnZ2Rg4cCDc3d3x3Xfflbrv22+/RefOndGmTRt8+eWXWLp0KX7++WeF/S1fvhxZWVmyn9jY2EqPkSBqOx0TIxi5OZebT4OiKGnRPTmBDcXQMG7lJr1sUMVogQ4MHBuiX+AxNP50AnhvvxXLGQvFMDB2d4XLjFHl3k/ULDlhUcpn5Vi2Rgc273u16xhij11Sa5bJceJgtFw1X4ujqvvUmrlZvHgxpk2bprCNs7MzbGxskJxcOu20WCxGeno6bGxsFB6fk5ODfv36wdDQEMePHwefz1fY3tPTE2vWrEFRUREEAkG5bQQCgdz7CIIon+P4QShISMHjpeulN1AUAAqcWAxb3y6w6uGJx8s2VOmYaKEOrHt0BADo2Vmj/W/foO3G5RDn5oNiaDz56ldEbDsoWwNEMTTsR/VFhy0rwTfQL9OfKDcP4tx8CMxNQCt5ryGqBs9Qv+oW/H6oBswGGbdoAu+9ir+wE8qpFdxYWlrC0tJSaTsvLy9kZmYiMDAQ7dpJr+FfvXoVLMvC09NT7nHZ2dnw9fWFQCDAqVOnIBQqv+7/+PFjmJqakuCFILSg2aLpcBw/EK92H0dORDR0TIzQaNwAmHdohcyQcDxeqpk3YbeFU+Eycwwith3CS3mFOykKTeZOKpOPhGYY6BgbAgDab/oGrVZ/hlT/ILBiCczbt4CurVWZrlIDnuDZmj8Qf+4GwHHgGRnA9ePRaP71bAjMTDTymIiKcRjdD6Hrt8u9n2IY6DnYIj8mXmH2bAuv1kj1f6zSOfnGBnAYOxDJtx4i570EgNWh0XhSKFMTtJahuH///khKSsLWrVshEokwffp0tG/fHvv37wcAvHnzBr1798aePXvQsWNHZGdno2/fvsjPz8fx48ehr//uW5alpSUYhsHp06eRlJSETp06QSgUws/PD1988QW++OILtdbUkN1SBCHN0ppy6yEyn70ET08Xtv27QddavS3gV3pPRfLNB5VaVKzb0BrDY28CkJaIuDtlKWIOnJNVRn77X4dxA+C9Z73KMywcx6E4Iwu0Dr/UrM2bczdwc+gcgEOZHWMGzg3R5+4BCC3MKvx4iMq71v9jJPrdKRu8UBRAUeh6dBMCPv4GosycMtu/KR4DAxcH9Ht0HC//9w+C12xRvJuPotB6/RfIDo3C639PKi2/oE0Uj8GIxDuk9IIC1V5+IT09HfPmzcPp06dB0zRGjhyJTZs2wcBAWuPj9evXcHJywrVr19CjRw9cv34dPXv2LLevqKgoODo64sKFC1i+fDkiIiLAcRxcXV0xZ84czJw5E7Qa1/5JcEPUd2kPg3F34hfSBcMl1b0pHgPXmWPQ9n9fgfkgK7A8BUmpuNprKrKeR1S4SjjF52F8cYjsd47jkHb/KaL+OY6ChBTwDPVB6/CRH5cIRqADu35d4ThpiNx6QZLiYrzctBdhm/YgP1a6gcGySzu4L5sFm95eOG7XBcWZOeWOlWIYuHw8Ch23yi8uSmifKCcXdyYsRvyZ6++q04vE4BnoweufdbAf0ReZIeG4OexT5EbEyOqLcRIJzD090PXYZlnpguKsHFwfOAupd4Oq73KXijrt/gnOU4dX9zBqtGoPbmoyEtwQ9VnWi0hcbD8SksKist+MaQqNxg5E5/2/qNyfuKAQ0QfOImr3cSTffFChMfU4vw12/boBAFiJBKLMbPD09RBz9CLuTVsGcJx0rJR0UYTA3BQ9L+2EWRv3Uv2wIhGuDZiFpCt3S6+dYGhAwsJpyjBE7TmhcCyMUIARKf7lrtEhqlbG0xeIPeYHcW4+jN1d0GjsgFI7iDiWReIVf6TeDQLF0LDp0xnmHVuVqq5dlJ6JYzadwYnk78CqKFk6BYYBJKxqSQQpCvqODVCckQ1RpjQtiWW39mjxzaew7dNZ42Osa0hwowAJboj67O6kLxB98JzCS0n9n5yEaaumavd9uecUJF9XPZfVW1bdOqDbyT/w/Ke/Ef7XQembPk0BrIK3JwrQd2wIpynD0OyLj8DT05Vezrh0R/HJeAyg5DLagGdnYNK8sdqPg1CuOCsHKbcDwYnFMG3bXG5xVE1JvfcYl7zGarxfk9bN0HBwT7jMHIO86DcI+Pgb5IRFqXSs9/5f4DDKF4Up6eDpCqFjaqzx8dVVpHAmQRBlSIqLEX3ovMLAhuIxeP3vKZiuVz+46bj1O5xrPQxsYZFaxyXffICLnqORGxnzbjZJUWADAByQFxWHZ6t+x/N12yC0Nkd+tAq1eFRYH8SrQNI1QjFJcTEeL/sFEX/+B8nb1wdFocGQXuj412q113u9T1xQiLiTV1DwJglCa3M0HNpbdtky9/UbTQy/NIqCy4xRcJs3CTmRMbgz9nNZ7TOFaBqmbZrBfmRf0Hw+qfqtRSS4IYh6RJyTp9L0fFFKRoX6N3Jzhu+9Q/CfugyZT0LVOjY3Mlbh7hdF2MIi1QIbZSgKxi0aQ79RgzJ3FWflIPnmA7DFIpi1dYeBk33lz6cEx3GlLrHUVhzH4c7YzxF36krpoJXjEH/mOvy6jEe/B0crVLU9cucRBH6+FuLsXFAMDU7CgtETwuP7z2E3uAcCZn2jwUfybtxCSzPEnb4K/8lLIcrKUe04lgXD56MwKU3rM1b1HbksRS5LEfUIKxbjsHF7SPIL5LahGAbNv56NVqvkZ/1WRfqjEGSFRiL55kNE/n1QceMakF/krS5HNsFhpK/sd1YkwuPlGxG+ZV+pGQfbfl3h+fca6DVUnLtLXaKcXLz8fR/Ct/6H/JgE8I0N4DR5GJoung4Dx4YaPVdVSbp2D1d6TZXfgKbh8f1CNF/+ieymvOg3iNx1DLmRMdAxM4bj+EEw9/QoFey93n8adyd+oc2hyxkvBZNWTZH5WL0AHpDOjOraWaN/0HGSdqACyJobBUhwQ9RnD+atRsRfB+RfmqIoDIn009jMRGFKOo436Cp/xqi6AxseA7AcKJpCu/99jSZzJ0KcXwBJQSH4Jka4O3ExYg5dKLPThuIx0LW1Qr9HxzS2dbw4Iwt+3SYi63lk6YKRPAY8fV34XP8Xpq2baeRcVenulKWI/u+Mwsuh+o4NMDTqKjiOw7Pv/0Dwys2gaGniSFDScga2/buh6+HfwNPXAyuR4JRjL+THqVbSp0Z5L5iLP38DT1duRkF8MviG+nD9ZCyafDZFrR3A9Um1Fs4kCKLmavH1bAgszaTbZ8vh/uVMjQU2kuJi3J2wWOGHmnF1LtylKJh5NEObdV9g+JtbMGnZBNf6zcAhgzY4atEJRy06Iebg+XK3EHNiCQrikxD22x6NDSdoyc/IDn1VtmCkWAJxbgFujfoMXE0tFqlAfmyC0lxIb9esvNp5BMErNsl2yHESiezYxEu3ce+jrwAAqf5BtTOwAQCWReTOI7jYaTSuD5iF9AfBKHiThOwXr/Do87U4auGJgmqo21aXkOCGIOoZXVsr+N47BNt+XUu2VksxukLo2dsi6VoAnq74Dflvkip9rvA//0PiFX/5+UUoCrSuahXItcWwSSM0+2IGEq/ew+Uek6VFGUvG+3arrjychEXEtkPIi4lHVmgkxHn5Ss/HcZx0G/4Hz0lxZjai/j0pdzsxJ5EgNzJGWg27hsuNisXDBd/jqFUnHNTzQMbjUOnuNwWElubgWBbP1vwhtw0nYRFz6DxyImNQnJap4VFXrbzoeKQFPC33PlFGNi60H1HFI6pbyIJigqiH9B3s0OP0X8iLTUD4H/vxfP12sMUi5McmID82AekPg/H85x3odvx3Wf6Zinj5+7+KG1BAxoPgCvdfaRyHhEt3kP8mCfemLy+ZLVAv23JRUhpONpImIGWEAjhNGw6P7xeWyTJbmJKO0A07ELntMIozssDo6aLRuAHQtbVE3MkryI9NAFukIJMupHlV0gOfwaa3l3qPswqlBjzBVZ9p0gCuZMZFUlikMIEexdBwmTEKWc8jkKdsYThN482pq7Dwaq3BUVcxilK6sL8gPhkJl+/C1se7igZVt5DghiDqseKMLDxfvx1g2VLLXjgJC44txs3h8zD45cUK7exgxWLkRsQoaVT9S/6K0zLxaPFPSgMLVUgKixC57TCSrtxD33sHZQtG8+OTcMlrHAreJMmCJ0l+AV7tPCo9UMV1RxwnrYpeU7EiEW4OnwtxfmHpS2uKAhseA10bSzSeOwF5UXFKz0HRFCQFhaD1avN2fdVe9+F/7CPBTQWRy1IEUY+F/ba3ZNFmOTgOnEiEiL8OVKhvimFA82vB9ycKiD97vdQlusrgJBLkvopFyI9/yW57OG9NqcCm7EEqds6ysOtf8Zk0beFYFkXpmYg+fAGFCSll1gwpYtTMBe5ffYLI7UeQcvuRdIG3onOJJTBp5QZGUHOruOs1soNZh5blXoqjGAa6DVTbYScpUC9fFPEOCW4Ioh5LuHhL4UJPTsIi4eLtCvVNURQaDPORu3C5UmgKZu1boP2WFbAbXH5NOpVxgDg3X60PZKVdSiSI2HYIrEiE/PgkxJ28ovblrjIoCnYDe8CoiZNmBqkB4rx8PF25CcdsOuOouSf8J34hnYVSFQVkBb/Ew09X4em3/8OjxT8BElZ+HzQNoa0leEYGSAt8Jq07pUE8Az3ljVQIgtv+sgx9bu9H08+ng3lvTRnF46HRhEHocWarSuOx7NpOpXZEWWQrONkKTtRjx2w7ozAxVWEb09bN0D/oRIX6T3sYjEteY6XJ+crZSi2wMFV6fkWM3F2QGxmrkUtKalOhUOjwhNvIfBqGa74zNHJKWqCDxrPHweOHz0vVWKoOotw8XOk5BRmPnlfJDi6Kx4CiKDB6uqonzVODwMocvvcO4VyrwWUvq73HqHlj5EXFQpJfKLcvI3dXDHx2BhRFQZSTi7T7wWDFYpi1bQ6hpTRtwCnXPsiNlH/ZlmIYjCl4AoZfc2eoqgPZCk4QhFJW3ToonFmheAysenSscP/m7Vui65FNYHQFAEVJP6B40ktVRk2d0evybtDCiq8hyX4RVS2BDc9AT/kMBUWBZ6AHRijQ2HnZomKE/bYHlzqPh1hBIsYK9S0SoTgzG6yKM0zPf/obGUFaDGwoCoxhSfFSHgOzDi3BisRqBzYUQ8Nj7WI0GNxT4UyP+5IZMHBqiJ6XdkLHxLDkWEZ2jI6ZMXqc345Wq+YrDGwAIPt5BDKfvAAA8A0NYN2rE/gGegj54U/cm74cIWv/Qqd/1oFSELh03P49CWwqoRZcECcIQlvcPpuMmEPn5d7PsRwazxlfqXM0HOqD4fG38frfU8gIeg5aoIMGg3vCtm8XUDQNjx8WIWjxTxXrvJpyvohzFW/5phgGtv26gm+gD3NPD/BNjSDKULytXB2ZT17gxa+70eLrOZXuK/tlFELW/oXo/WfAFovAM9CDy4xRcF82C7o2luUew4rFCP/zvwqXy1ANB5phIAEAsUTutmmlvUhYWHTyQOM543F9wMySCuIMOIkEFI8BJ5ag8ZwJaLpoOgDA0qsNhsVcR/SBs0i++RCgKFj36AjrXp3wavcxvPx9n0rnLUhMgSmaQZSdi5sj5iHpir/siwTHcqAowP3rT5F87R5SbgfKZgENmzii3aZvYOfbtUKPl5Ail6XIZSmingvdsANBS9bL3ugB6YwNJ2HRaddaOE8drvUxhG/9Dw/nr1Ga6K1WoChQDI0+t/bDolNrAEDIT3/jyfJfNHoagZU5RiTeqVTtqfRHIbjcfVKpbduANDgTWpuj771D5e6UK0hIxnG7mv/hSzEMDFzsMejFBVAUBVYiQcLF24jefxpFqRkwcLaHy4xRMGvXQmE/2S+jcLnbJBSmpKscUA8IPg2TFk1wfdAnSLhwU24g2OXwb7Af6QtRbh74+nqgSGZihUj5BQVIcEMQpSXffoiwTXuRfOMBKJqCrW8XuH02BWZtm1fZGIKWrEfoxl3VNhtTWW9nA/gmhvDe+zMaDHq30JljWQQu+AEvf/9XGjiyrHTNTiVnPsbkBlV47Q3HcTjrPgA54dHlLnameAzs+ndD5/82IvnmA0gKimDSyg2Gro1QnJWDIybtFfb/tohldaF4DHgG+vC5sRemrdSvcP8Wx3E413IwssNeqRZ80zRMW7mhf9AJZAaH4VyrIQoGScG4uSsGPD1dJwqkVgVVP7/JZSmCIGDVpT2suij+sNK2xnMn4MVv/0gz99bC71ycRIJGk4bA8+814H2QdZmiabTf/C1cZ4/Dq13HkB8TD4GlGfKi3yD+3I2K1dai6UrlvEm5E4jsF6/k3s+JJXhz+hqOWnmVWmNi3asTPLd/D8tu7ZF655HcAKY6AxsdM2M4TRmGpp9Pg76DXaX6Srn1EFkh4ao1pilQNIW2/5OWiIg9cVkW9JaL45D1LBz5sQmVHidRGgluCIKoEQwcG6LzfxtxZ9znAPDuWzJN15rZnOh9pyHOyYNRE0c4Tx8J42Yupe43ad4YbTd8CQDICo3EWfcBFT5Xg0E9QPMq/hae+TRMpeSBHy6eTb7xABc7jUW7/32FlFuBFT6/tlA8BiNS7mms8GTKnUeKA5T3GDd1QfstK2DdXboIX5JfKM11o+RQTS8OJ8huKYIgahCHkb4Y+OwMGs+ZAANXB+g7N4TT5KGw6NJWvfwp1YXj8ObUFbz4dTfOug9A4MIfytSQeitq78mK5wCiKbT4pnKLiXl6uhWaMeIkEhSnZyLV/zE67fxRtvutpuDEEjxb9bvG+qMYGqo8Ud77NmDAszOw7uEpu824RWOlZRYYPSGZtdECEtwQBFGlcl/FIvnmA2S9iAQgXZwafegcXv93BrlRsTByc0b7Td9gSLgfhkZegef276W5QWrLlSru3axT2G97EPrz9nKbFSWnoSIRG8XnoevR32HeoVVlRgnb/t0qHFxxYgle7ToKpynDYNzcRfkBKqB1NLftOeTHrShMTiv3vvSg5whasg73PlqO4DVbkBejuJaVTW8vpZfYBBamsB/lW2bdjMNIX+iYGcstGkoxDJynj5QGmoRG1ayQmyCIOivtwVMEfr4WqXceyW7jmxpBlJX77rITRcFuYHd02vEjhFbmAICXm/9F3Ikr1TFkjXi+bhvcFk6FKDMHmc9eghHowKxDS+g2tFG6togW6MBuUE9kh4SD0RWi4dDeaLp4OvgG+pUel661BVw+Ho2Ivw9WqMaXODcfKfceI/NJWKXHAgBssUgj/QDSrdbRB87C7bMpstskhUW4O2kJYo9efBfUcRyCV25Gy+/mocW3c8td1GvWrgUsu7RD6r3H5S8opgC3hVPB6JRd/8QIBfDetwE3Bs8BqNJFWSmGhmETR3isWVD5B0yUQYIbgiC0LjXgCS53nwRWXHqKvkzuF45DwoVb8Os6Af0eHgVPXw8v/re7Vi4wfqs4PQvXB8xC8o37sg9HHTNjuHw8WmECPIrHwHnacHTculpjY2HFYmliupIP8Xb/+xrFGVmIOXhe+oFf8jRzEonSDMyMrhCvdh3V2Ng0iWJoFCSklLrt/pzvEHvcDwDKBCnBKzdD18YSrrPGlttfl0P/w+WeU5ATFiWdhWE5WeqERuMHwX3ZLLljsevXDX39DyDkh62IO3UVYFnomBrDdfY4uH85EzrGhpV8tER5yFZwshWcILTufLsRyHgcqvrCYIpC243L4DhhMI5ZK6mK/PZDmKal/9XiW9rb/D/qnoOi6XIDGdPWzaTPy4ftGQY6pkboF3is0usxJIVFeLllH17+/i/yXr8BxWOg72AH45ZN4DCyLxxG90dWaCRe/3sKhSnp0HewhXlHD9wcKn9ND8Vj4PLxaKTdD0bGo5BKjU9bWqyYi1arPgMA5Mcl4oRDD4X/bnoNbTDk9VXQcrIYiwsKEXPwHF7vk+bIMWziCNeZY2Dd20vlbdySwiKI8wvANzaUex5CMZLnRgES3BBE1cl89hLnWg5W76CS/B8+1/fiqEUnxU35PDiM7gezNu548etuFMQnK+1b3eDEY90S2PbxhoFTQ6QGPMGdcZ9DlKmZ+kZun09F1O4TKM7Ikt1m7eOFjltXw9DFoVJ9iwsKcbXPdKT6B8m99CSwMkfP89vK5DS6O2UpXv97qmxNMIYB38gA/YOO4+bwecgIel6pMWpTqzUL0OKbTxH+5348mLta6b97v8BjVZrbiVAfyXNDEESNkPf6jfoHcRwK4lOgY2YCk1ZuyHz2Uu6HMycSo9G4gWg4uBfCNu1RqW916NrbIu74JSRduQuH0f1h0bmNRnO4FCVnoNvJP5D94hUEVuYwadG4UkFNblQsog+eR3FaBjKfhSPV/7HCNTXFaRm44jMNg8Muyoo6AkCnHT9AYGGK8D/2l6rfZdrWHV571kG/UQNYdPKo0cHN029/g56DHcT5haBoCpxE8b892ZJdd5CZGzJzQxBaleIfBD/vcWofp+/cEEMjr+D1/tO4O/GLcttQPAb6jg0w6MUF0AyDyz0mIflWoNzLXxXKmluyxuLtjA/PUF/6IaiFJHV6DW3Q/KtP4Dp7vNoZa1mxGA/nrUbE34dA0RRAUaqXs6BpeHy/EM2Xf1LmruKMLCRevgtJYRFMWjWFqce7bL/Z4a9xpomvWuOsUhQFw8aN0O63r3G9/0ylbV1nj0NRSgY4kQim7ZrD9ePR0LW1qpqxEiohl6UUIMENQVQdjmVx0rEX8mMT1DqOEQowIsUffAN9PF3xG56t+eNd/auSQEPP3ha9r/4DQ9dGAICwTXsQuOAHhf1quoilNjT/ejY8vv9crWMeLvgBLzfvrfCaI9O27ugfeLzc+zKevsDLTf8i/sJNcBIJjJq5gG9kAEaHj7TAZ8h7FVehc6qEoqTrqVSsVl6ewS8v4orPNOTHJam+7oumQTE0vHb/BMcJal5WJbRG1c9vkueGIAitomgardeVP/OiiKSoCNH7zwAAWq1egH6PjsPlo1Ew79QaNj7e6PjXagx8flYW2ABA0s0HisfCY9D404lqj6WqhfywFTkR0Sq3L0hKRfgf+yq1mDo7LApPvv2f7NJMXkw8AhetxSGjtjjvMRSROw6j4E0SChNTkXwtAG9OXkHMkYvIj1YvaFWXwNIMrjNGVaoPViRG5/2/gNHhg1J1IS/LghOJcXfyUqQGPKnU+YmqR4IbgiC0znH8IHju+AF8IwPpDSqkxqdoBinv5cQxa+OOjn+thq//QfS6tBOus8aWyvdSmJqONycuK+yTE0tg7O4CgaVpxR5IFaEYBpE7jqjc/s2pq5VeByTJK0DI93/ikGEbPFzwPc55DMHLTXsgzsmTfxD3Qe4W/rtEfIyesLwj1FaclgGnaRWvTM/T14W+YwNYdm4H3/uHYT/KVzobpCKKphD6y84Kn5+oHiS4IQiiSrh8NArDE+/A+7+N8Ph+ofIDKOmsj6ryXr9R+gFP8XjIefka/BqeW4TjOOS+ikVBQjKefPMrTjTqicPG7XC+7TBE/H0QkvcW+AKAKDtXus5GE1gOLzfthSg7V+2AiRNJE/FRDA1JQaGS1qqhBQLpAusKPD6KoeHy8WhZBmCTlm7ocuBXCN5bOK0MJ5Yg/sw1tc9NVC+yW4ogiCrD0xXCcdxAAEDcqStIvx8sN5EdJ5bAupdnufeVR5WAhWMlyIuJR25EjMr9ylWBLeUqd12yIPhcy8EozsyWBRkZQaG4/8kKBK/ZAtePx8Bp8lAYONvDyM1J81W4K5C1+C2NjYWhYT+iD4RW5jBwskdupBr/bjQNk5ZuaLW6bAZgiZq7othixfWhiJqHzNwQBFEtmn0xQ25gQzEMhNYWcBjdX+X+DF0bwbhFYyWXHCiIMrJLiiFWDMXQEFiZw3HikAr3oQwnliDlziMUZ+aUGygUxCUheNXvOOXaB/dmfAXr3p0gtLFQ/NgrWqSzOklYWHZuCwCw8fFS+TDdBtZotfoz+Nza9+5S6HuMmjqrPhNE0zBt3UzlcxM1AwluCIKoFg4jfdFixVwAKF3AkabANzZEzwvbwQgFKvdHUZT0cpe82RSKgmtJyYOKzixQDANGTxfdT2+F3YBuFepDKZqCabvmKIhLLLWepYySbMyvdh3Do8/XwuufdYrXMqm6LbyGebRoLfJiE+A0eajihjQN846tMLYoGMPjbqLF13Pk1uBqMnei6jNTLAu3BZPVHDVR3UhwQxBEtWm16jP43j8Mx0lDYdLKDeadPNBm3RIMfnmhQt+WGw71gefOH8HoCgGKAsXnSWdpKAouH41E+9+/hXEzF5UWNAMAaBo6ZsbgGxlA19YSbgunYmDwaVh0bIWU24Fqj08VFEXBpEUT1Xf1cBwith2GsbsrWq2ar5UxVSe2WISIvw7AwrstLLzayK9kzrJo/vXscgtYfshx0hDYDeyhePam5D7HyUO1OktHaAfJc0Py3BBEnSPKzkX0wXPIfRULHRNDOIzpDwMnewBATkQ0Tjfuq3JfNn07w3Pb92VqPJ1vNxwZj7SQnZemwQh0ICkqUn12gabQ7n9fI+7EZWmBTi0kGKxOJh5NMeDxSRSmpOP6wFlIfxAMiscDx7F4G560++0b6YyMiliRCKE/70DY5r0oTEwFAPAM9CApKALHsTD1aAa3BVPgNHmoWgvbCe0iSfwUIMENQdRvx+26oiBBSQ2qtxgaAnNT9Lt/GPqNGrzro2E3FLxJ0tII1Se0tURRWga4Orj41cjdFYNCzgKQJoVMvOKP2CMXIcrNg3EzFzh/NBJ6dtYV6puVSFAQnwyax0BoYym7Xd0M0UTVqPYkfunp6Zg4cSKMjIxgYmKCGTNmIDc3V+ExPXr0AEVRpX5mz55dqk1MTAwGDhwIPT09WFlZYcmSJRCL694fM0EQ2mPWoYXql6YkLIrTMvFo8U+lbmZ0VV8PpC6KpiGwsVDrmMKElJoV2NA0BBaVzydE8RhYdWn37neahm2fzuj412p03vcLWnzzaYUDGwCgGQb69rbQtbUq9dlD1G5aC24mTpyIkJAQ+Pn54cyZM7h58yZmzZql9LiZM2ciISFB9rN+/XrZfRKJBAMHDkRxcTHu3r2Lf/75B7t378aKFSu09TAIgqiDXD4aqXoafgCcRILY45dRmJwmu02voY02hiY9H8tCx7DsLp/apMHAHhj88iIofuUyjnBiCRp/OkFDoyLqC63kuQkNDcWFCxfw4MEDtG/fHgCwefNmDBgwABs2bICdnZ3cY/X09GBjU/6bxqVLl/D8+XNcvnwZ1tbWaN26NdasWYMvv/wS3333HXRUWEhGEARhN6gnbHy8kXj1nupBDssiMzgMNr29EbH9MJKv39fqGHPCX2u1f00T2ljCqlt7WHZtD1vfLjBq7AhAWiNMLKrAjBIFgAPabfqmVLFOglCFVmZu/P39YWJiIgtsAMDHxwc0TSMgIEDhsfv27YOFhQVatGiB5cuXIz8/v1S/LVu2hLX1uylIX19fZGdnIyQkRG6fRUVFyM7OLvVDEET9RTMMup36E40/GQdaoPqXohuDZuPpqs24P+tbLY4O0p06msg4TFHA+7uutLgwttM/P6HLwf/Bbd4kWWADADY+3mr3RQt00GCYD3xu7oPbfPnbsAtT0vH85+24O2Up7n+yAvHnb0i3+nMckm89hP+0L+HXdQJujpiH2GOXwJIlDPWGVmZuEhMTYWVVukw8j8eDmZkZEhMT5R43YcIENGrUCHZ2dnj69Cm+/PJLhIWF4dixY7J+3w9sAMh+V9Tv2rVrsWrVqoo+HIIg6iCerhDtt6yAgUtDBK/aoriGUglJYRGeffe7NEjQ4l4MHTNjFKdlVbofA6eGaDi8D6x6ekJgYoi4E5eR+fQlku8EQpKnXpZeZYJXboZd3y5lbm+zYSnijvspPLbHxe2AhAUjFMDCq41K+Y2i/j2JgI++AiuRgKJogAIi/j4I45ZNYNTEEbFHL8mqyFMMjbjjfjDr2Aq9LmyHjqlxhR8nUTuoFdwsW7YM69atU9gmNDS0woN5f01Oy5YtYWtri969eyMyMhIuLi4V7nf58uVYtGiR7Pfs7GzY29tXuD+CIGo+SXExYg5fwKudR1EQnww9e1u4zBgF+xF9QJcUeAxdvw2Pl/2ifudqrNepiOL0rMoHTzQN5+kj0OKbT2U3WXaWLsyVFBfjzelruD3qs8qd4z1p95+iMDUdQovSdZtoHk86C6VgWztPKIRVtw4qnyvpegD8p3wpe444vEtQmBUSjqzgl9LbSxIXyspXBIbAf8qX6H56q8rnImontYKbxYsXY9q0aQrbODs7w8bGBsnJpbdZisVipKeny11PUx5PT2ldmYiICLi4uMDGxgb375e+zp2UJN2KqahfgUAAgUB7OxsIgqhZirNycLXPdKQ/CJbOsrAsssNfI9HvDiy7tEOP89sgKSzCk29/q+6hlq8SdZ3eomgKLh+PLvc+RkcHDiN9YdahpfQ50gSWRW5ETJngJuKvg6AoChzKf0wUj8GL/+1WK7gJWfsXKJouP4OzgueOk0jw5sw1ZL+MglETJ5XPR9Q+agU3lpaWsLS0VNrOy8sLmZmZCAwMRLt20m8KV69eBcuysoBFFY8fPwYA2Nrayvr94YcfkJycLLvs5efnByMjI7i7u6vzUAiCqMPuz/r2XYK9t7MsJd/eU/2DELjgB5i2bqa4vEFV0kIRzoZDfaBro/j92mXGKKXBzdtLO6rgGeiVuS1JSVJBTixB8o0HKvUPSC8NJvrdrfjzRVFI9LtLgps6Tiury5o1a4Z+/fph5syZuH//Pu7cuYN58+Zh3Lhxsp1Sb968QdOmTWUzMZGRkVizZg0CAwPx+vVrnDp1ClOmTEG3bt3QqlUrAEDfvn3h7u6OyZMn48mTJ7h48SK++eYbzJ07l8zMEAQBAMiPS0TM4QtyAxdOwiJqz0nkhL8GrWqJA23TwvqdtIAnGulH1cBGx9QYxs0blz6WZSHKVGEDhxp5ZSRFxZV7viiQhcX1gNaWzu/btw9NmzZF7969MWDAAHTp0gV///237H6RSISwsDDZbigdHR1cvnwZffv2RdOmTbF48WKMHDkSp0+flh3DMAzOnDkDhmHg5eWFSZMmYcqUKVi9erW2HgZBELVM8q2HSj/8OLEY4rwCsBUsU8B7W5CxosneqiBJXGFKOoozs6EoCb04N1+lGlZy6zm9x2nasFLJ7zKevMAp1z7IColQ2rdNn85K+3+Lb2QA3QYVT9oHloOFp0fFjydqBa3slgIAMzMz7N+/X+79jo6Opf7o7O3tcePGDaX9NmrUCOfOndPIGAmCqINU/FZv0bktov45LmcliGItvp0Dk1ZuCPttD5JvPpDOJqgQKFEMDdO2zTW3zkUBtqgYR0w7QN+xAdwWTkWTuROli3vfY9jEUfmlOYqC/UhfxB65KLct38gAbX7+UvZ7flwiLveYBHFOfrnt38dJWDRdOFX5A5INh0KTeZPw5OuNaq9NohgGJi2bwJwEN3UeqQZGEESdYuHdRunMCMXQaDCgO5ot+Vi9zikKAmtzNJ49Hnb9uqHn+e0Ym/cE40XPMTz+FgZFXIJuA+vyZ0MoCqAoOIzup945KykvOh6PPl+L26MXgP0gOLHr3w1CGwuFz5eBc0O0/mkxDJwbSiusv4+mQAt10P3sX6Uu8YVt2gNxTr7iwImWPh8dt65Seyal6cKpsOrSvkwuoLfPu75jA9nz/e4+GjrmJuh88FdSXqEeIMENQRB1ioFjQzQY3FPu5RaKYeAwZgB0bSzh8eMitFqzAIyesFQb3YY24BmWLI5lGFkiPH0HW/hc3wu+UenSCBRFQdfWCkYujdD7ym7o2lrKzgWalgYBOnx0OfQbbHp7VfoxUjwGhk0cVbu8xXEAxyHuxGVE7jz6QUcUmsyfrLCf3Kg43B69AL2v7UWzJR/LcsRQfB4ajRuEfg+OSgON90TtPaV0RkjfwQ4Dgk/DddZY5Y/hA4xQgJ4Xd6D1j4ug+7YMBkXBpm9n+Nz4FwNDzqLtxmUwauoERk8IvYY2cF/+CQY8PUUWEtcTpCo4qQpOEHVOYWo6rnSfjKzQSOkNHFfyAc7BtHUz9L66Bzom7/72Rbl5SLhwC6LsXBg2doRll3aQFBQi+uA5pN4Nkq4L8fFGw6G9y1zaKY+kqBixRy8i/vxNsMUimHdoCefpIyAwNwXHcTjnMUS6FqWC+XIoPg8uH40E38gAL3/fB0lBoWrH8Rh4bvseztNGIPnmA9ydvAT5MQnKD6RptP7xc7h/OQscy0Kclw9GVwiax0Paw2C82nUMeTHxEFqawXHiENwYMhuSfMVjsuzaDn1uyl+6oCqO4yDOzQOtowNGjWzTRO2k6uc3CW5IcEMQdZI4Lx9Re04gcscR5McnQ6+hDVxnjoHjpCHg6QqVd6BFKXcf4UqvqdJdOxVc1Gzo5gSTFk1gN7A7BJZmePrtb8h8rFoS1Rbfforn67eDFYlVDrD0HGwxLPq67HdWIsGDT1YgcseRd5mAS/7LM9CDOK9A7vonisfAeepweG7/QaVzE8RbJLhRgAQ3BEFUt7QHTxG05Gck36h8AU6hjQWM3JxV7ovi86S5Z9ScORonfi5bWxO8+ncEf7cZ5a7IViFvT997hyq8a0mUm4eskAhQDA2Tlm5kxqYeUfXzW2u7pQiCIGoSUXYuovaeRPKth6AoCtY9PdFowiDw327rrmLmHVrB5/pe5MXEoyA+GaxYgtgjF/Bq93GIsnJAMQw4llVp91dhYioKk9JUPjdXgSrdjK4AVEnhTUlhEV5s3F1+YAO8G3NJdugPNf50QoUCG3F+AZ58/Ssi/j4ou+ylY2oMtwVT0Pzr2SpdMiTqBzJzQ2ZuCKLOS7pxHzeHzIEoJ69kFw0AloWOqTF6nNtWLXlPxPkFKEhIAd/IAELL0iULOJZFcWY2glduRuTOI0rXr2gbxWPgNHkYOu38EYD0+bzSQ3617rds+3VFyt1HEGdLi5LqNrBGsyUz4PbZFLV3LEmKi3HVZzpS7zySBn2lBkjBYWx/dN6/keyEquPIZSkFSHBDEPVHXvQbnGk2QJqL5sMPRZoG30APg15ehK61RZWMpyApFcErNiFqzwlICosAAFbdOqDlqvmw7lG2PI24oBCZT8NwqdOYKhlfGTQNRoePfo+Ow7iZtIBxgt8dXOv7keLjKAodtqyA07QR0mzQPB4M3ZwqnBU6csdhBHz8jcI2PS/thK0aCQGJ2kfVz2+yFZwgiDrt5R/7wRaLyl9fwrIQ5eYjctuhKhlLQWIKLnYYJZ2NKQlsACDldiCu9J6G2GOXyhzD0xVCrzIZeSuqJKeNwNwEPS/ukAU2AGDSyq1szpsPcRxM27UAT1cI01ZNYezuWqlyF+FbD5TJa/M+iscgoor+HYmajwQ3BEHUabHH/BTnXGFZxB73q5KxPF6+EQUJyWXqNb1dW3Nv+nKIy9nWLbS1BMXX4HoSSpp8T2HpBZaD22eTMSzuRpmK3brWFrAf5aswl5CJR1OYd2ipsSHnvopTXPFbLEFueLTGzkfUbiS4IQiiTmOLipS2UTVPTGWIsnMRvf+0/EKUHAdRdi5ij1wocxfNMBoNFMBx6LBlJSy7tlPY5uWWfciNjC337vabvoW+U0PZIuO3KIYB38QQnQ9odv2Ljpmx4gY0DYGlqcbOR9RuJLghCKJOM2vXQmHhR4rHwKy9BgMHOfJi4qWXxxSg+Dxkh0WVe5/3fxuVnoPWFUj/R8ElI4phYNq2OZymDi+5vKRg9oai8HLLvnLvElqZo9+DI2ixci507awAipLtXBrw+CSMm7qUe1xFOU0ZWiaQKoVl4ThpqEbPSdReJLghCKJOazJvkvzZEkgvZzT5dILWx8E3VGHLOcvKbWfgYAfX2eMUHt7z/Hb0vLgDDiN9YdjUWXYpi+LzZAGeeScP9LywHTTDIPHSHYWX7DixBAkXb8m9X8fECC1XzMPwN7cwXhKKUen30faXZdB7WxJBgxrPGQ+BlVm5gSrFMDB2d0WjMf01fl6idiJJAQiCqNOse3VCsy8+QuiGnaBo+t02YoYGJCxafjcfFp1aa30c+o0awLR1M2Q8fSF37QgnYWE/0lduHx22rITAzATP128HJ36Xq0ZgaQrvfb/AuntHAIBt3y4ApDutYo9cQMbjF2CEAjQY3BPmnh6yy0UqbZZVcT+ttrdgCy3M0OfWftwaOR+ZT8NAMbQ0nQ7LwrJLW3Q++D8wQoFWx0DUHmQrONkKThB1HsdxiDl8Hi827kJawFOAomDZuS2aLv4I9sN8qmwccaev4uaQOeXfSdNoVJKrRRlRdi7enLsBUWY2DBs7wrqnp+JLNnLcn7MSkdsPy53ZongMXD4ahY5/rVa7b23hOA6p/kFIufMIFMPAprcXTD2aVvewiCpC8twoQIIbgqi/WLFYuluoEtuSKyNy11E8+HQV2KJi0DweOJYFJ5HAYUx/dNr9U5XWvcp89hLnWg2RnwWZotD/8QmYtiLBA1EzkOBGARLcEARRnYqzchC9/zSyw6OhY2wIhzH9S+WRqUqRu44iYMbX0ss8JTM4FI8BJ2HhuW0NXGaMrpZxEUR5SHCjAAluCIIg3sl48gIvN/+LxCt3AQ6w7u0Ft/mTYNq6WXUPjSBKIcGNAiS4IQiCIIjah1QFJwiCqOcyHoci9rgfxHkFMG4u3SrN09fTSN9F6ZlIuuIPSWERTDyaknU5RI1CghuCIIg6RpSdi9vjPkfC+ZvSvDAUBU4kRuCCH+C1Z32ldohJiosRtORnRGz9r1RSQvNOHvD6Zx2Mmjhp4iEQRKWQJH4EQRB1CMdxuDVyPhIv3ZH+LpaAE0lz4ohz83F71Hyk3AmscP/3pi7Dy817y2RbTn/wDH7e45AXm1DxwROEhpDghiAIog5Ju/8UiZfvlp95mOMAUHj2/Z8V6/thMKIPnC136zgnkaA4KwehG3ZUqG+C0CQS3BAEQdQhMYcvgOLJX3HASSRIuHgbotw8tfuO2ntSYZ0uTizBq51HVct8TBBaRIIbgiCIOkSckwcoq4TAcRDnFajdd2Fi6rvyFfLOn5sPSaHySuwEoU0kuCEIgqhDDN2cFBbDBAC+sSEE5iZq961rZ6W0zAPf2IDUeCKqHQluCIIg6hCnKUMVlpagGAaus8aAVnDpSh7nqcMVVlinGAYuM0ZrvYgmQShDghuCIIg6RGhhhvZbVkp/+WCWhWIYGDZxRPOvZleob9PWzeD80UignOCF4jEQWJqi2RcfVahvgtAkEtwQBEHUMa4zx6D76a0wa9dcdhtPXxeN505A3zv/Qcek4pnZO/69Bs2/ng2evm6p2617eML33iHo2lpVuG+C0BRSfoGUXyAIog4rSEiGOL8QunZWGq04LsrNQ8qth5AUFsOklRsMXRw01jdByEPKLxAEQRBam0nhG+jDrn93rfRNEJVFLksRBEEQBFGnkOCGIAiCIIg6hQQ3BEEQBEHUKSS4IQiCIAiiTtFacJOeno6JEyfCyMgIJiYmmDFjBnJzc+W2f/36NSiKKvfn8OHDsnbl3X/gwAFtPQyCIAiCIGoZre2WmjhxIhISEuDn5weRSITp06dj1qxZ2L9/f7nt7e3tkZCQUOq2v//+Gz///DP69+9f6vZdu3ahX79+st9NTEw0Pn6CIAiCIGonrQQ3oaGhuHDhAh48eID27dsDADZv3owBAwZgw4YNsLOzK3MMwzCwsbEpddvx48cxZswYGBgYlLrdxMSkTFuCIAiCIAhAS5el/P39YWJiIgtsAMDHxwc0TSMgIEClPgIDA/H48WPMmDGjzH1z586FhYUFOnbsiJ07d6Ie5iEkCIIgCEIOrczcJCYmwsqqdOIoHo8HMzMzJCYmqtTHjh070KxZM3h7e5e6ffXq1ejVqxf09PRw6dIlfPrpp8jNzcVnn30mt6+ioiIUFRXJfs/Ozlbj0RAEQRAEUZuoFdwsW7YM69atU9gmNDS0UgMCgIKCAuzfvx/ffvttmfvev61NmzbIy8vDzz//rDC4Wbt2LVatWlXmdhLkEARBEETt8fZzW9kVG7VqS6WkpCAtLU1hG2dnZ/z7779YvHgxMjIyZLeLxWIIhUIcPnwYw4cPV9jH3r17MWPGDLx58waWlpYK2549exaDBg1CYWEhBAJBuW0+nLl58+YN3N3dFfZLEARBEETNFBsbi4YNG8q9X62ZG0tLS6XBBgB4eXkhMzMTgYGBaNeuHQDg6tWrYFkWnp6eSo/fsWMHhgwZotK5Hj9+DFNTU7mBDQAIBIJS9xsYGCA2NhaGhoagKErpOapTdnY27O3tERsbS4p8gjwf7yPPRWnk+SiNPB/vkOeitNr8fHAch5ycnHI3Jr1PK2tumjVrhn79+mHmzJnYunUrRCIR5s2bh3HjxskG9ObNG/Tu3Rt79uxBx44dZcdGRETg5s2bOHfuXJl+T58+jaSkJHTq1AlCoRB+fn748ccf8cUXX6g1PpqmFUZ8NZGRkVGtexFqE3k+3iHPRWnk+SiNPB/vkOeitNr6fBgbGytto7U8N/v27cO8efPQu3dv0DSNkSNHYtOmTbL7RSIRwsLCkJ+fX+q4nTt3omHDhujbt2+ZPvl8PrZs2YLPP/8cHMfB1dUVGzduxMyZM7X1MAiCIAiCqGXUWnNDVL3s7GwYGxsjKyurVkbYmkaej3fIc1EaeT5KI8/HO+S5KK0+PB+ktlQNJxAIsHLlSoVriuoT8ny8Q56L0sjzURp5Pt4hz0Vp9eH5IDM3BEEQBEHUKWTmhiAIgiCIOoUENwRBEARB1CkkuCEIgiAIok4hwQ1BEARBEHUKCW5qoB9++AHe3t7Q09ODiYmJSsdwHIcVK1bA1tYWurq68PHxQXh4uHYHWgXS09MxceJEGBkZwcTEBDNmzEBubq7CY3r06AGKokr9zJ49u4pGrFlbtmyBo6MjhEIhPD09cf/+fYXtDx8+jKZNm0IoFKJly5blJsOszdR5Pnbv3l3mdSAUCqtwtNpz8+ZNDB48GHZ2dqAoCidOnFB6zPXr19G2bVsIBAK4urpi9+7dWh9nVVH3+bh+/XqZ1wZFUSoXdq7J1q5diw4dOsDQ0BBWVlYYNmwYwsLClB5X1947SHBTAxUXF2P06NGYM2eOysesX78emzZtwtatWxEQEAB9fX34+vqisLBQiyPVvokTJyIkJAR+fn44c+YMbt68iVmzZik9bubMmUhISJD9rF+/vgpGq1kHDx7EokWLsHLlSjx69AgeHh7w9fVFcnJyue3v3r2L8ePHY8aMGQgKCsKwYcMwbNgwPHv2rIpHrh3qPh+ANAPr+6+D6OjoKhyx9uTl5cHDwwNbtmxRqX1UVBQGDhyInj174vHjx1i4cCE+/vhjXLx4UcsjrRrqPh9vhYWFlXp9WFlZaWmEVefGjRuYO3cu7t27Bz8/P4hEIvTt2xd5eXlyj6mT7x0cUWPt2rWLMzY2VtqOZVnOxsaG+/nnn2W3ZWZmcgKBgPvvv/+0OELtev78OQeAe/Dggey28+fPcxRFcW/evJF7XPfu3bkFCxZUwQi1q2PHjtzcuXNlv0skEs7Ozo5bu3Ztue3HjBnDDRw4sNRtnp6e3CeffKLVcVYVdZ8PVf9+ajsA3PHjxxW2Wbp0Kde8efNSt40dO5bz9fXV4siqhyrPx7Vr1zgAXEZGRpWMqTolJydzALgbN27IbVMX3zvIzE0dEBUVhcTERPj4+MhuMzY2hqenJ/z9/atxZJXj7+8PExMTtG/fXnabj48PaJpGQECAwmP37dsHCwsLtGjRAsuXLy9T5qOmKy4uRmBgYKl/U5qm4ePjI/ff1N/fv1R7APD19a3Vr4G3KvJ8AEBubi4aNWoEe3t7DB06FCEhIVUx3BqnLr82KqN169awtbVFnz59cOfOneoejlZkZWUBAMzMzOS2qYuvD63VliKqztvrxNbW1qVut7a2rtXXkBMTE8tME/N4PJiZmSl8XBMmTECjRo1gZ2eHp0+f4ssvv0RYWBiOHTum7SFrTGpqKiQSSbn/pi9evCj3mMTExDr3GnirIs+Hm5sbdu7ciVatWiErKwsbNmyAt7c3QkJCal3h3MqS99rIzs5GQUEBdHV1q2lk1cPW1hZbt25F+/btUVRUhO3bt6NHjx4ICAhA27Ztq3t4GsOyLBYuXIjOnTujRYsWctvVxfcOEtxUkWXLlmHdunUK24SGhqJp06ZVNKLqo+pzUVHvr8lp2bIlbG1t0bt3b0RGRsLFxaXC/RK1i5eXF7y8vGS/e3t7o1mzZvjrr7+wZs2aahwZUd3c3Nzg5uYm+93b2xuRkZH49ddfsXfv3mocmWbNnTsXz549w+3bt6t7KFWOBDdVZPHixZg2bZrCNs7OzhXq28bGBgCQlJQEW1tb2e1JSUlo3bp1hfrUJlWfCxsbmzKLRcViMdLT02WPWRWenp4AgIiIiFoT3FhYWIBhGCQlJZW6PSkpSe5jt7GxUat9bVKR5+NDfD4fbdq0QUREhDaGWKPJe20YGRnVu1kbeTp27FingoB58+bJNmEom6msi+8dZM1NFbG0tETTpk0V/ujo6FSobycnJ9jY2ODKlSuy27KzsxEQEFDqm2tNoepz4eXlhczMTAQGBsqOvXr1KliWlQUsqnj8+DEAlAr8ajodHaC511QAAANRSURBVB20a9eu1L8py7K4cuWK3H9TLy+vUu0BwM/Pr0a+BtRVkefjQxKJBMHBwbXqdaApdfm1oSmPHz+uE68NjuMwb948HD9+HFevXoWTk5PSY+rk66O6VzQTZUVHR3NBQUHcqlWrOAMDAy4oKIgLCgricnJyZG3c3Ny4Y8eOyX7/6aefOBMTE+7kyZPc06dPuaFDh3JOTk5cQUFBdTwEjenXrx/Xpk0bLiAggLt9+zbXuHFjbvz48bL74+LiODc3Ny4gIIDjOI6LiIjgVq9ezT18+JCLioriTp48yTk7O3PdunWrrodQYQcOHOAEAgG3e/du7vnz59ysWbM4ExMTLjExkeM4jps8eTK3bNkyWfs7d+5wPB6P27BhAxcaGsqtXLmS4/P5XHBwcHU9BI1S9/lYtWoVd/HiRS4yMpILDAzkxo0bxwmFQi4kJKS6HoLG5OTkyN4XAHAbN27kgoKCuOjoaI7jOG7ZsmXc5MmTZe1fvXrF6enpcUuWLOFCQ0O5LVu2cAzDcBcuXKiuh6BR6j4fv/76K3fixAkuPDycCw4O5hYsWMDRNM1dvny5uh6CxsyZM4czNjbmrl+/ziUkJMh+8vPzZW3qw3sHCW5qoKlTp3IAyvxcu3ZN1gYAt2vXLtnvLMty3377LWdtbc0JBAKud+/eXFhYWNUPXsPS0tK48ePHcwYGBpyRkRE3ffr0UkFeVFRUqecmJiaG69atG2dmZsYJBALO1dWVW7JkCZeVlVVNj6ByNm/ezDk4OHA6Ojpcx44duXv37snu6969Ozd16tRS7Q8dOsQ1adKE09HR4Zo3b86dPXu2ikesXeo8HwsXLpS1tba25gYMGMA9evSoGkateW+3Mn/48/bxT506levevXuZY1q3bs3p6Ohwzs7Opd4/ajt1n49169ZxLi4unFAo5MzMzLgePXpwV69erZ7Ba1h5z8OHnxf14b2D4jiOq7JpIoIgCIIgCC0ja24IgiAIgqhTSHBDEARBEESdQoIbgiAIgiDqFBLcEARBEARRp5DghiAIgiCIOoUENwRBEARB1CkkuCEIgiAIok4hwQ1BEARBEHUKCW4IgiAIgqhTSHBDEARBEESdQoIbgiAIgiDqFBLcEARBEARRp/wfA1i1qE2a+DkAAAAASUVORK5CYII=\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors of dtype float\n", + "X = torch.tensor(X, dtype=torch.float)\n", + "y = torch.tensor(y, dtype=torch.float)\n", + "\n", + "# Split the data into train and test sets (80% train, 20% test)\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X,\n", + " y,\n", + " test_size=0.2,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "len(X_train), len(X_test), len(y_train), len(y_test)" + ], + "metadata": { + "id": "bDhyHn9fR4dq", + "outputId": "54e5018c-16b3-4879-d5c3-3b8fd29392bc", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(800, 200, 800, 200)" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Build a model by subclassing `nn.Module` that incorporates non-linear activation functions and is capable of fitting the data you created in 1.\n", + " * Feel free to use any combination of PyTorch layers (linear and non-linear) you want." + ], + "metadata": { + "id": "cMIjxZdzQfPz" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from torch import nn\n", + "\n", + "# Inherit from nn.Module to make a model capable of fitting the mooon data\n", + "class MoonModelV0(nn.Module):\n", + " ## Your code here ##\n", + " def __init__(self, in_features, out_features, hidden_units):\n", + " super().__init__()\n", + "\n", + " self.layer1 = nn.Linear(in_features=in_features,\n", + " out_features=hidden_units)\n", + " self.layer2 = nn.Linear(in_features=hidden_units,\n", + " out_features=hidden_units)\n", + " self.layer3 = nn.Linear(in_features=hidden_units,\n", + " out_features=out_features)\n", + " self.relu = nn.ReLU()\n", + "\n", + " def forward(self, x):\n", + " ## Your code here ##\n", + " return self.layer3(self.relu(self.layer2(self.relu(self.layer1(x)))))\n", + "# Instantiate the model\n", + "model_0 = MoonModelV0(in_features=2,\n", + " out_features=1,\n", + " hidden_units=10).to(device)\n", + " ## Your code here ##\n", + "model_0\n", + "model_0.state_dict()\n" + ], + "metadata": { + "id": "hwtyvm34Ri6Q", + "outputId": "ed95d535-2bfa-47be-f533-425ef8734562", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "OrderedDict([('layer1.weight',\n", + " tensor([[-0.5470, -0.6836],\n", + " [-0.6950, 0.4084],\n", + " [-0.2922, -0.2321],\n", + " [ 0.6820, -0.5020],\n", + " [-0.6546, -0.6460],\n", + " [-0.2421, -0.3052],\n", + " [ 0.5689, -0.4556],\n", + " [-0.3980, -0.3647],\n", + " [-0.5105, 0.1456],\n", + " [-0.3020, -0.0145]], device='cuda:0')),\n", + " ('layer1.bias',\n", + " tensor([-0.4632, 0.6134, -0.2137, 0.0313, 0.2942, 0.1956, 0.2712, 0.4399,\n", + " -0.3251, 0.4376], device='cuda:0')),\n", + " ('layer2.weight',\n", + " tensor([[ 0.1165, -0.0450, -0.1116, -0.1601, 0.1070, 0.1842, 0.3130, 0.2653,\n", + " -0.1831, 0.1318],\n", + " [ 0.1607, 0.0982, 0.0973, -0.2744, 0.0552, 0.1487, -0.2684, 0.2512,\n", + " -0.1862, 0.1385],\n", + " [ 0.0164, -0.2737, 0.1847, 0.3070, 0.1939, 0.1399, -0.2639, 0.3137,\n", + " 0.0070, 0.2273],\n", + " [ 0.0614, 0.1864, 0.0584, -0.1277, -0.2208, -0.2585, 0.2736, 0.2088,\n", + " 0.2896, 0.2426],\n", + " [ 0.2687, 0.2152, 0.0520, 0.0781, 0.1021, 0.2492, 0.0022, 0.0666,\n", + " -0.1148, 0.1932],\n", + " [-0.2938, -0.2830, -0.2036, -0.1110, -0.2106, -0.2842, 0.3041, 0.0025,\n", + " -0.2531, 0.0739],\n", + " [ 0.0978, 0.0700, -0.2572, -0.0159, -0.2283, -0.2082, -0.2708, -0.1413,\n", + " 0.2099, 0.2307],\n", + " [ 0.2255, 0.0754, -0.3120, -0.2223, -0.0177, -0.1004, 0.0213, 0.1084,\n", + " 0.2014, 0.3029],\n", + " [-0.0838, 0.1268, 0.1217, -0.2499, -0.0082, 0.0147, 0.3039, -0.2365,\n", + " -0.0534, -0.2617],\n", + " [ 0.0107, -0.3108, -0.1708, 0.1689, -0.2182, -0.0506, 0.0155, 0.2588,\n", + " 0.1216, 0.2880]], device='cuda:0')),\n", + " ('layer2.bias',\n", + " tensor([ 0.1875, -0.1325, -0.1128, 0.0385, 0.2302, 0.1784, -0.0004, -0.1464,\n", + " 0.3064, -0.0241], device='cuda:0')),\n", + " ('layer3.weight',\n", + " tensor([[-0.2544, 0.2815, 0.2945, -0.1788, -0.0604, -0.0120, -0.2550, -0.3014,\n", + " -0.2443, 0.2854]], device='cuda:0')),\n", + " ('layer3.bias', tensor([0.2758], device='cuda:0'))])" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Setup a binary classification compatible loss function and optimizer to use when training the model built in 2." + ], + "metadata": { + "id": "DSj97RwyVeFE" + } + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function\n", + "loss_fn = nn.BCEWithLogitsLoss()\n", + "# Setup optimizer to optimize model's parameters\n", + "optimizer = torch.optim.SGD(params=model_0.parameters(), # parameters of model to optimize\n", + " lr=0.1) # learning rate" + ], + "metadata": { + "id": "whSGw5qgVvxU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Create a training and testing loop to fit the model you created in 2 to the data you created in 1.\n", + " * Do a forward pass of the model to see what's coming out in the form of logits, prediction probabilities and labels.\n", + " * To measure model accuray, you can create your own accuracy function or use the accuracy function in [TorchMetrics](https://torchmetrics.readthedocs.io/en/latest/).\n", + " * Train the model for long enough for it to reach over 96% accuracy.\n", + " * The training loop should output progress every 10 epochs of the model's training and test set loss and accuracy." + ], + "metadata": { + "id": "nvk4PfNTWUAt" + } + }, + { + "cell_type": "code", + "source": [ + "# What's coming out of our model?\n", + "\n", + "# logits (raw outputs of model)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "print(model_0(X_train.to(device)[:10]).squeeze())\n", + "# Prediction probabilities\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "print(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze()))\n", + "\n", + "# Prediction labels\n", + "print(\"Pred labels:\")\n", + "## Your code here ##\n", + "print(torch.round(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze())))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AgnFdlamd2-D", + "outputId": "d5fe83a8-4bca-4840-f7cf-7d7bd0075b92" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Logits:\n", + "tensor([ 0.0768, 0.0087, -0.0099, -0.0048, 0.0583, -0.0122, 0.0910, 0.0062,\n", + " 0.0361, 0.0620], device='cuda:0', grad_fn=)\n", + "Pred probs:\n", + "tensor([0.5192, 0.5022, 0.4975, 0.4988, 0.5146, 0.4970, 0.5227, 0.5016, 0.5090,\n", + " 0.5155], device='cuda:0', grad_fn=)\n", + "Pred labels:\n", + "tensor([1., 1., 0., 0., 1., 0., 1., 1., 1., 1.], device='cuda:0',\n", + " grad_fn=)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy using accuracy from TorchMetrics\n", + "!pip -q install torchmetrics # Colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "## TODO: Uncomment this code to use the Accuracy function\n", + "acc_fn = Accuracy(task=\"multiclass\", num_classes=2).to(device) # send accuracy function to device\n", + "acc_fn" + ], + "metadata": { + "id": "rUSDNHB4euoJ", + "outputId": "25c62d81-a655-4228-b978-897cd129357e", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m23.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m106.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m86.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m53.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m64.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MulticlassAccuracy()" + ] + }, + "metadata": {}, + "execution_count": 24 + } + ] + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "fGmP1hSLn-DR" + } + }, + { + "cell_type": "code", + "source": [ + "##TODO: Uncomment this to set the seed\n", + "torch.manual_seed(RANDOM_SEED)\n", + "\n", + "# Setup epochs\n", + "epochs=1000\n", + "\n", + "# Send data to the device\n", + "X_train, y_train = X_train.to(device), y_train.to(device)\n", + "X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + "# Loop through the data\n", + "# for epoch in range(epochs):\n", + " ### Training\n", + "\n", + "\n", + " # 1. Forward pass (logits output)\n", + "y_logits = model_0(X_train).squeeze()\n", + " # Turn logits into prediction probabilities\n", + "y_pred_probs = torch.sigmoid(y_logits)\n", + "\n", + " # Turn prediction probabilities into prediction labels\n", + "y_pred = torch.round(y_pred_probs)\n", + "\n", + " # 2. Calculaute the loss\n", + "loss = loss_fn(y_logits, y_train) # loss = compare model raw outputs to desired model outputs\n", + " # Calculate the accuracy\n", + "acc = acc_fn(y_pred, y_train.int()) # the accuracy function needs to compare pred labels (not logits) with actual labels\n", + "\n", + " # 3. Zero the gradients\n", + "\n", + "\n", + " # 4. Loss backward (perform backpropagation) - https://brilliant.org/wiki/backpropagation/#:~:text=Backpropagation%2C%20short%20for%20%22backward%20propagation,to%20the%20neural%20network's%20weights.\n", + "\n", + " # 5. Step the optimizer (gradient descent) - https://towardsdatascience.com/gradient-descent-algorithm-a-deep-dive-cf04e8115f21#:~:text=Gradient%20descent%20(GD)%20is%20an,e.g.%20in%20a%20linear%20regression)\n", + "\n", + "\n", + " ### Testing\n", + " # model_0.eval()\n", + " # with torch.inference_mode():\n", + " # 1. Forward pass (to get the logits)\n", + "\n", + " # Turn the test logits into prediction labels\n", + "\n", + "\n", + " # 2. Caculate the test loss/acc\n", + "\n", + "\n", + " # Print out what's happening every 100 epochs\n", + " # if epoch % 100 == 0:\n" + ], + "metadata": { + "id": "SHBY3h7XXnxt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Make predictions with your trained model and plot them using the `plot_decision_boundary()` function created in this notebook." + ], + "metadata": { + "id": "8Nwihtomj9JO" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot the model predictions\n", + "import numpy as np\n", + "\n", + "def plot_decision_boundary(model, X, y):\n", + "\n", + " # Put everything to CPU (works better with NumPy + Matplotlib)\n", + " model.to(\"cpu\")\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Source - https://madewithml.com/courses/foundations/neural-networks/\n", + " # (with modifications)\n", + " x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n", + " y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n", + " xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101),\n", + " np.linspace(y_min, y_max, 101))\n", + "\n", + " # Make features\n", + " X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n", + "\n", + " # Make predictions\n", + " model.eval()\n", + " with torch.inference_mode():\n", + " y_logits = model(X_to_pred_on)\n", + "\n", + " # Test for multi-class or binary and adjust logits to prediction labels\n", + " if len(torch.unique(y)) > 2:\n", + " y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\n", + " else:\n", + " y_pred = torch.round(torch.sigmoid(y_logits)) # binary\n", + "\n", + " # Reshape preds and plot\n", + " y_pred = y_pred.reshape(xx.shape).detach().numpy()\n", + " plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n", + " plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + " plt.xlim(xx.min(), xx.max())\n", + " plt.ylim(yy.min(), yy.max())" + ], + "metadata": { + "id": "0YRzatb8a1P2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n" + ], + "metadata": { + "id": "PMrcpyirig1d" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Replicate the Tanh (hyperbolic tangent) activation function in pure PyTorch.\n", + " * Feel free to reference the [ML cheatsheet website](https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh) for the formula." + ], + "metadata": { + "id": "EtMYBvtciiAU" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a straight line tensor\n" + ], + "metadata": { + "id": "BlXaWC5TkEUE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Test torch.tanh() on the tensor and plot it\n" + ], + "metadata": { + "id": "vZPCcQmIkZjO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Replicate torch.tanh() and plot it\n" + ], + "metadata": { + "id": "J-ne__Kjkdc1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Create a multi-class dataset using the [spirals data creation function from CS231n](https://cs231n.github.io/neural-networks-case-study/) (see below for the code).\n", + " * Split the data into training and test sets (80% train, 20% test) as well as turn it into PyTorch tensors.\n", + " * Construct a model capable of fitting the data (you may need a combination of linear and non-linear layers).\n", + " * Build a loss function and optimizer capable of handling multi-class data (optional extension: use the Adam optimizer instead of SGD, you may have to experiment with different values of the learning rate to get it working).\n", + " * Make a training and testing loop for the multi-class data and train a model on it to reach over 95% testing accuracy (you can use any accuracy measuring function here that you like) - 1000 epochs should be plenty.\n", + " * Plot the decision boundaries on the spirals dataset from your model predictions, the `plot_decision_boundary()` function should work for this dataset too." + ], + "metadata": { + "id": "Lbt1bNcWk5G9" + } + }, + { + "cell_type": "code", + "source": [ + "# Code for creating a spiral dataset from CS231n\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "RANDOM_SEED = 42\n", + "np.random.seed(RANDOM_SEED)\n", + "N = 100 # number of points per class\n", + "D = 2 # dimensionality\n", + "K = 3 # number of classes\n", + "X = np.zeros((N*K,D)) # data matrix (each row = single example)\n", + "y = np.zeros(N*K, dtype='uint8') # class labels\n", + "for j in range(K):\n", + " ix = range(N*j,N*(j+1))\n", + " r = np.linspace(0.0,1,N) # radius\n", + " t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta\n", + " X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]\n", + " y[ix] = j\n", + "# lets visualize the data\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "tU-UNZsKlJls", + "outputId": "8b7b745a-070d-4ecb-c639-c4ee4d8eae06" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors\n", + "import torch\n", + "X = torch.from_numpy(X).type(torch.float) # features as float32\n", + "y = torch.from_numpy(y).type(torch.LongTensor) # labels need to be of type long\n", + "\n", + "# Create train and test splits\n", + "from sklearn.model_selection import train_test_split\n" + ], + "metadata": { + "id": "OWVrmkEyl0VP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy for when we fit our model\n", + "!pip -q install torchmetrics # colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "\n", + "## TODO: uncomment the two lines below to send the accuracy function to the device\n", + "# acc_fn = Accuracy(task=\"multiclass\", num_classes=4).to(device)\n", + "# acc_fn" + ], + "metadata": { + "id": "a-v-7f0op0tG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Prepare device agnostic code\n", + "# device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "# Create model by subclassing nn.Module\n", + "\n", + "\n", + "\n", + "# Instantiate model and send it to device\n" + ], + "metadata": { + "id": "DB3u3ldumapf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup data to be device agnostic\n", + "\n", + "\n", + "# Print out first 10 untrained model outputs (forward pass)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "\n", + "print(\"Pred labels:\")\n", + "## Your code here ##" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QE7XWSSunMTS", + "outputId": "00b31909-87c9-41e3-9dbb-fb4c4bd3aabd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Logits:\n", + "Pred probs:\n", + "Pred labels:\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function and optimizer\n", + "# loss_fn =\n", + "# optimizer =" + ], + "metadata": { + "id": "54EqLRKLo0AW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Build a training loop for the model\n", + "\n", + "# Loop over data\n", + "\n", + "\n", + " ## Training\n", + "\n", + " # 1. Forward pass\n", + "\n", + "\n", + " # 2. Calculate the loss\n", + "\n", + "\n", + " # 3. Optimizer zero grad\n", + "\n", + "\n", + " # 4. Loss backward\n", + "\n", + "\n", + " # 5. Optimizer step\n", + "\n", + "\n", + " ## Testing\n", + "\n", + "\n", + " # 1. Forward pass\n", + "\n", + " # 2. Caculate loss and acc\n", + "\n", + " # Print out what's happening every 100 epochs\n" + ], + "metadata": { + "id": "vIlExkUHnmxi" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n" + ], + "metadata": { + "id": "JrwVRbaE0keT" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From eff6522dcd9d3d25e5118f8fe33732187d9610cc Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 15 Feb 2025 22:20:28 +0000 Subject: [PATCH 06/17] Created using Colab --- .../exercise_submissions/week1.ipynb | 351 ++++++++++++++++++ 1 file changed, 351 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week1.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week1.ipynb b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week1.ipynb new file mode 100644 index 0000000..58fde0e --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week1.ipynb @@ -0,0 +1,351 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyNmgmQPfwDlOMc4/UDTVN3a", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "V5ABxNIOnyAr" + }, + "outputs": [], + "source": [ + "import torch" + ] + }, + { + "cell_type": "code", + "source": [ + "# create random tensor\n", + "X = torch.rand(size=(7,7))\n", + "X,X.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4sPUYe-AR22P", + "outputId": "ff2f59aa-db29-467f-a2ab-a196be08ee1a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.3142, 0.4865, 0.7705, 0.3263, 0.7264, 0.6868, 0.0522],\n", + " [0.5438, 0.9234, 0.6737, 0.3396, 0.4684, 0.9051, 0.9022],\n", + " [0.5038, 0.2225, 0.9657, 0.4975, 0.0989, 0.6913, 0.5937],\n", + " [0.7634, 0.8749, 0.1176, 0.0565, 0.5362, 0.1045, 0.6571],\n", + " [0.2290, 0.1231, 0.1060, 0.2285, 0.8602, 0.9666, 0.6981],\n", + " [0.5703, 0.9126, 0.0165, 0.9157, 0.9846, 0.1595, 0.7734],\n", + " [0.0339, 0.1776, 0.6518, 0.5989, 0.2043, 0.2849, 0.2325]]),\n", + " torch.Size([7, 7]))" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Create another random tensor\n", + "Y = torch.rand(size=(1, 7))\n", + "# Perform matrix multiplication\n", + "Z = torch.matmul(X, Y.T)\n", + "Z, Z.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RduF2fcySFm8", + "outputId": "c85f229b-27d6-4215-8292-adff242d0708" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[1.4617],\n", + " [1.7799],\n", + " [1.3014],\n", + " [0.9893],\n", + " [1.7503],\n", + " [1.7336],\n", + " [0.8774]]),\n", + " torch.Size([7, 1]))" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set manual seed\n", + "torch.manual_seed(0)\n", + "\n", + "# Create two random tensors\n", + "X = torch.rand(size=(7, 7))\n", + "Y = torch.rand(size=(1, 7))\n", + "\n", + "# Matrix multiply tensors\n", + "Z = torch.matmul(X, Y.T)\n", + "Z, Z.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XJT1P2NBSfMu", + "outputId": "cf85f2aa-6bf2-4cf9-855d-0e451701d738" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[1.8542],\n", + " [1.9611],\n", + " [2.2884],\n", + " [3.0481],\n", + " [1.7067],\n", + " [2.5290],\n", + " [1.7989]]),\n", + " torch.Size([7, 1]))" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set random seed on the GPU\n", + "torch.cuda.manual_seed(1234)" + ], + "metadata": { + "id": "rcgfaPeMWPg2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Set random seed\n", + "torch.manual_seed(1234)\n", + "\n", + "# Check for access to GPU\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(f\"Device: {device}\")\n", + "\n", + "# Create two random tensors on GPU\n", + "tensor_A = torch.rand(size=(2,3)).to(device)\n", + "tensor_B = torch.rand(size=(2,3)).to(device)\n", + "tensor_A, tensor_B" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kXGUX9tLWtQR", + "outputId": "e715efb1-6115-4218-9c82-df5f494945be" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Device: cpu\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.0290, 0.4019, 0.2598],\n", + " [0.3666, 0.0583, 0.7006]]),\n", + " tensor([[0.0518, 0.4681, 0.6738],\n", + " [0.3315, 0.7837, 0.5631]]))" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Perform matmul on tensor_A and tensor_B\n", + "tensor_C = torch.matmul(tensor_A, tensor_B.T)\n", + "tensor_C, tensor_C.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EzvxTswjW2GP", + "outputId": "1cf4adf2-6618-4b23-b23c-f451f482741d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([[0.3647, 0.4709],\n", + " [0.5184, 0.5617]]),\n", + " torch.Size([2, 2]))" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Find max\n", + "max = torch.max(tensor_C)\n", + "\n", + "# Find min\n", + "min = torch.min(tensor_C)\n", + "max, min" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lHPg2D23XDo6", + "outputId": "140287af-d71f-4e8d-b7c1-03ddb285f902" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor(0.5617), tensor(0.3647))" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Find arg max\n", + "arg_max = torch.argmax(tensor_C)\n", + "\n", + "# Find arg min\n", + "arg_min = torch.argmin(tensor_C)\n", + "arg_max, arg_min" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6Fcr_F6QXK_r", + "outputId": "b6045ba0-92a8-472f-de2f-104187b1b546" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor(3), tensor(0))" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Set seed\n", + "torch.manual_seed(7)\n", + "\n", + "# Create random tensor\n", + "tensor_D = torch.rand(size=(1, 1, 1, 10))\n", + "\n", + "# Remove single dimensions\n", + "tensor_E = tensor_D.squeeze()\n", + "\n", + "# Print out tensors\n", + "print(tensor_D, tensor_D.shape)\n", + "print(tensor_E, tensor_E.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "f9OBG49yXRVN", + "outputId": "e96e91a7-a407-4660-bba7-9867b3f6bb7f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tensor([[[[0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297,\n", + " 0.3653, 0.8513]]]]) torch.Size([1, 1, 1, 10])\n", + "tensor([0.5349, 0.1988, 0.6592, 0.6569, 0.2328, 0.4251, 0.2071, 0.6297, 0.3653,\n", + " 0.8513]) torch.Size([10])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "tz9_OxvrXXyr" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From f406796d1452d4afefd6a1f9ebbe8db5a3e6f307 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 15 Feb 2025 22:22:45 +0000 Subject: [PATCH 07/17] Created using Colab --- .../exercise_submissions/week2.ipynb | 724 ++++++++++++++++++ 1 file changed, 724 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week2.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week2.ipynb b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week2.ipynb new file mode 100644 index 0000000..c51d81f --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week2.ipynb @@ -0,0 +1,724 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 01. PyTorch Workflow Exercise Template\n", + "\n", + "The following is a template for the PyTorch workflow exercises.\n", + "\n", + "It's only starter code and it's your job to fill in the blanks.\n", + "\n", + "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n", + "\n", + "Don't worry about trying to be *right* just try writing code that suffices the question.\n", + "\n", + "You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)." + ], + "metadata": { + "id": "N8LsPXZti9Sw" + } + }, + { + "cell_type": "code", + "source": [ + "# Import necessary libraries\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "from torch import nn" + ], + "metadata": { + "id": "Glu2fM4dkNlx" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup device-agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n" + ], + "metadata": { + "id": "LqKhXY26m31s", + "outputId": "0e6e7442-e4c8-4869-954b-27c7aae6f1da", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Create a straight line dataset using the linear regression formula (`weight * X + bias`).\n", + " * Set `weight=0.3` and `bias=0.9` there should be at least 100 datapoints total.\n", + " * Split the data into 80% training, 20% testing.\n", + " * Plot the training and testing data so it becomes visual.\n", + "\n", + "Your output of the below cell should look something like:\n", + "```\n", + "Number of X samples: 100\n", + "Number of y samples: 100\n", + "First 10 X & y samples:\n", + "X: tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n", + " 0.0900])\n", + "y: tensor([0.9000, 0.9030, 0.9060, 0.9090, 0.9120, 0.9150, 0.9180, 0.9210, 0.9240,\n", + " 0.9270])\n", + "```\n", + "\n", + "Of course the numbers in `X` and `y` may be different but ideally they're created using the linear regression formula." + ], + "metadata": { + "id": "g7HUhxCxjeBx" + } + }, + { + "cell_type": "code", + "source": [ + "# Create the data parameters\n", + "weight = 0.3\n", + "bias = 0.9\n", + "# Make X and y using linear regression feature\n", + "X = torch.arange(0,1,0.01).unsqueeze(dim = 1)\n", + "y = weight * X + bias\n", + "print(f\"Number of X samples: {len(X)}\")\n", + "print(f\"Number of y samples: {len(y)}\")\n", + "print(f\"First 10 X & y samples:\\nX: {X[:10]}\\ny: {y[:10]}\")" + ], + "metadata": { + "id": "KbDG5MV7jhvE", + "outputId": "a2868ed1-4ca1-4a4d-eae8-8ff4bf6d9996", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Number of X samples: 100\n", + "Number of y samples: 100\n", + "First 10 X & y samples:\n", + "X: tensor([[0.0000],\n", + " [0.0100],\n", + " [0.0200],\n", + " [0.0300],\n", + " [0.0400],\n", + " [0.0500],\n", + " [0.0600],\n", + " [0.0700],\n", + " [0.0800],\n", + " [0.0900]])\n", + "y: tensor([[0.9000],\n", + " [0.9030],\n", + " [0.9060],\n", + " [0.9090],\n", + " [0.9120],\n", + " [0.9150],\n", + " [0.9180],\n", + " [0.9210],\n", + " [0.9240],\n", + " [0.9270]])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Split the data into training and testing\n", + "train_split = int(len(X) * 0.8)\n", + "X_train = X[:train_split]\n", + "y_train = y[:train_split]\n", + "X_test = X[train_split:]\n", + "y_test = y[train_split:]\n", + "len(X_train),len(y_train),len(X_test),len(y_test)\n" + ], + "metadata": { + "id": "GlwtT1djkmLw", + "outputId": "1b5f0c58-8f26-4df8-885e-e0203eeb9a09", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(80, 80, 20, 20)" + ] + }, + "metadata": {}, + "execution_count": 30 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot the training and testing data\n", + "def plot_predictions(train_data = X_train,\n", + " train_labels = y_train,\n", + " test_data = X_test,\n", + " test_labels = y_test,\n", + " predictions = None):\n", + " plt.figure(figsize = (10,7))\n", + " plt.scatter(train_data,train_labels,c = 'r',s = 5,label = \"Training data\")\n", + " plt.scatter(test_data,test_labels,c = 'b',s = 5,label = \"Test data\")\n", + "\n", + " if predictions is not None:\n", + " plt.scatter(test_data,predictions,c = 'g',s = 5,label = \"Predictions\")\n", + " plt.legend(prop = {\"size\" : 10})\n", + "plot_predictions()\n" + ], + "metadata": { + "id": "29iQZFNhlYJ-", + "outputId": "b97b8c89-ff33-4ae0-ec64-195249ecfdf8", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 599 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Build a PyTorch model by subclassing `nn.Module`.\n", + " * Inside should be a randomly initialized `nn.Parameter()` with `requires_grad=True`, one for `weights` and one for `bias`.\n", + " * Implement the `forward()` method to compute the linear regression function you used to create the dataset in 1.\n", + " * Once you've constructed the model, make an instance of it and check its `state_dict()`.\n", + " * **Note:** If you'd like to use `nn.Linear()` instead of `nn.Parameter()` you can." + ], + "metadata": { + "id": "ImZoe3v8jif8" + } + }, + { + "cell_type": "code", + "source": [ + "# Create PyTorch linear regression model by subclassing nn.Module\n", + "class LinearRegressionModel(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.linear_layer = nn.Linear(in_features = 1,\n", + " out_features = 1)\n", + " def forward(self,x : torch.Tensor) -> torch.Tensor:\n", + " return self.linear_layer(x)\n", + "torch.manual_seed(42)\n", + "model_1 = LinearRegressionModel()\n", + "model_1,model_1.state_dict()" + ], + "metadata": { + "id": "qzd__Y5rjtB8", + "outputId": "7437a819-2c41-4292-eafb-06da70d88fb9", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(LinearRegressionModel(\n", + " (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n", + " ),\n", + " OrderedDict([('linear_layer.weight', tensor([[0.7645]])),\n", + " ('linear_layer.bias', tensor([0.8300]))]))" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [ + "next(model_1.parameters()).device" + ], + "metadata": { + "id": "LQpVsgqg2Bvm", + "outputId": "57314bf0-92d2-49a7-d5c3-98be345541f6", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "device(type='cpu')" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Instantiate the model and put it to the target device\n", + "model_1.to(device)\n", + "list(model_1.parameters())" + ], + "metadata": { + "id": "5LdcDnmOmyQ2", + "outputId": "098a2e6b-05cb-431f-f4ba-5549ca273b7b", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[Parameter containing:\n", + " tensor([[0.7645]], device='cuda:0', requires_grad=True),\n", + " Parameter containing:\n", + " tensor([0.8300], device='cuda:0', requires_grad=True)]" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Create a loss function and optimizer using `nn.L1Loss()` and `torch.optim.SGD(params, lr)` respectively.\n", + " * Set the learning rate of the optimizer to be 0.01 and the parameters to optimize should be the model parameters from the model you created in 2.\n", + " * Write a training loop to perform the appropriate training steps for 300 epochs.\n", + " * The training loop should test the model on the test dataset every 20 epochs." + ], + "metadata": { + "id": "G6nYOrJhjtfu" + } + }, + { + "cell_type": "code", + "source": [ + "# Create the loss function and optimizer\n", + "loss_fn = nn.L1Loss()\n", + "optimizer = torch.optim.SGD(params = model_1.parameters(),\n", + " lr = 0.01)" + ], + "metadata": { + "id": "ltvoZ-FWjv1j" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Training loop\n", + "# Train model for 300 epochs\n", + "torch.manual_seed(42)\n", + "\n", + "epochs = 300\n", + "\n", + "# Send data to target device\n", + "X_train = X_train.to(device)\n", + "X_test = X_test.to(device)\n", + "y_train = y_train.to(device)\n", + "y_test = y_test.to(device)\n", + "\n", + "for epoch in range(epochs):\n", + " ### Training\n", + "\n", + " # Put model in train mode\n", + " model_1.train()\n", + "\n", + " # 1. Forward pass\n", + " y_pred = model_1(X_train)\n", + "\n", + " # 2. Calculate loss\n", + " loss = loss_fn(y_pred,y_train)\n", + "\n", + " # 3. Zero gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # 4. Backpropagation\n", + " loss.backward()\n", + "\n", + " # 5. Step the optimizer\n", + " optimizer.step()\n", + "\n", + " ### Perform testing every 20 epochs\n", + " if epoch % 20 == 0:\n", + " # Put model in evaluation mode and setup inference context\n", + " model_1.eval()\n", + " with torch.inference_mode():\n", + " # 1. Forward pass\n", + " y_preds = model_1(X_test)\n", + " # 2. Calculate test loss\n", + " test_loss = loss_fn(y_preds,y_test)\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Train loss: {loss:.3f} | Test loss: {test_loss:.3f}\")" + ], + "metadata": { + "id": "xpE83NvNnkdV", + "outputId": "e190714c-f4fb-4928-8735-3f24338ee9b0", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch: 0 | Train loss: 0.128 | Test loss: 0.337\n", + "Epoch: 20 | Train loss: 0.082 | Test loss: 0.218\n", + "Epoch: 40 | Train loss: 0.072 | Test loss: 0.175\n", + "Epoch: 60 | Train loss: 0.065 | Test loss: 0.153\n", + "Epoch: 80 | Train loss: 0.058 | Test loss: 0.137\n", + "Epoch: 100 | Train loss: 0.051 | Test loss: 0.121\n", + "Epoch: 120 | Train loss: 0.045 | Test loss: 0.104\n", + "Epoch: 140 | Train loss: 0.038 | Test loss: 0.088\n", + "Epoch: 160 | Train loss: 0.031 | Test loss: 0.072\n", + "Epoch: 180 | Train loss: 0.024 | Test loss: 0.056\n", + "Epoch: 200 | Train loss: 0.017 | Test loss: 0.040\n", + "Epoch: 220 | Train loss: 0.010 | Test loss: 0.024\n", + "Epoch: 240 | Train loss: 0.003 | Test loss: 0.007\n", + "Epoch: 260 | Train loss: 0.008 | Test loss: 0.007\n", + "Epoch: 280 | Train loss: 0.008 | Test loss: 0.007\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Make predictions with the trained model on the test data.\n", + " * Visualize these predictions against the original training and testing data (**note:** you may need to make sure the predictions are *not* on the GPU if you want to use non-CUDA-enabled libraries such as matplotlib to plot)." + ], + "metadata": { + "id": "x4j4TM18jwa7" + } + }, + { + "cell_type": "code", + "source": [ + "# Make predictions with the model\n", + "model_1.eval()\n", + "\n", + "with torch.inference_mode():\n", + " y_preds = model_1(X_test)\n", + "y_preds" + ], + "metadata": { + "id": "bbMPK5Qjjyx_", + "outputId": "92aa19b8-8495-44a0-b89a-864259250bc3", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[1.1333],\n", + " [1.1363],\n", + " [1.1393],\n", + " [1.1423],\n", + " [1.1454],\n", + " [1.1484],\n", + " [1.1514],\n", + " [1.1545],\n", + " [1.1575],\n", + " [1.1605],\n", + " [1.1635],\n", + " [1.1666],\n", + " [1.1696],\n", + " [1.1726],\n", + " [1.1757],\n", + " [1.1787],\n", + " [1.1817],\n", + " [1.1847],\n", + " [1.1878],\n", + " [1.1908]], device='cuda:0')" + ] + }, + "metadata": {}, + "execution_count": 39 + } + ] + }, + { + "cell_type": "code", + "source": [ + "y_preds.cpu()" + ], + "metadata": { + "id": "OPU8PJbS2fnm", + "outputId": "06733a03-73e9-458d-bcf3-ebe67a9fb7b5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[1.1333],\n", + " [1.1363],\n", + " [1.1393],\n", + " [1.1423],\n", + " [1.1454],\n", + " [1.1484],\n", + " [1.1514],\n", + " [1.1545],\n", + " [1.1575],\n", + " [1.1605],\n", + " [1.1635],\n", + " [1.1666],\n", + " [1.1696],\n", + " [1.1726],\n", + " [1.1757],\n", + " [1.1787],\n", + " [1.1817],\n", + " [1.1847],\n", + " [1.1878],\n", + " [1.1908]])" + ] + }, + "metadata": {}, + "execution_count": 40 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot the predictions (these may need to be on a specific device)\n", + "plot_predictions(predictions = y_preds.cpu())" + ], + "metadata": { + "id": "K3BdmQaDpFo8", + "outputId": "7317e273-37e6-48aa-b905-1ab1f9f3c2f2", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 599 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Save your trained model's `state_dict()` to file.\n", + " * Create a new instance of your model class you made in 2. and load in the `state_dict()` you just saved to it.\n", + " * Perform predictions on your test data with the loaded model and confirm they match the original model predictions from 4." + ], + "metadata": { + "id": "s2OnlMWKjzX8" + } + }, + { + "cell_type": "code", + "source": [ + "from pathlib import Path\n", + "\n", + "# 1. Create models directory\n", + "MODEL_PATH = Path(\"models\")\n", + "MODEL_PATH.mkdir(parents = True,exist_ok = True)\n", + "# 2. Create model save path\n", + "MODEL_NAME = \"01_pytorch_model1\"\n", + "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n", + "# 3. Save the model state dict\n", + "print(f\"Saving model to {MODEL_SAVE_PATH}\")\n", + "torch.save(obj = model_1.state_dict(),f = MODEL_SAVE_PATH)\n" + ], + "metadata": { + "id": "hgxhgD14qr-i", + "outputId": "04412cb6-a060-4d32-96f1-7e2fca0b5944", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saving model to models/01_pytorch_model1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Create new instance of model and load saved state dict (make sure to put it on the target device)\n", + "loaded_model = LinearRegressionModel()\n", + "loaded_model.load_state_dict(torch.load(f = MODEL_SAVE_PATH))\n", + "loaded_model.to(device)" + ], + "metadata": { + "id": "P9vTgiLRrJ7T", + "outputId": "fddc6cc9-2692-4d22-c637-0a0f95597c32", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":3: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " loaded_model.load_state_dict(torch.load(f = MODEL_SAVE_PATH))\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "LinearRegressionModel(\n", + " (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 43 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make predictions with loaded model and compare them to the previous\n", + "y_preds_new = loaded_model(X_test)\n", + "y_preds == y_preds_new" + ], + "metadata": { + "id": "8UGX3VebrVtI", + "outputId": "e17b6491-8995-41b5-cd76-6873b5b2137a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True],\n", + " [True]], device='cuda:0')" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ] + } + ] +} \ No newline at end of file From 5242c5853ef08a27833d4f5240d52e125f2bb434 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 15 Feb 2025 22:25:56 +0000 Subject: [PATCH 08/17] Created using Colab --- .../exercise_submissions/week3.ipynb | 557 ++++++++++++------ 1 file changed, 385 insertions(+), 172 deletions(-) diff --git a/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb index b86b108..94ad66c 100644 --- a/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb +++ b/Part_1_Deep_Learning_with_Pytorch/exercise_submissions/week3.ipynb @@ -64,7 +64,7 @@ "metadata": { "id": "CSrUPgapO0tf" }, - "execution_count": null, + "execution_count": 15, "outputs": [] }, { @@ -93,12 +93,12 @@ ], "metadata": { "id": "5t4VhPV1PX1X", - "outputId": "ed1efa82-95db-4ac0-c5b0-86b9f97b8fbd", + "outputId": "88e33069-75ee-48cd-8e9f-06669f7db812", "colab": { "base_uri": "https://localhost:8080/" } }, - "execution_count": null, + "execution_count": 16, "outputs": [ { "output_type": "execute_result", @@ -118,7 +118,7 @@ ] }, "metadata": {}, - "execution_count": 3 + "execution_count": 16 } ] }, @@ -134,13 +134,13 @@ ], "metadata": { "id": "SUeHZ3-3P9C7", - "outputId": "f0344982-1235-4973-85eb-8728806c6cd5", + "outputId": "7ab24745-f8e6-46cc-8a14-5053c4aa3223", "colab": { "base_uri": "https://localhost:8080/", "height": 206 } }, - "execution_count": null, + "execution_count": 17, "outputs": [ { "output_type": "execute_result", @@ -155,7 +155,7 @@ ], "text/html": [ "\n", - "
\n", + "
\n", "
\n", "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
X0X1y
0-0.0334110.4213911
10.998827-0.4428901
20.889592-0.3278431
30.341958-0.4176901
4-0.8385310.5323750
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - " \n", - "\n", - "\n", - "\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "variable_name": "data_df", - "summary": "{\n \"name\": \"data_df\",\n \"rows\": 1000,\n \"fields\": [\n {\n \"column\": \"X0\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.8694818021016458,\n \"min\": -1.1517146477802855,\n \"max\": 2.1819758362649324,\n \"num_unique_values\": 1000,\n \"samples\": [\n 0.5424909907290043,\n 0.8410600562502046,\n 1.274536542513856\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"X1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.4984727335666475,\n \"min\": -0.6690694860909892,\n \"max\": 1.132945524956193,\n \"num_unique_values\": 1000,\n \"samples\": [\n -0.39644452406089203,\n 0.6354459945668033,\n -0.4373423036321222\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {}, - "execution_count": 4 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Visualize the data on a scatter plot\n", - "import matplotlib.pyplot as plt\n", - "plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlGn_r);" - ], - "metadata": { - "id": "owrkPSFvQPFI", - "outputId": "9e3a4075-43f2-4a72-e702-15460cfb665d", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 430 - } - }, - "execution_count": 7, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Turn data into tensors of dtype float\n", - "X = torch.tensor(X, dtype=torch.float)\n", - "y = torch.tensor(y, dtype=torch.float)\n", - "\n", - "# Split the data into train and test sets (80% train, 20% test)\n", - "from sklearn.model_selection import train_test_split\n", - "X_train, X_test, y_train, y_test = train_test_split(X,\n", - " y,\n", - " test_size=0.2,\n", - " random_state=RANDOM_SEED)\n", - "\n", - "len(X_train), len(X_test), len(y_train), len(y_test)" - ], - "metadata": { - "id": "bDhyHn9fR4dq", - "outputId": "54e5018c-16b3-4879-d5c3-3b8fd29392bc", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "execution_count": 8, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(800, 200, 800, 200)" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 2. Build a model by subclassing `nn.Module` that incorporates non-linear activation functions and is capable of fitting the data you created in 1.\n", - " * Feel free to use any combination of PyTorch layers (linear and non-linear) you want." - ], - "metadata": { - "id": "cMIjxZdzQfPz" - } - }, - { - "cell_type": "code", - "source": [ - "import torch\n", - "from torch import nn\n", - "\n", - "# Inherit from nn.Module to make a model capable of fitting the mooon data\n", - "class MoonModelV0(nn.Module):\n", - " ## Your code here ##\n", - " def __init__(self, in_features, out_features, hidden_units):\n", - " super().__init__()\n", - "\n", - " self.layer1 = nn.Linear(in_features=in_features,\n", - " out_features=hidden_units)\n", - " self.layer2 = nn.Linear(in_features=hidden_units,\n", - " out_features=hidden_units)\n", - " self.layer3 = nn.Linear(in_features=hidden_units,\n", - " out_features=out_features)\n", - " self.relu = nn.ReLU()\n", - "\n", - " def forward(self, x):\n", - " ## Your code here ##\n", - " return self.layer3(self.relu(self.layer2(self.relu(self.layer1(x)))))\n", - "# Instantiate the model\n", - "model_0 = MoonModelV0(in_features=2,\n", - " out_features=1,\n", - " hidden_units=10).to(device)\n", - " ## Your code here ##\n", - "model_0\n", - "model_0.state_dict()\n" - ], - "metadata": { - "id": "hwtyvm34Ri6Q", - "outputId": "ed95d535-2bfa-47be-f533-425ef8734562", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "execution_count": 21, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "OrderedDict([('layer1.weight',\n", - " tensor([[-0.5470, -0.6836],\n", - " [-0.6950, 0.4084],\n", - " [-0.2922, -0.2321],\n", - " [ 0.6820, -0.5020],\n", - " [-0.6546, -0.6460],\n", - " [-0.2421, -0.3052],\n", - " [ 0.5689, -0.4556],\n", - " [-0.3980, -0.3647],\n", - " [-0.5105, 0.1456],\n", - " [-0.3020, -0.0145]], device='cuda:0')),\n", - " ('layer1.bias',\n", - " tensor([-0.4632, 0.6134, -0.2137, 0.0313, 0.2942, 0.1956, 0.2712, 0.4399,\n", - " -0.3251, 0.4376], device='cuda:0')),\n", - " ('layer2.weight',\n", - " tensor([[ 0.1165, -0.0450, -0.1116, -0.1601, 0.1070, 0.1842, 0.3130, 0.2653,\n", - " -0.1831, 0.1318],\n", - " [ 0.1607, 0.0982, 0.0973, -0.2744, 0.0552, 0.1487, -0.2684, 0.2512,\n", - " -0.1862, 0.1385],\n", - " [ 0.0164, -0.2737, 0.1847, 0.3070, 0.1939, 0.1399, -0.2639, 0.3137,\n", - " 0.0070, 0.2273],\n", - " [ 0.0614, 0.1864, 0.0584, -0.1277, -0.2208, -0.2585, 0.2736, 0.2088,\n", - " 0.2896, 0.2426],\n", - " [ 0.2687, 0.2152, 0.0520, 0.0781, 0.1021, 0.2492, 0.0022, 0.0666,\n", - " -0.1148, 0.1932],\n", - " [-0.2938, -0.2830, -0.2036, -0.1110, -0.2106, -0.2842, 0.3041, 0.0025,\n", - " -0.2531, 0.0739],\n", - " [ 0.0978, 0.0700, -0.2572, -0.0159, -0.2283, -0.2082, -0.2708, -0.1413,\n", - " 0.2099, 0.2307],\n", - " [ 0.2255, 0.0754, -0.3120, -0.2223, -0.0177, -0.1004, 0.0213, 0.1084,\n", - " 0.2014, 0.3029],\n", - " [-0.0838, 0.1268, 0.1217, -0.2499, -0.0082, 0.0147, 0.3039, -0.2365,\n", - " -0.0534, -0.2617],\n", - " [ 0.0107, -0.3108, -0.1708, 0.1689, -0.2182, -0.0506, 0.0155, 0.2588,\n", - " 0.1216, 0.2880]], device='cuda:0')),\n", - " ('layer2.bias',\n", - " tensor([ 0.1875, -0.1325, -0.1128, 0.0385, 0.2302, 0.1784, -0.0004, -0.1464,\n", - " 0.3064, -0.0241], device='cuda:0')),\n", - " ('layer3.weight',\n", - " tensor([[-0.2544, 0.2815, 0.2945, -0.1788, -0.0604, -0.0120, -0.2550, -0.3014,\n", - " -0.2443, 0.2854]], device='cuda:0')),\n", - " ('layer3.bias', tensor([0.2758], device='cuda:0'))])" - ] - }, - "metadata": {}, - "execution_count": 21 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 3. Setup a binary classification compatible loss function and optimizer to use when training the model built in 2." - ], - "metadata": { - "id": "DSj97RwyVeFE" - } - }, - { - "cell_type": "code", - "source": [ - "# Setup loss function\n", - "loss_fn = nn.BCEWithLogitsLoss()\n", - "# Setup optimizer to optimize model's parameters\n", - "optimizer = torch.optim.SGD(params=model_0.parameters(), # parameters of model to optimize\n", - " lr=0.1) # learning rate" - ], - "metadata": { - "id": "whSGw5qgVvxU" - }, - "execution_count": 22, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "## 4. Create a training and testing loop to fit the model you created in 2 to the data you created in 1.\n", - " * Do a forward pass of the model to see what's coming out in the form of logits, prediction probabilities and labels.\n", - " * To measure model accuray, you can create your own accuracy function or use the accuracy function in [TorchMetrics](https://torchmetrics.readthedocs.io/en/latest/).\n", - " * Train the model for long enough for it to reach over 96% accuracy.\n", - " * The training loop should output progress every 10 epochs of the model's training and test set loss and accuracy." - ], - "metadata": { - "id": "nvk4PfNTWUAt" - } - }, - { - "cell_type": "code", - "source": [ - "# What's coming out of our model?\n", - "\n", - "# logits (raw outputs of model)\n", - "print(\"Logits:\")\n", - "## Your code here ##\n", - "print(model_0(X_train.to(device)[:10]).squeeze())\n", - "# Prediction probabilities\n", - "print(\"Pred probs:\")\n", - "## Your code here ##\n", - "print(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze()))\n", - "\n", - "# Prediction labels\n", - "print(\"Pred labels:\")\n", - "## Your code here ##\n", - "print(torch.round(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze())))\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "AgnFdlamd2-D", - "outputId": "d5fe83a8-4bca-4840-f7cf-7d7bd0075b92" - }, - "execution_count": 23, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Logits:\n", - "tensor([ 0.0768, 0.0087, -0.0099, -0.0048, 0.0583, -0.0122, 0.0910, 0.0062,\n", - " 0.0361, 0.0620], device='cuda:0', grad_fn=)\n", - "Pred probs:\n", - "tensor([0.5192, 0.5022, 0.4975, 0.4988, 0.5146, 0.4970, 0.5227, 0.5016, 0.5090,\n", - " 0.5155], device='cuda:0', grad_fn=)\n", - "Pred labels:\n", - "tensor([1., 1., 0., 0., 1., 0., 1., 1., 1., 1.], device='cuda:0',\n", - " grad_fn=)\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Let's calculuate the accuracy using accuracy from TorchMetrics\n", - "!pip -q install torchmetrics # Colab doesn't come with torchmetrics\n", - "from torchmetrics import Accuracy\n", - "## TODO: Uncomment this code to use the Accuracy function\n", - "acc_fn = Accuracy(task=\"multiclass\", num_classes=2).to(device) # send accuracy function to device\n", - "acc_fn" - ], - "metadata": { - "id": "rUSDNHB4euoJ", - "outputId": "25c62d81-a655-4228-b978-897cd129357e", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "execution_count": 24, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m23.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m1.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m106.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m86.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m53.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m64.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25h" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "MulticlassAccuracy()" - ] - }, - "metadata": {}, - "execution_count": 24 - } - ] - }, - { - "cell_type": "markdown", - "source": [], - "metadata": { - "id": "fGmP1hSLn-DR" - } - }, - { - "cell_type": "code", - "source": [ - "##TODO: Uncomment this to set the seed\n", - "torch.manual_seed(RANDOM_SEED)\n", - "\n", - "# Setup epochs\n", - "epochs=1000\n", - "\n", - "# Send data to the device\n", - "X_train, y_train = X_train.to(device), y_train.to(device)\n", - "X_test, y_test = X_test.to(device), y_test.to(device)\n", - "\n", - "# Loop through the data\n", - "# for epoch in range(epochs):\n", - " ### Training\n", - "\n", - "\n", - " # 1. Forward pass (logits output)\n", - "y_logits = model_0(X_train).squeeze()\n", - " # Turn logits into prediction probabilities\n", - "y_pred_probs = torch.sigmoid(y_logits)\n", - "\n", - " # Turn prediction probabilities into prediction labels\n", - "y_pred = torch.round(y_pred_probs)\n", - "\n", - " # 2. Calculaute the loss\n", - "loss = loss_fn(y_logits, y_train) # loss = compare model raw outputs to desired model outputs\n", - " # Calculate the accuracy\n", - "acc = acc_fn(y_pred, y_train.int()) # the accuracy function needs to compare pred labels (not logits) with actual labels\n", - "\n", - " # 3. Zero the gradients\n", - "\n", - "\n", - " # 4. Loss backward (perform backpropagation) - https://brilliant.org/wiki/backpropagation/#:~:text=Backpropagation%2C%20short%20for%20%22backward%20propagation,to%20the%20neural%20network's%20weights.\n", - "\n", - " # 5. Step the optimizer (gradient descent) - https://towardsdatascience.com/gradient-descent-algorithm-a-deep-dive-cf04e8115f21#:~:text=Gradient%20descent%20(GD)%20is%20an,e.g.%20in%20a%20linear%20regression)\n", - "\n", - "\n", - " ### Testing\n", - " # model_0.eval()\n", - " # with torch.inference_mode():\n", - " # 1. Forward pass (to get the logits)\n", - "\n", - " # Turn the test logits into prediction labels\n", - "\n", - "\n", - " # 2. Caculate the test loss/acc\n", - "\n", - "\n", - " # Print out what's happening every 100 epochs\n", - " # if epoch % 100 == 0:\n", - "" - ], - "metadata": { - "id": "SHBY3h7XXnxt" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "## 5. Make predictions with your trained model and plot them using the `plot_decision_boundary()` function created in this notebook." - ], - "metadata": { - "id": "8Nwihtomj9JO" - } - }, - { - "cell_type": "code", - "source": [ - "# Plot the model predictions\n", - "import numpy as np\n", - "\n", - "def plot_decision_boundary(model, X, y):\n", - "\n", - " # Put everything to CPU (works better with NumPy + Matplotlib)\n", - " model.to(\"cpu\")\n", - " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", - "\n", - " # Source - https://madewithml.com/courses/foundations/neural-networks/\n", - " # (with modifications)\n", - " x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n", - " y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n", - " xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101),\n", - " np.linspace(y_min, y_max, 101))\n", - "\n", - " # Make features\n", - " X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n", - "\n", - " # Make predictions\n", - " model.eval()\n", - " with torch.inference_mode():\n", - " y_logits = model(X_to_pred_on)\n", - "\n", - " # Test for multi-class or binary and adjust logits to prediction labels\n", - " if len(torch.unique(y)) > 2:\n", - " y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\n", - " else:\n", - " y_pred = torch.round(torch.sigmoid(y_logits)) # binary\n", - "\n", - " # Reshape preds and plot\n", - " y_pred = y_pred.reshape(xx.shape).detach().numpy()\n", - " plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n", - " plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", - " plt.xlim(xx.min(), xx.max())\n", - " plt.ylim(yy.min(), yy.max())" - ], - "metadata": { - "id": "0YRzatb8a1P2" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Plot decision boundaries for training and test sets\n" - ], - "metadata": { - "id": "PMrcpyirig1d" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "## 6. Replicate the Tanh (hyperbolic tangent) activation function in pure PyTorch.\n", - " * Feel free to reference the [ML cheatsheet website](https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh) for the formula." - ], - "metadata": { - "id": "EtMYBvtciiAU" - } - }, - { - "cell_type": "code", - "source": [ - "# Create a straight line tensor\n" - ], - "metadata": { - "id": "BlXaWC5TkEUE" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Test torch.tanh() on the tensor and plot it\n" - ], - "metadata": { - "id": "vZPCcQmIkZjO" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Replicate torch.tanh() and plot it\n" - ], - "metadata": { - "id": "J-ne__Kjkdc1" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "## 7. Create a multi-class dataset using the [spirals data creation function from CS231n](https://cs231n.github.io/neural-networks-case-study/) (see below for the code).\n", - " * Split the data into training and test sets (80% train, 20% test) as well as turn it into PyTorch tensors.\n", - " * Construct a model capable of fitting the data (you may need a combination of linear and non-linear layers).\n", - " * Build a loss function and optimizer capable of handling multi-class data (optional extension: use the Adam optimizer instead of SGD, you may have to experiment with different values of the learning rate to get it working).\n", - " * Make a training and testing loop for the multi-class data and train a model on it to reach over 95% testing accuracy (you can use any accuracy measuring function here that you like) - 1000 epochs should be plenty.\n", - " * Plot the decision boundaries on the spirals dataset from your model predictions, the `plot_decision_boundary()` function should work for this dataset too." - ], - "metadata": { - "id": "Lbt1bNcWk5G9" - } - }, - { - "cell_type": "code", - "source": [ - "# Code for creating a spiral dataset from CS231n\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "RANDOM_SEED = 42\n", - "np.random.seed(RANDOM_SEED)\n", - "N = 100 # number of points per class\n", - "D = 2 # dimensionality\n", - "K = 3 # number of classes\n", - "X = np.zeros((N*K,D)) # data matrix (each row = single example)\n", - "y = np.zeros(N*K, dtype='uint8') # class labels\n", - "for j in range(K):\n", - " ix = range(N*j,N*(j+1))\n", - " r = np.linspace(0.0,1,N) # radius\n", - " t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta\n", - " X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]\n", - " y[ix] = j\n", - "# lets visualize the data\n", - "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - }, - "id": "tU-UNZsKlJls", - "outputId": "8b7b745a-070d-4ecb-c639-c4ee4d8eae06" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Turn data into tensors\n", - "import torch\n", - "X = torch.from_numpy(X).type(torch.float) # features as float32\n", - "y = torch.from_numpy(y).type(torch.LongTensor) # labels need to be of type long\n", - "\n", - "# Create train and test splits\n", - "from sklearn.model_selection import train_test_split\n" - ], - "metadata": { - "id": "OWVrmkEyl0VP" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Let's calculuate the accuracy for when we fit our model\n", - "!pip -q install torchmetrics # colab doesn't come with torchmetrics\n", - "from torchmetrics import Accuracy\n", - "\n", - "## TODO: uncomment the two lines below to send the accuracy function to the device\n", - "# acc_fn = Accuracy(task=\"multiclass\", num_classes=4).to(device)\n", - "# acc_fn" - ], - "metadata": { - "id": "a-v-7f0op0tG" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Prepare device agnostic code\n", - "# device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", - "\n", - "# Create model by subclassing nn.Module\n", - "\n", - "\n", - "\n", - "# Instantiate model and send it to device\n" - ], - "metadata": { - "id": "DB3u3ldumapf" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Setup data to be device agnostic\n", - "\n", - "\n", - "# Print out first 10 untrained model outputs (forward pass)\n", - "print(\"Logits:\")\n", - "## Your code here ##\n", - "\n", - "print(\"Pred probs:\")\n", - "## Your code here ##\n", - "\n", - "print(\"Pred labels:\")\n", - "## Your code here ##" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "QE7XWSSunMTS", - "outputId": "00b31909-87c9-41e3-9dbb-fb4c4bd3aabd" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Logits:\n", - "Pred probs:\n", - "Pred labels:\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Setup loss function and optimizer\n", - "# loss_fn =\n", - "# optimizer =" - ], - "metadata": { - "id": "54EqLRKLo0AW" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Build a training loop for the model\n", - "\n", - "# Loop over data\n", - "\n", - "\n", - " ## Training\n", - "\n", - " # 1. Forward pass\n", - "\n", - "\n", - " # 2. Calculate the loss\n", - "\n", - "\n", - " # 3. Optimizer zero grad\n", - "\n", - "\n", - " # 4. Loss backward\n", - "\n", - "\n", - " # 5. Optimizer step\n", - "\n", - "\n", - " ## Testing\n", - "\n", - "\n", - " # 1. Forward pass\n", - "\n", - " # 2. Caculate loss and acc\n", - "\n", - " # Print out what's happening every 100 epochs\n", - "" - ], - "metadata": { - "id": "vIlExkUHnmxi" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Plot decision boundaries for training and test sets\n" - ], - "metadata": { - "id": "JrwVRbaE0keT" - }, - "execution_count": null, - "outputs": [] - } - ] -} \ No newline at end of file From 66aaa7c58c6743f7fecd2d910965f8dbd21f2aba Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 22 Feb 2025 20:07:58 +0000 Subject: [PATCH 10/17] Created using Colab --- Part_1_Deep_Learning_with_Pytorch/week3.ipynb | 1338 +++++++++++++++++ 1 file changed, 1338 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week3.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week3.ipynb b/Part_1_Deep_Learning_with_Pytorch/week3.ipynb new file mode 100644 index 0000000..d929847 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week3.ipynb @@ -0,0 +1,1338 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "02_pytorch_classification_exercises.ipynb", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 02. PyTorch Classification Exercises\n", + "\n", + "The following is a template for 02. PyTorch Classification exercises.\n", + "\n", + "It's only starter code and it's your job to fill in the blanks.\n", + "\n", + "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n", + "\n", + "Don't worry about trying to be *right* just try writing code that suffices the question.\n", + "\n", + "## Resources\n", + "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n", + "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)." + ], + "metadata": { + "id": "ZKJFt7YxH8yl" + } + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Setup device agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n", + "\n", + "# Setup random seed\n", + "RANDOM_SEED = 42" + ], + "metadata": { + "id": "CSrUPgapO0tf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n", + " * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n", + " * Turn the data into PyTorch tensors.\n", + " * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing." + ], + "metadata": { + "id": "pH7jIZ2SPFee" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a dataset with Scikit-Learn's make_moons()\n", + "from sklearn.datasets import make_moons\n", + "NUM_SAMPLES = 1000\n", + "X, y = make_moons(n_samples=NUM_SAMPLES,\n", + " noise=0.07,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "X[:10], y[:10]" + ], + "metadata": { + "id": "5t4VhPV1PX1X", + "outputId": "88e33069-75ee-48cd-8e9f-06669f7db812", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(array([[-0.03341062, 0.4213911 ],\n", + " [ 0.99882703, -0.4428903 ],\n", + " [ 0.88959204, -0.32784256],\n", + " [ 0.34195829, -0.41768975],\n", + " [-0.83853099, 0.53237483],\n", + " [ 0.59906425, -0.28977331],\n", + " [ 0.29009023, -0.2046885 ],\n", + " [-0.03826868, 0.45942924],\n", + " [ 1.61377123, -0.2939697 ],\n", + " [ 0.693337 , 0.82781911]]),\n", + " array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0]))" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into a DataFrame\n", + "import pandas as pd\n", + "data_df = pd.DataFrame({\"X0\": X[:, 0],\n", + " \"X1\": X[:, 1],\n", + " \"y\": y})\n", + "data_df.head()" + ], + "metadata": { + "id": "SUeHZ3-3P9C7", + "outputId": "7ab24745-f8e6-46cc-8a14-5053c4aa3223", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " X0 X1 y\n", + "0 -0.033411 0.421391 1\n", + "1 0.998827 -0.442890 1\n", + "2 0.889592 -0.327843 1\n", + "3 0.341958 -0.417690 1\n", + "4 -0.838531 0.532375 0" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X0X1y
0-0.0334110.4213911
10.998827-0.4428901
20.889592-0.3278431
30.341958-0.4176901
4-0.8385310.5323750
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "data_df", + "summary": "{\n \"name\": \"data_df\",\n \"rows\": 1000,\n \"fields\": [\n {\n \"column\": \"X0\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.8694818021016458,\n \"min\": -1.1517146477802855,\n \"max\": 2.1819758362649324,\n \"num_unique_values\": 1000,\n \"samples\": [\n 0.5424909907290043,\n 0.8410600562502046,\n 1.274536542513856\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"X1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.4984727335666475,\n \"min\": -0.6690694860909892,\n \"max\": 1.132945524956193,\n \"num_unique_values\": 1000,\n \"samples\": [\n -0.39644452406089203,\n 0.6354459945668033,\n -0.4373423036321222\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Visualize the data on a scatter plot\n", + "import matplotlib.pyplot as plt\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlGn_r);" + ], + "metadata": { + "id": "owrkPSFvQPFI", + "outputId": "6d2f18dc-e193-44d9-8b8a-d227162f1258", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors of dtype float\n", + "X = torch.tensor(X, dtype=torch.float)\n", + "y = torch.tensor(y, dtype=torch.float)\n", + "\n", + "# Split the data into train and test sets (80% train, 20% test)\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X,\n", + " y,\n", + " test_size=0.2,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "len(X_train), len(X_test), len(y_train), len(y_test)" + ], + "metadata": { + "id": "bDhyHn9fR4dq", + "outputId": "2cc583f5-256f-496d-dd99-eac628c03505", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(800, 200, 800, 200)" + ] + }, + "metadata": {}, + "execution_count": 19 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Build a model by subclassing `nn.Module` that incorporates non-linear activation functions and is capable of fitting the data you created in 1.\n", + " * Feel free to use any combination of PyTorch layers (linear and non-linear) you want." + ], + "metadata": { + "id": "cMIjxZdzQfPz" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from torch import nn\n", + "\n", + "# Inherit from nn.Module to make a model capable of fitting the mooon data\n", + "class MoonModelV0(nn.Module):\n", + " ## Your code here ##\n", + " def __init__(self, in_features, out_features, hidden_units):\n", + " super().__init__()\n", + "\n", + " self.layer1 = nn.Linear(in_features=in_features,\n", + " out_features=hidden_units)\n", + " self.layer2 = nn.Linear(in_features=hidden_units,\n", + " out_features=hidden_units)\n", + " self.layer3 = nn.Linear(in_features=hidden_units,\n", + " out_features=out_features)\n", + " self.relu = nn.ReLU()\n", + "\n", + " def forward(self, x):\n", + " ## Your code here ##\n", + " return self.layer3(self.relu(self.layer2(self.relu(self.layer1(x)))))\n", + "# Instantiate the model\n", + "model_0 = MoonModelV0(in_features=2,\n", + " out_features=1,\n", + " hidden_units=10).to(device)\n", + " ## Your code here ##\n", + "model_0\n", + "model_0.state_dict()\n" + ], + "metadata": { + "id": "hwtyvm34Ri6Q", + "outputId": "a2d24946-d8b6-4155-cbbc-811e15d64bc4", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "OrderedDict([('layer1.weight',\n", + " tensor([[ 0.5406, 0.5869],\n", + " [-0.1657, 0.6496],\n", + " [-0.1549, 0.1427],\n", + " [-0.3443, 0.4153],\n", + " [ 0.6233, -0.5188],\n", + " [ 0.6146, 0.1323],\n", + " [ 0.5224, 0.0958],\n", + " [ 0.3410, -0.0998],\n", + " [ 0.5451, 0.1045],\n", + " [-0.3301, 0.1802]], device='cuda:0')),\n", + " ('layer1.bias',\n", + " tensor([-0.3258, -0.0829, -0.2872, 0.4691, -0.5582, -0.3260, -0.1997, -0.4252,\n", + " 0.0667, -0.6984], device='cuda:0')),\n", + " ('layer2.weight',\n", + " tensor([[ 0.2856, -0.2686, 0.2441, 0.0526, -0.1027, 0.1954, 0.0493, 0.2555,\n", + " 0.0346, -0.0997],\n", + " [ 0.0850, -0.0858, 0.1331, 0.2823, 0.1828, -0.1382, 0.1825, 0.0566,\n", + " 0.1606, -0.1927],\n", + " [-0.3130, -0.1222, -0.2426, 0.2595, 0.0911, 0.1310, 0.1000, -0.0055,\n", + " 0.2475, -0.2247],\n", + " [ 0.0199, -0.2158, 0.0975, -0.1089, 0.0969, -0.0659, 0.2623, -0.1874,\n", + " -0.1886, -0.1886],\n", + " [ 0.2844, 0.1054, 0.3043, -0.2610, -0.3137, -0.2474, -0.2127, 0.1281,\n", + " 0.1132, 0.2628],\n", + " [-0.1633, -0.2156, 0.1678, -0.1278, 0.1919, -0.0750, 0.1809, -0.2457,\n", + " -0.1596, 0.0964],\n", + " [ 0.0669, -0.0806, 0.1885, 0.2150, -0.2293, -0.1688, 0.2896, -0.1067,\n", + " -0.1121, -0.3060],\n", + " [-0.1811, 0.0790, -0.0417, -0.2295, 0.0074, -0.2160, -0.2683, -0.1741,\n", + " -0.2768, -0.2014],\n", + " [ 0.3161, 0.0597, 0.0974, -0.2949, -0.2077, -0.1053, 0.0494, -0.2783,\n", + " -0.1363, -0.1893],\n", + " [ 0.0009, -0.1177, -0.0219, -0.2143, -0.2171, -0.1845, -0.1082, -0.2496,\n", + " 0.2651, -0.0628]], device='cuda:0')),\n", + " ('layer2.bias',\n", + " tensor([ 0.2721, 0.0985, -0.2678, 0.2188, -0.0870, -0.1212, -0.2625, -0.3144,\n", + " 0.0905, -0.0691], device='cuda:0')),\n", + " ('layer3.weight',\n", + " tensor([[ 0.1231, -0.2595, 0.2348, -0.2321, -0.0546, 0.0661, 0.1633, 0.2553,\n", + " 0.2881, -0.2507]], device='cuda:0')),\n", + " ('layer3.bias', tensor([0.0796], device='cuda:0'))])" + ] + }, + "metadata": {}, + "execution_count": 20 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Setup a binary classification compatible loss function and optimizer to use when training the model built in 2." + ], + "metadata": { + "id": "DSj97RwyVeFE" + } + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function\n", + "loss_fn = nn.BCEWithLogitsLoss()\n", + "# Setup optimizer to optimize model's parameters\n", + "optimizer = torch.optim.SGD(params=model_0.parameters(), # parameters of model to optimize\n", + " lr=0.1) # learning rate" + ], + "metadata": { + "id": "whSGw5qgVvxU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Create a training and testing loop to fit the model you created in 2 to the data you created in 1.\n", + " * Do a forward pass of the model to see what's coming out in the form of logits, prediction probabilities and labels.\n", + " * To measure model accuray, you can create your own accuracy function or use the accuracy function in [TorchMetrics](https://torchmetrics.readthedocs.io/en/latest/).\n", + " * Train the model for long enough for it to reach over 96% accuracy.\n", + " * The training loop should output progress every 10 epochs of the model's training and test set loss and accuracy." + ], + "metadata": { + "id": "nvk4PfNTWUAt" + } + }, + { + "cell_type": "code", + "source": [ + "# What's coming out of our model?\n", + "\n", + "# logits (raw outputs of model)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "print(model_0(X_train.to(device)[:10]).squeeze())\n", + "# Prediction probabilities\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "print(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze()))\n", + "\n", + "# Prediction labels\n", + "print(\"Pred labels:\")\n", + "## Your code here ##\n", + "print(torch.round(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze())))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AgnFdlamd2-D", + "outputId": "0c3d73e1-d651-40cb-8326-05cd8a7a8016" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Logits:\n", + "tensor([0.0019, 0.0094, 0.0161, 0.0185, 0.0284, 0.0192, 0.0291, 0.0196, 0.0258,\n", + " 0.0079], device='cuda:0', grad_fn=)\n", + "Pred probs:\n", + "tensor([0.5005, 0.5024, 0.5040, 0.5046, 0.5071, 0.5048, 0.5073, 0.5049, 0.5065,\n", + " 0.5020], device='cuda:0', grad_fn=)\n", + "Pred labels:\n", + "tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], device='cuda:0',\n", + " grad_fn=)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy using accuracy from TorchMetrics\n", + "!pip -q install torchmetrics # Colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "## TODO: Uncomment this code to use the Accuracy function\n", + "acc_fn = Accuracy(task=\"multiclass\", num_classes=2).to(device) # send accuracy function to device\n", + "acc_fn" + ], + "metadata": { + "id": "rUSDNHB4euoJ", + "outputId": "495d36fd-5689-4655-cee2-2e56a0134582", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MulticlassAccuracy()" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "fGmP1hSLn-DR" + } + }, + { + "cell_type": "code", + "source": [ + "##TODO: Uncomment this to set the seed\n", + "torch.manual_seed(RANDOM_SEED)\n", + "\n", + "# Setup epochs\n", + "epochs=1000\n", + "\n", + "# Send data to the device\n", + "X_train, y_train = X_train.to(device), y_train.to(device)\n", + "X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + "# Loop through the data\n", + "for epoch in range(epochs):\n", + " ### Training\n", + " model_0.train()\n", + "\n", + " # 1. Forward pass (logits output)\n", + "y_logits = model_0(X_train).squeeze()\n", + " # Turn logits into prediction probabilities\n", + "y_pred_probs = torch.sigmoid(y_logits)\n", + "\n", + " # Turn prediction probabilities into prediction labels\n", + "y_pred = torch.round(y_pred_probs)\n", + "\n", + " # 2. Calculaute the loss\n", + "loss = loss_fn(y_logits, y_train) # loss = compare model raw outputs to desired model outputs\n", + " # Calculate the accuracy\n", + "acc = acc_fn(y_pred, y_train.int()) # the accuracy function needs to compare pred labels (not logits) with actual labels\n", + "\n", + " # 3. Zero the gradients\n", + "optimizer.zero_grad()\n", + "\n", + " # 4. Loss backward (perform backpropagation) - https://brilliant.org/wiki/backpropagation/#:~:text=Backpropagation%2C%20short%20for%20%22backward%20propagation,to%20the%20neural%20network's%20weights.\n", + "loss.backward()\n", + " # 5. Step the optimizer (gradient descent) - https://towardsdatascience.com/gradient-descent-algorithm-a-deep-dive-cf04e8115f21#:~:text=Gradient%20descent%20(GD)%20is%20an,e.g.%20in%20a%20linear%20regression)\n", + "optimizer.step()\n", + "\n", + " ### Testing\n", + "model_0.eval()\n", + "with torch.inference_mode():\n", + " # 1. Forward pass (to get the logits)\n", + " test_logits = model_0(X_test).squeeze()\n", + "\n", + " # Turn the test logits into prediction labels\n", + " test_pred = torch.round(torch.sigmoid(test_logits))\n", + "\n", + " # 2. Caculate the test loss/acc\n", + " test_loss = loss_fn(test_logits, y_test)\n", + " test_acc = acc_fn(test_pred, y_test.int())\n", + "\n", + "\n", + " # Print out what's happening every 100 epochs\n", + "if epoch % 100 == 0:\n", + " print(f\"Epoch: {epoch} | Loss: {loss:.2f} Acc: {acc:.2f} | Test loss: {test_loss:.2f} Test acc: {test_acc:.2f}\")\n", + "\n" + ], + "metadata": { + "id": "SHBY3h7XXnxt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Make predictions with your trained model and plot them using the `plot_decision_boundary()` function created in this notebook." + ], + "metadata": { + "id": "8Nwihtomj9JO" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot the model predictions\n", + "import numpy as np\n", + "\n", + "def plot_decision_boundary(model, X, y):\n", + "\n", + " # Put everything to CPU (works better with NumPy + Matplotlib)\n", + " model.to(\"cpu\")\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Source - https://madewithml.com/courses/foundations/neural-networks/\n", + " # (with modifications)\n", + " x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n", + " y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n", + " xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101),\n", + " np.linspace(y_min, y_max, 101))\n", + "\n", + " # Make features\n", + " X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n", + "\n", + " # Make predictions\n", + " model.eval()\n", + " with torch.inference_mode():\n", + " y_logits = model(X_to_pred_on)\n", + "\n", + " # Test for multi-class or binary and adjust logits to prediction labels\n", + " if len(torch.unique(y)) > 2:\n", + " y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\n", + " else:\n", + " y_pred = torch.round(torch.sigmoid(y_logits)) # binary\n", + "\n", + " # Reshape preds and plot\n", + " y_pred = y_pred.reshape(xx.shape).detach().numpy()\n", + " plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n", + " plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + " plt.xlim(xx.min(), xx.max())\n", + " plt.ylim(yy.min(), yy.max())" + ], + "metadata": { + "id": "0YRzatb8a1P2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n", + "plt.figure(figsize=(12, 6))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title(\"Train\")\n", + "plot_decision_boundary(model_0, X_train, y_train)\n", + "plt.subplot(1, 2, 2)\n", + "plt.title(\"Test\")\n", + "plot_decision_boundary(model_0, X_test, y_test)" + ], + "metadata": { + "id": "PMrcpyirig1d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 545 + }, + "outputId": "05cd1077-06d2-44db-8182-bbd7d3ac3709" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Replicate the Tanh (hyperbolic tangent) activation function in pure PyTorch.\n", + " * Feel free to reference the [ML cheatsheet website](https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh) for the formula." + ], + "metadata": { + "id": "EtMYBvtciiAU" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a straight line tensor\n", + "tensor_A = torch.arange(-100, 100, 1)\n", + "plt.plot(tensor_A)" + ], + "metadata": { + "id": "BlXaWC5TkEUE", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "outputId": "b1e7995a-ef43-4a54-86dc-32aee0015e9f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 28 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Test torch.tanh() on the tensor and plot it\n", + "plt.plot(torch.tanh(tensor_A))" + ], + "metadata": { + "id": "vZPCcQmIkZjO", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "outputId": "e8cb1d13-aff4-4280-cd23-0def0c62bb05" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 29 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Replicate torch.tanh() and plot it\n", + "def tanh(x):\n", + " # Source - https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh\n", + " return (torch.exp(x) - torch.exp(-x)) / (torch.exp(x) + torch.exp(-x))\n", + "\n", + "plt.plot(tanh(tensor_A))" + ], + "metadata": { + "id": "J-ne__Kjkdc1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "outputId": "787ae729-f1c8-4887-b04c-49d8ce1ec718" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 30 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAGdCAYAAAAfTAk2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAANidJREFUeJzt3X98VNWB///35NeEIEmIQCaRyE8XZOVXQWKsrVryIFG+LbRsC5ZuhMWwImgxqJh+BBTUqLjUxbJSrQh+xWrtqq22G41BsNUYNJhaLeYjLgJKJighGRIkmcnczx8w14yEAMqQzLmv5+MxD8mdM3fOcebevHPuuee4LMuyBAAAYJCYrq4AAADA6UbAAQAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAYJ66rK9AVgsGg9u7dq169esnlcnV1dQAAwEmwLEsHDx5UZmamYmI676NxZMDZu3evsrKyuroaAADga9izZ4/69+/faRlHBpxevXpJOvI/KDk5uYtrAwAATobP51NWVpb9e7wzjgw4octSycnJBBwAAKLMyQwvYZAxAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4BBwAAGAcAg4AADBORAPOa6+9pu9///vKzMyUy+XS888/f8LXbN68Wd/61rfkdrs1dOhQrV+//pgya9as0cCBA5WYmKjs7Gxt3br19FceAABErYgGnObmZo0ePVpr1qw5qfI7d+7U5MmTdfnll6u6uloLFy7UNddco5deesku8/TTT6uoqEjLli3Ttm3bNHr0aOXl5Wnfvn2RagYAAIgyLsuyrDPyRi6XnnvuOU2dOvW4ZRYvXqw//elPeu+99+xtM2bMUENDg0pLSyVJ2dnZuvDCC/WrX/1KkhQMBpWVlaXrr79et95660nVxefzKSUlRY2NjaxFBQBAlDiV39/darHNiooK5ebmhm3Ly8vTwoULJUmtra2qqqpScXGx/XxMTIxyc3NVUVFx3P22tLSopaXF/tnn853eigOIKi2BNlV9fEDv7/WptS2o1kBQ/ragAkFL/rZgV1cPMMK4Ab31/43K7LL371YBx+v1Kj09PWxbenq6fD6fvvjiCx04cEBtbW0dlvnggw+Ou9+SkhLdcccdEakzgOjxRWub/s/zf1fpe14dam3r6uoARmsJBAk4kVZcXKyioiL7Z5/Pp6ysrC6sEYCusO71nXp226eSpD5nuZU9OE293HGKi3UpLiZGCXExio1xKcbVxRUFDDC6f2qXvn+3Cjgej0d1dXVh2+rq6pScnKwePXooNjZWsbGxHZbxeDzH3a/b7Zbb7Y5InQFEh+aWgH7zl/+VJN059QL9dMK5iiHJAMbqVvPg5OTkqLy8PGxbWVmZcnJyJEkJCQkaN25cWJlgMKjy8nK7DAB05Ik3d+nAIb8Gnp2kGRdmEW4Aw0U04DQ1Nam6ulrV1dWSjtwGXl1drd27d0s6cumooKDALn/ttdfqf//3f3XLLbfogw8+0H/913/pd7/7nW688Ua7TFFRkR555BFt2LBB27dv17x589Tc3KzZs2dHsikAotgXrW16+LUjvTfzLx+quNhu9bcdgAiI6CWqt99+W5dffrn9c2gczNVXX63169ertrbWDjuSNGjQIP3pT3/SjTfeqP/8z/9U//799Zvf/EZ5eXl2menTp+uzzz7T0qVL5fV6NWbMGJWWlh4z8BgAQjZW7tL+5lZlpfXQ1LHndHV1AJwBZ2wenO6EeXAAZ5m8+i96f69Pd/3wAs3MHtDV1QHwNZ3K72/6aQEY77ODR+bB6uq7OgCcOQQcAEazLEsHDrVKknr3TOji2gA4Uwg4AIzW3Nomf9uRK/G9k+K7uDYAzhQCDgCjHWg+0nvjjotRj/jYLq4NgDOFgAPAaA2H/JKk3kkJcrmY+wZwCgIOAKPVHx1/k8rlKcBRCDgAjNYQGmCcxABjwEkIOACMFhqDk8YdVICjEHAAGK3+6BgcLlEBzkLAAWA0LlEBzkTAAWC0A6G7qLhEBTgKAQeA0UJjcJjkD3AWAg4Aox3gEhXgSAQcAEZr4BIV4EgEHABGq+cSFeBIBBwAxjrsb9MX/jZJUiqXqABHIeAAMFbo8lRsjEvJiXFdXBsAZxIBB4CxvhxgHM9Cm4DDEHAAGCt0iziXpwDnIeAAMJY9yR8DjAHHIeAAMBZz4ADORcABYKwvZzEm4ABOQ8ABYKzQJarUnlyiApyGgAPAWKGVxNPowQEch4ADwFj1jMEBHIuAA8BY9iUq7qICHIeAA8BY9iUqFtoEHIeAA8BYTPQHOBcBB4CRAm1B+Q4HJDHRH+BEBBwARmr4wm//O6UHAQdwGgIOACOFxt+k9IhXXCynOsBpzshRv2bNGg0cOFCJiYnKzs7W1q1bj1v2sssuk8vlOuYxefJku8ysWbOOeT4/P/9MNAVAlKhvZh0qwMniIv0GTz/9tIqKirR27VplZ2frgQceUF5enmpqatSvX79jyj/77LNqbW21f96/f79Gjx6tH//4x2Hl8vPz9dhjj9k/u93uyDUCQNQJrUPFAGPAmSLeg7Nq1SoVFhZq9uzZGjFihNauXaukpCStW7euw/JpaWnyeDz2o6ysTElJSccEHLfbHVaud+/ekW4KgCjS+AVz4ABOFtGA09raqqqqKuXm5n75hjExys3NVUVFxUnt49FHH9WMGTPUs2fPsO2bN29Wv379NGzYMM2bN0/79+8/7j5aWlrk8/nCHgDM1hoISpLccYy/AZwookf+559/rra2NqWnp4dtT09Pl9frPeHrt27dqvfee0/XXHNN2Pb8/Hw9/vjjKi8v17333qstW7boiiuuUFtbW4f7KSkpUUpKiv3Iysr6+o0CEBUCbUcCDgOMAWeK+Bicb+LRRx/VyJEjNWHChLDtM2bMsP89cuRIjRo1SkOGDNHmzZs1ceLEY/ZTXFysoqIi+2efz0fIAQwXCFqSpPgYVxfXBEBXiOifNn369FFsbKzq6urCttfV1cnj8XT62ubmZj311FOaM2fOCd9n8ODB6tOnj3bs2NHh8263W8nJyWEPAGZrpQcHcLSIHvkJCQkaN26cysvL7W3BYFDl5eXKycnp9LXPPPOMWlpa9LOf/eyE7/PJJ59o//79ysjI+MZ1BmCGQNvRHpxYenAAJ4r4nzZFRUV65JFHtGHDBm3fvl3z5s1Tc3OzZs+eLUkqKChQcXHxMa979NFHNXXqVJ199tlh25uamnTzzTfrzTff1Mcff6zy8nJNmTJFQ4cOVV5eXqSbAyBK2GNwYujBAZwo4mNwpk+frs8++0xLly6V1+vVmDFjVFpaag883r17t2K+cgKqqanRX//6V7388svH7C82NlbvvvuuNmzYoIaGBmVmZmrSpElasWIFc+EAsPlDY3C4RAU40hkZZLxgwQItWLCgw+c2b958zLZhw4bJsqwOy/fo0UMvvfTS6aweAAOFenC4RAU4E3/aADCS/+gYnDgCDuBIBBwARgoEGYMDOBlHPgAjcRcV4GwEHABGYh4cwNk48gEYKdSDE8dMxoAjEXAAGCk0BofbxAFn4sgHYCR/G/PgAE7GkQ/ASF+uJs4lKsCJCDgAjGSvJk7AARyJgAPASH7WogIcjSMfgJGYBwdwNgIOACPRgwM4G0c+ACOxFhXgbAQcAEZiHhzA2TjyARgpwDw4gKNx5AMwkj/IPDiAkxFwABjJ7sFhkDHgSBz5AIzEIGPA2Qg4AIz05SBjAg7gRAQcAEYKXaJiHhzAmTjyARiplcU2AUcj4AAwUmg1cW4TB5yJIx+AcYJBS0cXEyfgAA7FkQ/AOKE5cCQuUQFORcABYJzQAGOJeXAAp+LIB2Cc9gGHHhzAmQg4AIwTdokqhoADOBEBB4BxvpwDxyWXi4ADOBEBB4Bx/MyBAzgeAQeAcUIBhwHGgHNx9AMwTuDoJDjxcZziAKc6I0f/mjVrNHDgQCUmJio7O1tbt249btn169fL5XKFPRITE8PKWJalpUuXKiMjQz169FBubq4+/PDDSDcDQJSwL1ExwBhwrIgHnKefflpFRUVatmyZtm3bptGjRysvL0/79u077muSk5NVW1trP3bt2hX2/H333afVq1dr7dq1qqysVM+ePZWXl6fDhw9HujkAokBokDGzGAPOFfGjf9WqVSosLNTs2bM1YsQIrV27VklJSVq3bt1xX+NyueTxeOxHenq6/ZxlWXrggQd02223acqUKRo1apQef/xx7d27V88//3ykmwMgCgSCDDIGnC6iAae1tVVVVVXKzc398g1jYpSbm6uKiorjvq6pqUkDBgxQVlaWpkyZovfff99+bufOnfJ6vWH7TElJUXZ29nH32dLSIp/PF/YAYC5/u9vEAThTRAPO559/rra2trAeGElKT0+X1+vt8DXDhg3TunXr9Ic//EFPPPGEgsGgLr74Yn3yySeSZL/uVPZZUlKilJQU+5GVlfVNmwagG+MSFYBud/Tn5OSooKBAY8aM0aWXXqpnn31Wffv21a9//euvvc/i4mI1Njbajz179pzGGgPobpgHB0BEA06fPn0UGxururq6sO11dXXyeDwntY/4+HiNHTtWO3bskCT7daeyT7fbreTk5LAHAHPZ8+DQgwM4VkSP/oSEBI0bN07l5eX2tmAwqPLycuXk5JzUPtra2vT3v/9dGRkZkqRBgwbJ4/GE7dPn86mysvKk9wnAbPY8OEz0BzhWXKTfoKioSFdffbXGjx+vCRMm6IEHHlBzc7Nmz54tSSooKNA555yjkpISSdLy5ct10UUXaejQoWpoaNDKlSu1a9cuXXPNNZKO3GG1cOFC3XnnnTrvvPM0aNAgLVmyRJmZmZo6dWqkmwMgCnCJCkDEA8706dP12WefaenSpfJ6vRozZoxKS0vtQcK7d+9WTLu/sg4cOKDCwkJ5vV717t1b48aN0xtvvKERI0bYZW655RY1Nzdr7ty5amho0CWXXKLS0tJjJgQE4Ez2YptcogIcy2VZltXVlTjTfD6fUlJS1NjYyHgcwEBPv7Vbi//775o4vJ8enXVhV1cHwGlyKr+/+fMGgHHseXC4RAU4FgEHgHEC9hgcTnGAU3H0AzBOqAcnnpmMAcci4AAwjj/IPDiA03H0AzAOd1EB4OgHYJyAPZMxl6gApyLgADCOPxhaTZxTHOBUHP0AjEMPDgACDgDjMA8OAAIOAOMEjt5FxSUqwLk4+gEYxx84Og8OPTiAYxFwABiHeXAAcPQDMA7z4ADg6AdgnECQu6gApyPgADCOfRcVg4wBx+LoB2CcL1cTpwcHcCoCDgDjBILcRQU4HQEHgHH8bcyDAzgdRz8A44TG4NCDAzgXAQeAcb5ci4pTHOBUHP0AjONnHhzA8Tj6ARjHngcnhktUgFMRcAAYh5mMAXD0AzBOaC0q5sEBnIuAA8A4oR6ceG4TBxyLox+Acb4cZEwPDuBUBBwAxvG3sdgm4HQEHADGYR4cABz9AIzjD3IXFeB0HP0AjGP34DAPDuBYBBwARgkGLR3twKEHB3CwM3L0r1mzRgMHDlRiYqKys7O1devW45Z95JFH9J3vfEe9e/dW7969lZube0z5WbNmyeVyhT3y8/Mj3QwAUSA0B47EXVSAk0U84Dz99NMqKirSsmXLtG3bNo0ePVp5eXnat29fh+U3b96sq666Sq+++qoqKiqUlZWlSZMm6dNPPw0rl5+fr9raWvvx29/+NtJNARAFQnPgSMyDAzhZxI/+VatWqbCwULNnz9aIESO0du1aJSUlad26dR2W37hxo6677jqNGTNGw4cP129+8xsFg0GVl5eHlXO73fJ4PPajd+/ekW4KgCjQPuDQgwM4V0QDTmtrq6qqqpSbm/vlG8bEKDc3VxUVFSe1j0OHDsnv9ystLS1s++bNm9WvXz8NGzZM8+bN0/79+4+7j5aWFvl8vrAHADO1trW7RMUgY8CxIhpwPv/8c7W1tSk9PT1se3p6urxe70ntY/HixcrMzAwLSfn5+Xr88cdVXl6ue++9V1u2bNEVV1yhtra2DvdRUlKilJQU+5GVlfX1GwWgW7NXEo89Mj4PgDPFdXUFOnPPPffoqaee0ubNm5WYmGhvnzFjhv3vkSNHatSoURoyZIg2b96siRMnHrOf4uJiFRUV2T/7fD5CDmAoeyVxxt8AjhbRM0CfPn0UGxururq6sO11dXXyeDydvvb+++/XPffco5dfflmjRo3qtOzgwYPVp08f7dixo8Pn3W63kpOTwx4AzBRapoHxN4CzRTTgJCQkaNy4cWEDhEMDhnNyco77uvvuu08rVqxQaWmpxo8ff8L3+eSTT7R//35lZGSclnoDiF6Bo5PgsEwD4GwRPwMUFRXpkUce0YYNG7R9+3bNmzdPzc3Nmj17tiSpoKBAxcXFdvl7771XS5Ys0bp16zRw4EB5vV55vV41NTVJkpqamnTzzTfrzTff1Mcff6zy8nJNmTJFQ4cOVV5eXqSbA6Cbs3twGGAMOFrEx+BMnz5dn332mZYuXSqv16sxY8aotLTUHni8e/duxbS7Vv7QQw+ptbVV//Iv/xK2n2XLlun2229XbGys3n33XW3YsEENDQ3KzMzUpEmTtGLFCrnd7kg3B0A3FxqDQw8O4Gwuy7KsExczi8/nU0pKihobGxmPAximale9pj1UoQFnJ2nLzZd3dXUAnEan8vubP3EAGMVv30XFJSrAyQg4AIwSGoPDJSrA2TgDADAKY3AASAQcAIZhHhwAEgEHgGHseXCYyRhwNM4AAIxCDw4AiYADwDD2WlSMwQEcjTMAAKPYq4lzmzjgaAQcAEax58HhEhXgaAQcAEZhHhwAEgEHgGGYBweARMABYBh/kNXEARBwABiGu6gASAQcAIYJ2GNw6MEBnIyAA8Ao/mBoNXFOb4CTcQYAYBR6cABIBBwAhvFzFxUAEXAAGIa1qABIBBwAhmEeHAASAQeAYZgHB4BEwAFgGObBASARcAAYxl5NnDE4gKMRcAAYxV5NnHlwAEfjDADAKAHuogIgAg4AwwSOzmScwBgcwNE4AwAwSmuAHhwABBwAhgmwFhUAEXAAGIa1qABIBBwAhvEzDw4AEXAAGMaeB4eZjAFHI+AAMAozGQOQzlDAWbNmjQYOHKjExERlZ2dr69atnZZ/5plnNHz4cCUmJmrkyJH685//HPa8ZVlaunSpMjIy1KNHD+Xm5urDDz+MZBMARAl7LSrG4ACOFvGA8/TTT6uoqEjLli3Ttm3bNHr0aOXl5Wnfvn0dln/jjTd01VVXac6cOXrnnXc0depUTZ06Ve+9955d5r777tPq1au1du1aVVZWqmfPnsrLy9Phw4cj3RwA3VyoB4d5cABnc1mWZUXyDbKzs3XhhRfqV7/6lSQpGAwqKytL119/vW699dZjyk+fPl3Nzc168cUX7W0XXXSRxowZo7Vr18qyLGVmZmrRokW66aabJEmNjY1KT0/X+vXrNWPGjBPWyefzKSUlRY2NjUpOTj5NLQXQHYy/s0yfN7WqdOF3NNzD8Q2Y5FR+f0f0T5zW1lZVVVUpNzf3yzeMiVFubq4qKio6fE1FRUVYeUnKy8uzy+/cuVNerzesTEpKirKzs4+7z5aWFvl8vrAHADOxFhUAKcIB5/PPP1dbW5vS09PDtqenp8vr9Xb4Gq/X22n50H9PZZ8lJSVKSUmxH1lZWV+rPQC6P+bBASA55C6q4uJiNTY22o89e/Z0dZUARIg/yF1UACIccPr06aPY2FjV1dWFba+rq5PH4+nwNR6Pp9Pyof+eyj7dbreSk5PDHgDMZPfgMA8O4GgRDTgJCQkaN26cysvL7W3BYFDl5eXKycnp8DU5OTlh5SWprKzMLj9o0CB5PJ6wMj6fT5WVlcfdJwBnCAYtHe3AoQcHcLi4SL9BUVGRrr76ao0fP14TJkzQAw88oObmZs2ePVuSVFBQoHPOOUclJSWSpJ///Oe69NJL9R//8R+aPHmynnrqKb399tt6+OGHJUkul0sLFy7UnXfeqfPOO0+DBg3SkiVLlJmZqalTp0a6OQC6sdAcOBLz4ABOF/GAM336dH322WdaunSpvF6vxowZo9LSUnuQ8O7duxXT7m6Hiy++WE8++aRuu+02/eIXv9B5552n559/XhdccIFd5pZbblFzc7Pmzp2rhoYGXXLJJSotLVViYmKkmwOgGwvNgSMxDw7gdBGfB6c7Yh4cwEwNh1o1ZnmZJGnHXVdwmQowTLeZBwcAziR/ux6cWAYZA45GwAFgDHsl8ViXXC4CDuBkBBwAxggwizGAozgLADCGv42VxAEcQcABYIzA0Ulw4hlcDDgeZwEAxrB7cBhgDDgeAQeAMUJjcOjBAcBZAIAx/KwkDuAoAg4AY4TmwWGCPwCcBQAYIzQPDmNwABBwABiDMTgAQjgLADAG8+AACCHgADCGPQ8OMxkDjsdZAIAx6MEBEELAAWAMxuAACOEsAMAYzIMDIISAA8AY/iCriQM4grMAAGMEGIMD4CgCDgBjMAYHQAhnAQDG8DOTMYCjCDgAjBFgLSoAR3EWAGCMAHdRATiKgAPAGKG7qBiDA4CzAABj+APcRQXgCAIOAGOwFhWAEM4CAIzBWlQAQgg4AIzBPDgAQjgLADAG8+AACCHgADAG8+AACOEsAMAYgSDz4AA4goADwBh+xuAAOCqiZ4H6+nrNnDlTycnJSk1N1Zw5c9TU1NRp+euvv17Dhg1Tjx49dO655+qGG25QY2NjWDmXy3XM46mnnopkUwBEAXs1ccbgAI4XF8mdz5w5U7W1tSorK5Pf79fs2bM1d+5cPfnkkx2W37t3r/bu3av7779fI0aM0K5du3Tttddq7969+v3vfx9W9rHHHlN+fr79c2pqaiSbAiAK0IMDICRiAWf79u0qLS3VW2+9pfHjx0uSHnzwQV155ZW6//77lZmZecxrLrjgAv33f/+3/fOQIUN011136Wc/+5kCgYDi4r6sbmpqqjweT6SqDyAKMQ8OgJCI/ZlTUVGh1NRUO9xIUm5urmJiYlRZWXnS+2lsbFRycnJYuJGk+fPnq0+fPpowYYLWrVsny7KOu4+Wlhb5fL6wBwDzhGYyjmMmY8DxItaD4/V61a9fv/A3i4tTWlqavF7vSe3j888/14oVKzR37tyw7cuXL9f3vvc9JSUl6eWXX9Z1112npqYm3XDDDR3up6SkRHfcccfXawiAqMFq4gBCTvnPnFtvvbXDQb7tHx988ME3rpjP59PkyZM1YsQI3X777WHPLVmyRN/+9rc1duxYLV68WLfccotWrlx53H0VFxersbHRfuzZs+cb1w9A9+NnHhwAR51yD86iRYs0a9asTssMHjxYHo9H+/btC9seCARUX19/wrEzBw8eVH5+vnr16qXnnntO8fHxnZbPzs7WihUr1NLSIrfbfczzbre7w+0AzMI8OABCTjng9O3bV3379j1huZycHDU0NKiqqkrjxo2TJG3atEnBYFDZ2dnHfZ3P51NeXp7cbrf++Mc/KjEx8YTvVV1drd69exNiAIdjLSoAIREbg3P++ecrPz9fhYWFWrt2rfx+vxYsWKAZM2bYd1B9+umnmjhxoh5//HFNmDBBPp9PkyZN0qFDh/TEE0+EDQju27evYmNj9cILL6iurk4XXXSREhMTVVZWprvvvls33XRTpJoCIEqwFhWAkIjOg7Nx40YtWLBAEydOVExMjKZNm6bVq1fbz/v9ftXU1OjQoUOSpG3bttl3WA0dOjRsXzt37tTAgQMVHx+vNWvW6MYbb5RlWRo6dKhWrVqlwsLCSDYFQBTwB+jBAXCEy+rs/mpD+Xw+paSk2LegAzDD+DvL9HlTq0oXfkfDPRzbgGlO5fc3f+YAMIZ9FxXz4ACOx1kAgDGYBwdACAEHgDH8QebBAXAEZwEAxqAHB0AIAQeAEYJBS0c7cBTPGBzA8TgLADBCaA4cidXEARBwABgidAeVxDw4AAg4AAwRGn8jMZMxAAIOAEO078GJJeAAjkfAAWCE9iuJu1wEHMDpCDgAjBBgFmMA7XAmAGAEP3PgAGiHgAPACIEgK4kD+BJnAgBGCPXgMAcOAImAA8AQrCQOoD3OBACMwDpUANoj4AAwgt2DwxgcACLgADBEaB4cZjEGIBFwABgiNA8Od1EBkAg4AAzBPDgA2iPgADBCaB4cxuAAkAg4AAxBDw6A9gg4AIzAPDgA2uNMAMAIzIMDoD0CDgAj+IP04AD4EmcCAEYIsBYVgHYIOACMwDw4ANrjTADACP4gY3AAfImAA8AIAdaiAtAOZwIARrDvomItKgAi4AAwRCs9OADaieiZoL6+XjNnzlRycrJSU1M1Z84cNTU1dfqayy67TC6XK+xx7bXXhpXZvXu3Jk+erKSkJPXr108333yzAoFAJJsCoJvjLioA7cVFcuczZ85UbW2tysrK5Pf7NXv2bM2dO1dPPvlkp68rLCzU8uXL7Z+TkpLsf7e1tWny5MnyeDx64403VFtbq4KCAsXHx+vuu++OWFsAdG+htajimQcHgCIYcLZv367S0lK99dZbGj9+vCTpwQcf1JVXXqn7779fmZmZx31tUlKSPB5Ph8+9/PLL+sc//qFXXnlF6enpGjNmjFasWKHFixfr9ttvV0JCQkTaA6B789ODA6CdiP2pU1FRodTUVDvcSFJubq5iYmJUWVnZ6Ws3btyoPn366IILLlBxcbEOHToUtt+RI0cqPT3d3paXlyefz6f333+/w/21tLTI5/OFPQCYhXlwALQXsR4cr9erfv36hb9ZXJzS0tLk9XqP+7qf/vSnGjBggDIzM/Xuu+9q8eLFqqmp0bPPPmvvt324kWT/fLz9lpSU6I477vgmzQHQzTEPDoD2Tjng3Hrrrbr33ns7LbN9+/avXaG5c+fa/x45cqQyMjI0ceJEffTRRxoyZMjX2mdxcbGKiorsn30+n7Kysr52HQF0PwFWEwfQzikHnEWLFmnWrFmdlhk8eLA8Ho/27dsXtj0QCKi+vv6442s6kp2dLUnasWOHhgwZIo/Ho61bt4aVqaurk6Tj7tftdsvtdp/0ewKIPgF6cAC0c8oBp2/fvurbt+8Jy+Xk5KihoUFVVVUaN26cJGnTpk0KBoN2aDkZ1dXVkqSMjAx7v3fddZf27dtnXwIrKytTcnKyRowYcYqtAWCK1gDz4AD4UsTOBOeff77y8/NVWFiorVu36vXXX9eCBQs0Y8YM+w6qTz/9VMOHD7d7ZD766COtWLFCVVVV+vjjj/XHP/5RBQUF+u53v6tRo0ZJkiZNmqQRI0boX//1X/W3v/1NL730km677TbNnz+fXhrAwUI9OHHMZAxAEZ7ob+PGjRo+fLgmTpyoK6+8Updccokefvhh+3m/36+amhr7LqmEhAS98sormjRpkoYPH65FixZp2rRpeuGFF+zXxMbG6sUXX1RsbKxycnL0s5/9TAUFBWHz5gBwHu6iAtBeRCf6S0tL63RSv4EDB8qyLPvnrKwsbdmy5YT7HTBggP785z+fljoCMAPz4ABojz91ABghNJMxd1EBkAg4AAwRWosqIY4eHAAEHACG8DMPDoB2OBMAMIJ9FxVjcACIgAPAEH7uogLQDmcCAEaw76JiHhwAIuAAMATz4ABojzMBACMwBgdAewQcAEbgLioA7XEmAGAEex4cLlEBEAEHgCH8oZmMuUQFQAQcAIYIsBYVgHYIOACiXlvQ0tEOHMUzBgeACDgADBCaA0eiBwfAEQQcAFEvtJK4xDw4AI7gTAAg6gXa9+AwkzEAEXAAGCA0B47LJcUScACIgAPAAKFZjONjYuRyEXAAEHAAGCC0DhUDjAGEEHAARD1WEgfwVQQcAFEvdBcVd1ABCOFsACDqtQaYxRhAOAIOgKgX6sFhJXEAIZwNAES90Dw48fTgADiKgAMg6oXmwWEMDoAQzgYAol5oHpw4Ag6AozgbAIh6AbsHh0tUAI4g4ACIesyDA+CrCDgAop59FxWXqAAcxdkAQNTzcxcVgK8g4ACIeqG7qJgHB0BIRM8G9fX1mjlzppKTk5Wamqo5c+aoqanpuOU//vhjuVyuDh/PPPOMXa6j55966qlINgVAN8Y8OAC+Ki6SO585c6Zqa2tVVlYmv9+v2bNna+7cuXryySc7LJ+VlaXa2tqwbQ8//LBWrlypK664Imz7Y489pvz8fPvn1NTU015/ANHBz1pUAL4iYgFn+/btKi0t1VtvvaXx48dLkh588EFdeeWVuv/++5WZmXnMa2JjY+XxeMK2Pffcc/rJT36is846K2x7amrqMWUBOFOoB4dBxgBCInY2qKioUGpqqh1uJCk3N1cxMTGqrKw8qX1UVVWpurpac+bMOea5+fPnq0+fPpowYYLWrVsny7KOu5+Wlhb5fL6wBwBz2PPgcJs4gKMi1oPj9XrVr1+/8DeLi1NaWpq8Xu9J7ePRRx/V+eefr4svvjhs+/Lly/W9731PSUlJevnll3XdddepqalJN9xwQ4f7KSkp0R133PH1GgKg2/MHWU0cQLhT7sG59dZbjzsQOPT44IMPvnHFvvjiCz355JMd9t4sWbJE3/72tzV27FgtXrxYt9xyi1auXHncfRUXF6uxsdF+7Nmz5xvXD0D3EerB4RIVgJBT7sFZtGiRZs2a1WmZwYMHy+PxaN++fWHbA4GA6uvrT2rszO9//3sdOnRIBQUFJyybnZ2tFStWqKWlRW63+5jn3W53h9sBmKEl0CZJSiDgADjqlANO37591bdv3xOWy8nJUUNDg6qqqjRu3DhJ0qZNmxQMBpWdnX3C1z/66KP6wQ9+cFLvVV1drd69exNiAIc6cMgvSUpNiu/imgDoLiI2Buf8889Xfn6+CgsLtXbtWvn9fi1YsEAzZsyw76D69NNPNXHiRD3++OOaMGGC/dodO3botdde05///Odj9vvCCy+orq5OF110kRITE1VWVqa7775bN910U6SaAqCbazjUKknqnZTQxTUB0F1EdB6cjRs3asGCBZo4caJiYmI0bdo0rV692n7e7/erpqZGhw4dCnvdunXr1L9/f02aNOmYfcbHx2vNmjW68cYbZVmWhg4dqlWrVqmwsDCSTQHQjR1opgcHQDiX1dn91Yby+XxKSUlRY2OjkpOTu7o6AL6h/Ade0wfeg/r/50zQd8478WVtANHpVH5/MyIPQNQ7wCUqAF9BwAEQ1SzLYpAxgGMQcABEtS/8bWoNHJnoL60nPTgAjiDgAIhq9c1HLk8lxMWoR3xsF9cGQHdBwAEQ1RqOXp7qnRQvl4ulGgAcQcABENUYYAygIwQcAFEtdImKgAOgPQIOgKhmX6LqyR1UAL5EwAEQ1UKXqFLpwQHQDgEHQFRrP8gYAEIIOACiGmNwAHSEgAMgqnEXFYCOEHAARDUGGQPoCAEHQFTjEhWAjhBwAES1Bi5RAegAAQdA1GoJtKm5tU0SAQdAOAIOgKgVGn8T45J6JcZ1cW0AdCcEHABRq/0dVDExLLQJ4EsEHABR60DzkR6cVCb5A/AVBBwAUYsBxgCOh4ADIGrVsw4VgOMg4ACIWqFBxmlM8gfgKwg4AKLWASb5A3AcBBwAUYtLVACOh4ADIGpxiQrA8RBwAEStA/TgADgOAg6AqMUYHADHQ8ABELUOHL1E1ZuJ/gB8BQEHQFRqC1ryHT4acHrSgwMgHAEHQFSq3nNAliUlxMYotQc9OADCEXAARKXV5TskST8ce47iYjmVAQgXsbPCXXfdpYsvvlhJSUlKTU09qddYlqWlS5cqIyNDPXr0UG5urj788MOwMvX19Zo5c6aSk5OVmpqqOXPmqKmpKQItANBd/W1Pg7b8388UG+PSdZcP6erqAOiGIhZwWltb9eMf/1jz5s076dfcd999Wr16tdauXavKykr17NlTeXl5Onz4sF1m5syZev/991VWVqYXX3xRr732mubOnRuJJgDoph7cdOQPn6ljztGAs3t2cW0AdEcuy7KsSL7B+vXrtXDhQjU0NHRazrIsZWZmatGiRbrpppskSY2NjUpPT9f69es1Y8YMbd++XSNGjNBbb72l8ePHS5JKS0t15ZVX6pNPPlFmZuZJ1cnn8yklJUWNjY1KTk7+Ru0DcOZYlqW/fPi5CtZtVYxLeqXoUg3ue1ZXVwvAGXIqv7/jzlCdTmjnzp3yer3Kzc21t6WkpCg7O1sVFRWaMWOGKioqlJqaaocbScrNzVVMTIwqKyv1wx/+sMN9t7S0qKWlxf7Z5/NFpA1Vu+r1wt9qI7JvnF4RzvVdwrwWHdEWtPSFv03NLQG9s7tB+w4eOZa/PzqTcAPguLpNwPF6vZKk9PT0sO3p6en2c16vV/369Qt7Pi4uTmlpaXaZjpSUlOiOO+44zTU+Vo23Sevf+Dji7wM4WY/4WF36T3112+QRXV0VAN3YKQWcW2+9Vffee2+nZbZv367hw4d/o0qdbsXFxSoqKrJ/9vl8ysrKOu3v88+ZyVpw+dDTvt/uwOXq6hqcfgY2ycgPKsZ1JNQkxsdqaL+zNH5gb7njYru6WgC6uVMKOIsWLdKsWbM6LTN48OCvVRGPxyNJqqurU0ZGhr29rq5OY8aMscvs27cv7HWBQED19fX26zvidrvldru/Vr1OxeisVI3OSo34+wAAgM6dUsDp27ev+vbtG5GKDBo0SB6PR+Xl5Xag8fl8qqystO/EysnJUUNDg6qqqjRu3DhJ0qZNmxQMBpWdnR2RegEAgOgTsdvEd+/ererqau3evVttbW2qrq5WdXV12Jw1w4cP13PPPSdJcrlcWrhwoe6880798Y9/1N///ncVFBQoMzNTU6dOlSSdf/75ys/PV2FhobZu3arXX39dCxYs0IwZM076DioAAGC+iA0yXrp0qTZs2GD/PHbsWEnSq6++qssuu0ySVFNTo8bGRrvMLbfcoubmZs2dO1cNDQ265JJLVFpaqsTERLvMxo0btWDBAk2cOFExMTGaNm2aVq9eHalmAACAKBTxeXC6I+bBAQAg+pzK728WcAEAAMYh4AAAAOMQcAAAgHEIOAAAwDgEHAAAYBwCDgAAMA4BBwAAGIeAAwAAjEPAAQAAxonYUg3dWWjyZp/P18U1AQAAJyv0e/tkFmFwZMA5ePCgJCkrK6uLawIAAE7VwYMHlZKS0mkZR65FFQwGtXfvXvXq1Usul6urq3Pa+Xw+ZWVlac+ePY5ca4v2037aT/tpv5nttyxLBw8eVGZmpmJiOh9l48genJiYGPXv37+rqxFxycnJRn7BTxbtp/20n/Y7lcntP1HPTQiDjAEAgHEIOAAAwDgEHAO53W4tW7ZMbre7q6vSJWg/7af9tJ/2O7P97TlykDEAADAbPTgAAMA4BBwAAGAcAg4AADAOAQcAABiHgBOlSkpKdOGFF6pXr17q16+fpk6dqpqamrAyl112mVwuV9jj2muv7aIan1633377MW0bPny4/fzhw4c1f/58nX322TrrrLM0bdo01dXVdWGNT6+BAwce036Xy6X58+dLMu+zf+211/T9739fmZmZcrlcev7558OetyxLS5cuVUZGhnr06KHc3Fx9+OGHYWXq6+s1c+ZMJScnKzU1VXPmzFFTU9MZbMU309n/A7/fr8WLF2vkyJHq2bOnMjMzVVBQoL1794bto6PvzT333HOGW/L1nOg7MGvWrGPalp+fH1Ymmr8DJ2p/R+cDl8ullStX2mWi+fP/Ogg4UWrLli2aP3++3nzzTZWVlcnv92vSpElqbm4OK1dYWKja2lr7cd9993VRjU+/f/7nfw5r21//+lf7uRtvvFEvvPCCnnnmGW3ZskV79+7Vj370oy6s7en11ltvhbW9rKxMkvTjH//YLmPSZ9/c3KzRo0drzZo1HT5/3333afXq1Vq7dq0qKyvVs2dP5eXl6fDhw3aZmTNn6v3331dZWZlefPFFvfbaa5o7d+6ZasI31tn/g0OHDmnbtm1asmSJtm3bpmeffVY1NTX6wQ9+cEzZ5cuXh30vrr/++jNR/W/sRN8BScrPzw9r229/+9uw56P5O3Ci9rdvd21trdatWyeXy6Vp06aFlYvWz/9rsWCEffv2WZKsLVu22NsuvfRS6+c//3nXVSqCli1bZo0ePbrD5xoaGqz4+HjrmWeesbdt377dkmRVVFScoRqeWT//+c+tIUOGWMFg0LIssz97SdZzzz1n/xwMBi2Px2OtXLnS3tbQ0GC53W7rt7/9rWVZlvWPf/zDkmS99dZbdpn/+Z//sVwul/Xpp5+esbqfLl/9f9CRrVu3WpKsXbt22dsGDBhg/fKXv4xs5c6Ajtp/9dVXW1OmTDnua0z6DpzM5z9lyhTre9/7Xtg2Uz7/k0UPjiEaGxslSWlpaWHbN27cqD59+uiCCy5QcXGxDh061BXVi4gPP/xQmZmZGjx4sGbOnKndu3dLkqqqquT3+5Wbm2uXHT58uM4991xVVFR0VXUjprW1VU888YT+7d/+LWzxWJM/+/Z27twpr9cb9nmnpKQoOzvb/rwrKiqUmpqq8ePH22Vyc3MVExOjysrKM17nM6GxsVEul0upqalh2++55x6dffbZGjt2rFauXKlAINA1FYyAzZs3q1+/fho2bJjmzZun/fv328856TtQV1enP/3pT5ozZ84xz5n8+X+VIxfbNE0wGNTChQv17W9/WxdccIG9/ac//akGDBigzMxMvfvuu1q8eLFqamr07LPPdmFtT4/s7GytX79ew4YNU21tre644w595zvf0XvvvSev16uEhIRjTuzp6enyer1dU+EIev7559XQ0KBZs2bZ20z+7L8q9Jmmp6eHbW//eXu9XvXr1y/s+bi4OKWlpRn5nTh8+LAWL16sq666KmzBxRtuuEHf+ta3lJaWpjfeeEPFxcWqra3VqlWrurC2p0d+fr5+9KMfadCgQfroo4/0i1/8QldccYUqKioUGxvrqO/Ahg0b1KtXr2Muy5v8+XeEgGOA+fPn67333gsbgyIp7NryyJEjlZGRoYkTJ+qjjz7SkCFDznQ1T6srrrjC/veoUaOUnZ2tAQMG6He/+5169OjRhTU78x599FFdccUVyszMtLeZ/Nmjc36/Xz/5yU9kWZYeeuihsOeKiorsf48aNUoJCQn693//d5WUlET91P4zZsyw/z1y5EiNGjVKQ4YM0ebNmzVx4sQurNmZt27dOs2cOVOJiYlh203+/DvCJaoot2DBAr344ot69dVX1b9//07LZmdnS5J27NhxJqp2RqWmpuqf/umftGPHDnk8HrW2tqqhoSGsTF1dnTweT9dUMEJ27dqlV155Rddcc02n5Uz+7EOf6Vfvkmv/eXs8Hu3bty/s+UAgoPr6eqO+E6Fws2vXLpWVlYX13nQkOztbgUBAH3/88Zmp4Bk0ePBg9enTx/7OO+U78Je//EU1NTUnPCdIZn/+EgEnalmWpQULFui5557Tpk2bNGjQoBO+prq6WpKUkZER4dqdeU1NTfroo4+UkZGhcePGKT4+XuXl5fbzNTU12r17t3JycrqwlqffY489pn79+mny5MmdljP5sx80aJA8Hk/Y5+3z+VRZWWl/3jk5OWpoaFBVVZVdZtOmTQoGg3b4i3ahcPPhhx/qlVde0dlnn33C11RXVysmJuaYSzcm+OSTT7R//377O++E74B0pEd33LhxGj169AnLmvz5S+Iuqmg1b948KyUlxdq8ebNVW1trPw4dOmRZlmXt2LHDWr58ufX2229bO3futP7whz9YgwcPtr773e92cc1Pj0WLFlmbN2+2du7cab3++utWbm6u1adPH2vfvn2WZVnWtddea5177rnWpk2brLffftvKycmxcnJyurjWp1dbW5t17rnnWosXLw7bbuJnf/DgQeudd96x3nnnHUuStWrVKuudd96x7xC65557rNTUVOsPf/iD9e6771pTpkyxBg0aZH3xxRf2PvLz862xY8dalZWV1l//+lfrvPPOs6666qquatIp6+z/QWtrq/WDH/zA6t+/v1VdXR12TmhpabEsy7LeeOMN65e//KVVXV1tffTRR9YTTzxh9e3b1yooKOjilp2cztp/8OBB66abbrIqKiqsnTt3Wq+88or1rW99yzrvvPOsw4cP2/uI5u/AiY4By7KsxsZGKykpyXrooYeOeX20f/5fBwEnSknq8PHYY49ZlmVZu3fvtr773e9aaWlpltvttoYOHWrdfPPNVmNjY9dW/DSZPn26lZGRYSUkJFjnnHOONX36dGvHjh3281988YV13XXXWb1797aSkpKsH/7wh1ZtbW0X1vj0e+mllyxJVk1NTdh2Ez/7V199tcPv+9VXX21Z1pFbxZcsWWKlp6dbbrfbmjhx4jH/X/bv329dddVV1llnnWUlJydbs2fPtg4ePNgFrfl6Ovt/sHPnzuOeE1599VXLsiyrqqrKys7OtlJSUqzExETr/PPPt+6+++6wANCdddb+Q4cOWZMmTbL69u1rxcfHWwMGDLAKCwstr9cbto9o/g6c6BiwLMv69a9/bfXo0cNqaGg45vXR/vl/HS7LsqyIdhEBAACcYYzBAQAAxiHgAAAA4xBwAACAcQg4AADAOAQcAABgHAIOAAAwDgEHAAAYh4ADAACMQ8ABAADGIeAAAADjEHAAAIBxCDgAAMA4/w/Mq/sIIGeM0wAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Create a multi-class dataset using the [spirals data creation function from CS231n](https://cs231n.github.io/neural-networks-case-study/) (see below for the code).\n", + " * Split the data into training and test sets (80% train, 20% test) as well as turn it into PyTorch tensors.\n", + " * Construct a model capable of fitting the data (you may need a combination of linear and non-linear layers).\n", + " * Build a loss function and optimizer capable of handling multi-class data (optional extension: use the Adam optimizer instead of SGD, you may have to experiment with different values of the learning rate to get it working).\n", + " * Make a training and testing loop for the multi-class data and train a model on it to reach over 95% testing accuracy (you can use any accuracy measuring function here that you like) - 1000 epochs should be plenty.\n", + " * Plot the decision boundaries on the spirals dataset from your model predictions, the `plot_decision_boundary()` function should work for this dataset too." + ], + "metadata": { + "id": "Lbt1bNcWk5G9" + } + }, + { + "cell_type": "code", + "source": [ + "# Code for creating a spiral dataset from CS231n\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "RANDOM_SEED = 42\n", + "np.random.seed(RANDOM_SEED)\n", + "N = 100 # number of points per class\n", + "D = 2 # dimensionality\n", + "K = 3 # number of classes\n", + "X = np.zeros((N*K,D)) # data matrix (each row = single example)\n", + "y = np.zeros(N*K, dtype='uint8') # class labels\n", + "for j in range(K):\n", + " ix = range(N*j,N*(j+1))\n", + " r = np.linspace(0.0,1,N) # radius\n", + " t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta\n", + " X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]\n", + " y[ix] = j\n", + "# lets visualize the data\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "tU-UNZsKlJls", + "outputId": "e62a5067-098c-4307-c026-5c6d08ef2cad" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors\n", + "import torch\n", + "X = torch.from_numpy(X).type(torch.float) # features as float32\n", + "y = torch.from_numpy(y).type(torch.LongTensor) # labels need to be of type long\n", + "\n", + "# Create train and test splits\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=RANDOM_SEED)\n", + "len(X_train), len(X_test), len(y_train), len(y_test)" + ], + "metadata": { + "id": "OWVrmkEyl0VP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3ad2db89-c6fa-4b3e-d966-392763530032" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(240, 60, 240, 60)" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy for when we fit our model\n", + "!pip -q install torchmetrics # colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "\n", + "## TODO: uncomment the two lines below to send the accuracy function to the device\n", + "acc_fn = Accuracy(task=\"multiclass\", num_classes=4).to(device)\n", + "acc_fn" + ], + "metadata": { + "id": "a-v-7f0op0tG", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "34a7e85c-9c8b-4365-fd3e-b449b319725d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MulticlassAccuracy()" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Prepare device agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "# Create model by subclassing nn.Module\n", + "class SpiralModel(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.linear1 = nn.Linear(in_features=2, out_features=10)\n", + " self.linear2 = nn.Linear(in_features=10, out_features=10)\n", + " self.linear3 = nn.Linear(in_features=10, out_features=3)\n", + " self.relu = nn.ReLU()\n", + "\n", + "\n", + "# Instantiate model and send it to device\n", + " def forward(self, x):\n", + " return self.linear3(self.relu(self.linear2(self.relu(self.linear1(x)))))\n", + "\n", + "model_1 = SpiralModel().to(device)\n", + "model_1" + ], + "metadata": { + "id": "DB3u3ldumapf", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "702b88ca-5f18-45e9-f0e3-c4d48ba0a338" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "SpiralModel(\n", + " (linear1): Linear(in_features=2, out_features=10, bias=True)\n", + " (linear2): Linear(in_features=10, out_features=10, bias=True)\n", + " (linear3): Linear(in_features=10, out_features=3, bias=True)\n", + " (relu): ReLU()\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup data to be device agnostic\n", + "X_train, y_train = X_train.to(device), y_train.to(device)\n", + "X_test, y_test = X_test.to(device), y_test.to(device)\n", + "print(X_train.dtype, X_test.dtype, y_train.dtype, y_test.dtype)\n", + "\n", + "# Print out first 10 untrained model outputs (forward pass)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "print(model_1(X_train)[:10])\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "print(torch.softmax(model_1(X_train)[:10], dim=1))\n", + "print(\"Pred labels:\")\n", + "## Your code here ##\n", + "print(torch.softmax(model_1(X_train)[:10], dim=1).argmax(dim=1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QE7XWSSunMTS", + "outputId": "6932d533-7ea4-4a59-b95c-58ed6fb762e0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "torch.float32 torch.float32 torch.int64 torch.int64\n", + "Logits:\n", + "tensor([[-0.2160, -0.0600, 0.2256],\n", + " [-0.2020, -0.0530, 0.2257],\n", + " [-0.2223, -0.0604, 0.2384],\n", + " [-0.2174, -0.0555, 0.2826],\n", + " [-0.2201, -0.0502, 0.2792],\n", + " [-0.2195, -0.0565, 0.2457],\n", + " [-0.2212, -0.0581, 0.2440],\n", + " [-0.2251, -0.0631, 0.2354],\n", + " [-0.2116, -0.0548, 0.2336],\n", + " [-0.2170, -0.0552, 0.2842]], device='cuda:0',\n", + " grad_fn=)\n", + "Pred probs:\n", + "tensor([[0.2685, 0.3139, 0.4176],\n", + " [0.2707, 0.3142, 0.4151],\n", + " [0.2659, 0.3126, 0.4215],\n", + " [0.2615, 0.3074, 0.4311],\n", + " [0.2609, 0.3092, 0.4299],\n", + " [0.2653, 0.3123, 0.4224],\n", + " [0.2653, 0.3123, 0.4224],\n", + " [0.2659, 0.3127, 0.4214],\n", + " [0.2681, 0.3136, 0.4184],\n", + " [0.2614, 0.3072, 0.4314]], device='cuda:0', grad_fn=)\n", + "Pred labels:\n", + "tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2], device='cuda:0')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function and optimizer\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.Adam(model_1.parameters(),\n", + " lr=0.02)" + ], + "metadata": { + "id": "54EqLRKLo0AW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Build a training loop for the model\n", + "epochs = 1000\n", + "\n", + "# Loop over data\n", + "for epoch in range(epochs):\n", + " ## Training\n", + " model_1.train()\n", + " # 1. forward pass\n", + " y_logits = model_1(X_train)\n", + " y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1)\n", + "\n", + " # 2. calculate the loss\n", + " loss = loss_fn(y_logits, y_train)\n", + " acc = acc_fn(y_pred, y_train)\n", + " # 3. optimizer zero grad\n", + " optimizer.zero_grad()\n", + "\n", + " # 4. loss backwards\n", + " loss.backward()\n", + "\n", + " # 5. optimizer step\n", + " optimizer.step()\n", + "\n", + " ## Testing\n", + " model_1.eval()\n", + " with torch.inference_mode():\n", + " # 1. Forward pass\n", + " test_logits = model_1(X_test)\n", + " test_pred = torch.softmax(test_logits, dim=1).argmax(dim=1)\n", + " # 2. Caculate loss and acc\n", + " test_loss = loss_fn(test_logits, y_test)\n", + " test_acc = acc_fn(test_pred, y_test)\n", + " # Print out what's happening every 100 epochs\n", + "if epoch % 100 == 0:\n", + " print(f\"Epoch: {epoch} | Loss: {loss:.2f} Acc: {acc:.2f} | Test loss: {test_loss:.2f} Test acc: {test_acc:.2f}\")\n" + ], + "metadata": { + "id": "vIlExkUHnmxi" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n", + "plt.figure(figsize=(12, 6))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title(\"Train\")\n", + "plot_decision_boundary(model_1, X_train, y_train)\n", + "plt.subplot(1, 2, 2)\n", + "plt.title(\"Test\")\n", + "plot_decision_boundary(model_1, X_test, y_test)\n" + ], + "metadata": { + "id": "JrwVRbaE0keT", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 545 + }, + "outputId": "d713592b-7440-4b02-9dfe-e9476998a1bf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 68dc7ceda2f72c427ff291ce757599100fa2a0f5 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sat, 22 Feb 2025 20:12:19 +0000 Subject: [PATCH 11/17] Created using Colab --- .../week3/week3.ipynb | 1338 +++++++++++++++++ 1 file changed, 1338 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week3/week3.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week3/week3.ipynb b/Part_1_Deep_Learning_with_Pytorch/week3/week3.ipynb new file mode 100644 index 0000000..4ef42df --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week3/week3.ipynb @@ -0,0 +1,1338 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "02_pytorch_classification_exercises.ipynb", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 02. PyTorch Classification Exercises\n", + "\n", + "The following is a template for 02. PyTorch Classification exercises.\n", + "\n", + "It's only starter code and it's your job to fill in the blanks.\n", + "\n", + "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n", + "\n", + "Don't worry about trying to be *right* just try writing code that suffices the question.\n", + "\n", + "## Resources\n", + "* These exercises are based on [notebook 02 of the learn PyTorch course](https://www.learnpytorch.io/02_pytorch_classification/).\n", + "* You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)." + ], + "metadata": { + "id": "ZKJFt7YxH8yl" + } + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Setup device agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n", + "\n", + "# Setup random seed\n", + "RANDOM_SEED = 42" + ], + "metadata": { + "id": "CSrUPgapO0tf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. Make a binary classification dataset with Scikit-Learn's [`make_moons()`](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_moons.html) function.\n", + " * For consistency, the dataset should have 1000 samples and a `random_state=42`.\n", + " * Turn the data into PyTorch tensors.\n", + " * Split the data into training and test sets using `train_test_split` with 80% training and 20% testing." + ], + "metadata": { + "id": "pH7jIZ2SPFee" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a dataset with Scikit-Learn's make_moons()\n", + "from sklearn.datasets import make_moons\n", + "NUM_SAMPLES = 1000\n", + "X, y = make_moons(n_samples=NUM_SAMPLES,\n", + " noise=0.07,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "X[:10], y[:10]" + ], + "metadata": { + "id": "5t4VhPV1PX1X", + "outputId": "88e33069-75ee-48cd-8e9f-06669f7db812", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(array([[-0.03341062, 0.4213911 ],\n", + " [ 0.99882703, -0.4428903 ],\n", + " [ 0.88959204, -0.32784256],\n", + " [ 0.34195829, -0.41768975],\n", + " [-0.83853099, 0.53237483],\n", + " [ 0.59906425, -0.28977331],\n", + " [ 0.29009023, -0.2046885 ],\n", + " [-0.03826868, 0.45942924],\n", + " [ 1.61377123, -0.2939697 ],\n", + " [ 0.693337 , 0.82781911]]),\n", + " array([1, 1, 1, 1, 0, 1, 1, 1, 1, 0]))" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into a DataFrame\n", + "import pandas as pd\n", + "data_df = pd.DataFrame({\"X0\": X[:, 0],\n", + " \"X1\": X[:, 1],\n", + " \"y\": y})\n", + "data_df.head()" + ], + "metadata": { + "id": "SUeHZ3-3P9C7", + "outputId": "7ab24745-f8e6-46cc-8a14-5053c4aa3223", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " X0 X1 y\n", + "0 -0.033411 0.421391 1\n", + "1 0.998827 -0.442890 1\n", + "2 0.889592 -0.327843 1\n", + "3 0.341958 -0.417690 1\n", + "4 -0.838531 0.532375 0" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
X0X1y
0-0.0334110.4213911
10.998827-0.4428901
20.889592-0.3278431
30.341958-0.4176901
4-0.8385310.5323750
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "variable_name": "data_df", + "summary": "{\n \"name\": \"data_df\",\n \"rows\": 1000,\n \"fields\": [\n {\n \"column\": \"X0\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.8694818021016458,\n \"min\": -1.1517146477802855,\n \"max\": 2.1819758362649324,\n \"num_unique_values\": 1000,\n \"samples\": [\n 0.5424909907290043,\n 0.8410600562502046,\n 1.274536542513856\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"X1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.4984727335666475,\n \"min\": -0.6690694860909892,\n \"max\": 1.132945524956193,\n \"num_unique_values\": 1000,\n \"samples\": [\n -0.39644452406089203,\n 0.6354459945668033,\n -0.4373423036321222\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Visualize the data on a scatter plot\n", + "import matplotlib.pyplot as plt\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlGn_r);" + ], + "metadata": { + "id": "owrkPSFvQPFI", + "outputId": "6d2f18dc-e193-44d9-8b8a-d227162f1258", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors of dtype float\n", + "X = torch.tensor(X, dtype=torch.float)\n", + "y = torch.tensor(y, dtype=torch.float)\n", + "\n", + "# Split the data into train and test sets (80% train, 20% test)\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X,\n", + " y,\n", + " test_size=0.2,\n", + " random_state=RANDOM_SEED)\n", + "\n", + "len(X_train), len(X_test), len(y_train), len(y_test)" + ], + "metadata": { + "id": "bDhyHn9fR4dq", + "outputId": "2cc583f5-256f-496d-dd99-eac628c03505", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(800, 200, 800, 200)" + ] + }, + "metadata": {}, + "execution_count": 19 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Build a model by subclassing `nn.Module` that incorporates non-linear activation functions and is capable of fitting the data you created in 1.\n", + " * Feel free to use any combination of PyTorch layers (linear and non-linear) you want." + ], + "metadata": { + "id": "cMIjxZdzQfPz" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from torch import nn\n", + "\n", + "# Inherit from nn.Module to make a model capable of fitting the mooon data\n", + "class MoonModelV0(nn.Module):\n", + " ## Your code here ##\n", + " def __init__(self, in_features, out_features, hidden_units):\n", + " super().__init__()\n", + "\n", + " self.layer1 = nn.Linear(in_features=in_features,\n", + " out_features=hidden_units)\n", + " self.layer2 = nn.Linear(in_features=hidden_units,\n", + " out_features=hidden_units)\n", + " self.layer3 = nn.Linear(in_features=hidden_units,\n", + " out_features=out_features)\n", + " self.relu = nn.ReLU()\n", + "\n", + " def forward(self, x):\n", + " ## Your code here ##\n", + " return self.layer3(self.relu(self.layer2(self.relu(self.layer1(x)))))\n", + "# Instantiate the model\n", + "model_0 = MoonModelV0(in_features=2,\n", + " out_features=1,\n", + " hidden_units=10).to(device)\n", + " ## Your code here ##\n", + "model_0\n", + "model_0.state_dict()\n" + ], + "metadata": { + "id": "hwtyvm34Ri6Q", + "outputId": "a2d24946-d8b6-4155-cbbc-811e15d64bc4", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "OrderedDict([('layer1.weight',\n", + " tensor([[ 0.5406, 0.5869],\n", + " [-0.1657, 0.6496],\n", + " [-0.1549, 0.1427],\n", + " [-0.3443, 0.4153],\n", + " [ 0.6233, -0.5188],\n", + " [ 0.6146, 0.1323],\n", + " [ 0.5224, 0.0958],\n", + " [ 0.3410, -0.0998],\n", + " [ 0.5451, 0.1045],\n", + " [-0.3301, 0.1802]], device='cuda:0')),\n", + " ('layer1.bias',\n", + " tensor([-0.3258, -0.0829, -0.2872, 0.4691, -0.5582, -0.3260, -0.1997, -0.4252,\n", + " 0.0667, -0.6984], device='cuda:0')),\n", + " ('layer2.weight',\n", + " tensor([[ 0.2856, -0.2686, 0.2441, 0.0526, -0.1027, 0.1954, 0.0493, 0.2555,\n", + " 0.0346, -0.0997],\n", + " [ 0.0850, -0.0858, 0.1331, 0.2823, 0.1828, -0.1382, 0.1825, 0.0566,\n", + " 0.1606, -0.1927],\n", + " [-0.3130, -0.1222, -0.2426, 0.2595, 0.0911, 0.1310, 0.1000, -0.0055,\n", + " 0.2475, -0.2247],\n", + " [ 0.0199, -0.2158, 0.0975, -0.1089, 0.0969, -0.0659, 0.2623, -0.1874,\n", + " -0.1886, -0.1886],\n", + " [ 0.2844, 0.1054, 0.3043, -0.2610, -0.3137, -0.2474, -0.2127, 0.1281,\n", + " 0.1132, 0.2628],\n", + " [-0.1633, -0.2156, 0.1678, -0.1278, 0.1919, -0.0750, 0.1809, -0.2457,\n", + " -0.1596, 0.0964],\n", + " [ 0.0669, -0.0806, 0.1885, 0.2150, -0.2293, -0.1688, 0.2896, -0.1067,\n", + " -0.1121, -0.3060],\n", + " [-0.1811, 0.0790, -0.0417, -0.2295, 0.0074, -0.2160, -0.2683, -0.1741,\n", + " -0.2768, -0.2014],\n", + " [ 0.3161, 0.0597, 0.0974, -0.2949, -0.2077, -0.1053, 0.0494, -0.2783,\n", + " -0.1363, -0.1893],\n", + " [ 0.0009, -0.1177, -0.0219, -0.2143, -0.2171, -0.1845, -0.1082, -0.2496,\n", + " 0.2651, -0.0628]], device='cuda:0')),\n", + " ('layer2.bias',\n", + " tensor([ 0.2721, 0.0985, -0.2678, 0.2188, -0.0870, -0.1212, -0.2625, -0.3144,\n", + " 0.0905, -0.0691], device='cuda:0')),\n", + " ('layer3.weight',\n", + " tensor([[ 0.1231, -0.2595, 0.2348, -0.2321, -0.0546, 0.0661, 0.1633, 0.2553,\n", + " 0.2881, -0.2507]], device='cuda:0')),\n", + " ('layer3.bias', tensor([0.0796], device='cuda:0'))])" + ] + }, + "metadata": {}, + "execution_count": 20 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Setup a binary classification compatible loss function and optimizer to use when training the model built in 2." + ], + "metadata": { + "id": "DSj97RwyVeFE" + } + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function\n", + "loss_fn = nn.BCEWithLogitsLoss()\n", + "# Setup optimizer to optimize model's parameters\n", + "optimizer = torch.optim.SGD(params=model_0.parameters(), # parameters of model to optimize\n", + " lr=0.1) # learning rate" + ], + "metadata": { + "id": "whSGw5qgVvxU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Create a training and testing loop to fit the model you created in 2 to the data you created in 1.\n", + " * Do a forward pass of the model to see what's coming out in the form of logits, prediction probabilities and labels.\n", + " * To measure model accuray, you can create your own accuracy function or use the accuracy function in [TorchMetrics](https://torchmetrics.readthedocs.io/en/latest/).\n", + " * Train the model for long enough for it to reach over 96% accuracy.\n", + " * The training loop should output progress every 10 epochs of the model's training and test set loss and accuracy." + ], + "metadata": { + "id": "nvk4PfNTWUAt" + } + }, + { + "cell_type": "code", + "source": [ + "# What's coming out of our model?\n", + "\n", + "# logits (raw outputs of model)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "print(model_0(X_train.to(device)[:10]).squeeze())\n", + "# Prediction probabilities\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "print(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze()))\n", + "\n", + "# Prediction labels\n", + "print(\"Pred labels:\")\n", + "## Your code here ##\n", + "print(torch.round(torch.sigmoid(model_0(X_train.to(device)[:10]).squeeze())))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AgnFdlamd2-D", + "outputId": "0c3d73e1-d651-40cb-8326-05cd8a7a8016" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Logits:\n", + "tensor([0.0019, 0.0094, 0.0161, 0.0185, 0.0284, 0.0192, 0.0291, 0.0196, 0.0258,\n", + " 0.0079], device='cuda:0', grad_fn=)\n", + "Pred probs:\n", + "tensor([0.5005, 0.5024, 0.5040, 0.5046, 0.5071, 0.5048, 0.5073, 0.5049, 0.5065,\n", + " 0.5020], device='cuda:0', grad_fn=)\n", + "Pred labels:\n", + "tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], device='cuda:0',\n", + " grad_fn=)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy using accuracy from TorchMetrics\n", + "!pip -q install torchmetrics # Colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "## TODO: Uncomment this code to use the Accuracy function\n", + "acc_fn = Accuracy(task=\"multiclass\", num_classes=2).to(device) # send accuracy function to device\n", + "acc_fn" + ], + "metadata": { + "id": "rUSDNHB4euoJ", + "outputId": "495d36fd-5689-4655-cee2-2e56a0134582", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MulticlassAccuracy()" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [], + "metadata": { + "id": "fGmP1hSLn-DR" + } + }, + { + "cell_type": "code", + "source": [ + "##TODO: Uncomment this to set the seed\n", + "torch.manual_seed(RANDOM_SEED)\n", + "\n", + "# Setup epochs\n", + "epochs=1000\n", + "\n", + "# Send data to the device\n", + "X_train, y_train = X_train.to(device), y_train.to(device)\n", + "X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + "# Loop through the data\n", + "for epoch in range(epochs):\n", + " ### Training\n", + " model_0.train()\n", + "\n", + " # 1. Forward pass (logits output)\n", + "y_logits = model_0(X_train).squeeze()\n", + " # Turn logits into prediction probabilities\n", + "y_pred_probs = torch.sigmoid(y_logits)\n", + "\n", + " # Turn prediction probabilities into prediction labels\n", + "y_pred = torch.round(y_pred_probs)\n", + "\n", + " # 2. Calculaute the loss\n", + "loss = loss_fn(y_logits, y_train) # loss = compare model raw outputs to desired model outputs\n", + " # Calculate the accuracy\n", + "acc = acc_fn(y_pred, y_train.int()) # the accuracy function needs to compare pred labels (not logits) with actual labels\n", + "\n", + " # 3. Zero the gradients\n", + "optimizer.zero_grad()\n", + "\n", + " # 4. Loss backward (perform backpropagation) - https://brilliant.org/wiki/backpropagation/#:~:text=Backpropagation%2C%20short%20for%20%22backward%20propagation,to%20the%20neural%20network's%20weights.\n", + "loss.backward()\n", + " # 5. Step the optimizer (gradient descent) - https://towardsdatascience.com/gradient-descent-algorithm-a-deep-dive-cf04e8115f21#:~:text=Gradient%20descent%20(GD)%20is%20an,e.g.%20in%20a%20linear%20regression)\n", + "optimizer.step()\n", + "\n", + " ### Testing\n", + "model_0.eval()\n", + "with torch.inference_mode():\n", + " # 1. Forward pass (to get the logits)\n", + " test_logits = model_0(X_test).squeeze()\n", + "\n", + " # Turn the test logits into prediction labels\n", + " test_pred = torch.round(torch.sigmoid(test_logits))\n", + "\n", + " # 2. Caculate the test loss/acc\n", + " test_loss = loss_fn(test_logits, y_test)\n", + " test_acc = acc_fn(test_pred, y_test.int())\n", + "\n", + "\n", + " # Print out what's happening every 100 epochs\n", + "if epoch % 100 == 0:\n", + " print(f\"Epoch: {epoch} | Loss: {loss:.2f} Acc: {acc:.2f} | Test loss: {test_loss:.2f} Test acc: {test_acc:.2f}\")\n", + "\n" + ], + "metadata": { + "id": "SHBY3h7XXnxt" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Make predictions with your trained model and plot them using the `plot_decision_boundary()` function created in this notebook." + ], + "metadata": { + "id": "8Nwihtomj9JO" + } + }, + { + "cell_type": "code", + "source": [ + "# Plot the model predictions\n", + "import numpy as np\n", + "\n", + "def plot_decision_boundary(model, X, y):\n", + "\n", + " # Put everything to CPU (works better with NumPy + Matplotlib)\n", + " model.to(\"cpu\")\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Source - https://madewithml.com/courses/foundations/neural-networks/\n", + " # (with modifications)\n", + " x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1\n", + " y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1\n", + " xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101),\n", + " np.linspace(y_min, y_max, 101))\n", + "\n", + " # Make features\n", + " X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()\n", + "\n", + " # Make predictions\n", + " model.eval()\n", + " with torch.inference_mode():\n", + " y_logits = model(X_to_pred_on)\n", + "\n", + " # Test for multi-class or binary and adjust logits to prediction labels\n", + " if len(torch.unique(y)) > 2:\n", + " y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1) # mutli-class\n", + " else:\n", + " y_pred = torch.round(torch.sigmoid(y_logits)) # binary\n", + "\n", + " # Reshape preds and plot\n", + " y_pred = y_pred.reshape(xx.shape).detach().numpy()\n", + " plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)\n", + " plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + " plt.xlim(xx.min(), xx.max())\n", + " plt.ylim(yy.min(), yy.max())" + ], + "metadata": { + "id": "0YRzatb8a1P2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n", + "plt.figure(figsize=(12, 6))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title(\"Train\")\n", + "plot_decision_boundary(model_0, X_train, y_train)\n", + "plt.subplot(1, 2, 2)\n", + "plt.title(\"Test\")\n", + "plot_decision_boundary(model_0, X_test, y_test)" + ], + "metadata": { + "id": "PMrcpyirig1d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 545 + }, + "outputId": "05cd1077-06d2-44db-8182-bbd7d3ac3709" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Replicate the Tanh (hyperbolic tangent) activation function in pure PyTorch.\n", + " * Feel free to reference the [ML cheatsheet website](https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh) for the formula." + ], + "metadata": { + "id": "EtMYBvtciiAU" + } + }, + { + "cell_type": "code", + "source": [ + "# Create a straight line tensor\n", + "tensor_A = torch.arange(-100, 100, 1)\n", + "plt.plot(tensor_A)" + ], + "metadata": { + "id": "BlXaWC5TkEUE", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "outputId": "b1e7995a-ef43-4a54-86dc-32aee0015e9f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 28 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Test torch.tanh() on the tensor and plot it\n", + "plt.plot(torch.tanh(tensor_A))" + ], + "metadata": { + "id": "vZPCcQmIkZjO", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "outputId": "e8cb1d13-aff4-4280-cd23-0def0c62bb05" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 29 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Replicate torch.tanh() and plot it\n", + "def tanh(x):\n", + " # Source - https://ml-cheatsheet.readthedocs.io/en/latest/activation_functions.html#tanh\n", + " return (torch.exp(x) - torch.exp(-x)) / (torch.exp(x) + torch.exp(-x))\n", + "\n", + "plt.plot(tanh(tensor_A))" + ], + "metadata": { + "id": "J-ne__Kjkdc1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 447 + }, + "outputId": "787ae729-f1c8-4887-b04c-49d8ce1ec718" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 30 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Create a multi-class dataset using the [spirals data creation function from CS231n](https://cs231n.github.io/neural-networks-case-study/) (see below for the code).\n", + " * Split the data into training and test sets (80% train, 20% test) as well as turn it into PyTorch tensors.\n", + " * Construct a model capable of fitting the data (you may need a combination of linear and non-linear layers).\n", + " * Build a loss function and optimizer capable of handling multi-class data (optional extension: use the Adam optimizer instead of SGD, you may have to experiment with different values of the learning rate to get it working).\n", + " * Make a training and testing loop for the multi-class data and train a model on it to reach over 95% testing accuracy (you can use any accuracy measuring function here that you like) - 1000 epochs should be plenty.\n", + " * Plot the decision boundaries on the spirals dataset from your model predictions, the `plot_decision_boundary()` function should work for this dataset too." + ], + "metadata": { + "id": "Lbt1bNcWk5G9" + } + }, + { + "cell_type": "code", + "source": [ + "# Code for creating a spiral dataset from CS231n\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "RANDOM_SEED = 42\n", + "np.random.seed(RANDOM_SEED)\n", + "N = 100 # number of points per class\n", + "D = 2 # dimensionality\n", + "K = 3 # number of classes\n", + "X = np.zeros((N*K,D)) # data matrix (each row = single example)\n", + "y = np.zeros(N*K, dtype='uint8') # class labels\n", + "for j in range(K):\n", + " ix = range(N*j,N*(j+1))\n", + " r = np.linspace(0.0,1,N) # radius\n", + " t = np.linspace(j*4,(j+1)*4,N) + np.random.randn(N)*0.2 # theta\n", + " X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]\n", + " y[ix] = j\n", + "# lets visualize the data\n", + "plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "tU-UNZsKlJls", + "outputId": "e62a5067-098c-4307-c026-5c6d08ef2cad" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn data into tensors\n", + "import torch\n", + "X = torch.from_numpy(X).type(torch.float) # features as float32\n", + "y = torch.from_numpy(y).type(torch.LongTensor) # labels need to be of type long\n", + "\n", + "# Create train and test splits\n", + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=RANDOM_SEED)\n", + "len(X_train), len(X_test), len(y_train), len(y_test)" + ], + "metadata": { + "id": "OWVrmkEyl0VP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3ad2db89-c6fa-4b3e-d966-392763530032" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(240, 60, 240, 60)" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Let's calculuate the accuracy for when we fit our model\n", + "!pip -q install torchmetrics # colab doesn't come with torchmetrics\n", + "from torchmetrics import Accuracy\n", + "\n", + "## TODO: uncomment the two lines below to send the accuracy function to the device\n", + "acc_fn = Accuracy(task=\"multiclass\", num_classes=4).to(device)\n", + "acc_fn" + ], + "metadata": { + "id": "a-v-7f0op0tG", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "34a7e85c-9c8b-4365-fd3e-b449b319725d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MulticlassAccuracy()" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Prepare device agnostic code\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "\n", + "# Create model by subclassing nn.Module\n", + "class SpiralModel(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.linear1 = nn.Linear(in_features=2, out_features=10)\n", + " self.linear2 = nn.Linear(in_features=10, out_features=10)\n", + " self.linear3 = nn.Linear(in_features=10, out_features=3)\n", + " self.relu = nn.ReLU()\n", + "\n", + "\n", + "# Instantiate model and send it to device\n", + " def forward(self, x):\n", + " return self.linear3(self.relu(self.linear2(self.relu(self.linear1(x)))))\n", + "\n", + "model_1 = SpiralModel().to(device)\n", + "model_1" + ], + "metadata": { + "id": "DB3u3ldumapf", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "702b88ca-5f18-45e9-f0e3-c4d48ba0a338" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "SpiralModel(\n", + " (linear1): Linear(in_features=2, out_features=10, bias=True)\n", + " (linear2): Linear(in_features=10, out_features=10, bias=True)\n", + " (linear3): Linear(in_features=10, out_features=3, bias=True)\n", + " (relu): ReLU()\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup data to be device agnostic\n", + "X_train, y_train = X_train.to(device), y_train.to(device)\n", + "X_test, y_test = X_test.to(device), y_test.to(device)\n", + "print(X_train.dtype, X_test.dtype, y_train.dtype, y_test.dtype)\n", + "\n", + "# Print out first 10 untrained model outputs (forward pass)\n", + "print(\"Logits:\")\n", + "## Your code here ##\n", + "print(model_1(X_train)[:10])\n", + "print(\"Pred probs:\")\n", + "## Your code here ##\n", + "print(torch.softmax(model_1(X_train)[:10], dim=1))\n", + "print(\"Pred labels:\")\n", + "## Your code here ##\n", + "print(torch.softmax(model_1(X_train)[:10], dim=1).argmax(dim=1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QE7XWSSunMTS", + "outputId": "6932d533-7ea4-4a59-b95c-58ed6fb762e0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "torch.float32 torch.float32 torch.int64 torch.int64\n", + "Logits:\n", + "tensor([[-0.2160, -0.0600, 0.2256],\n", + " [-0.2020, -0.0530, 0.2257],\n", + " [-0.2223, -0.0604, 0.2384],\n", + " [-0.2174, -0.0555, 0.2826],\n", + " [-0.2201, -0.0502, 0.2792],\n", + " [-0.2195, -0.0565, 0.2457],\n", + " [-0.2212, -0.0581, 0.2440],\n", + " [-0.2251, -0.0631, 0.2354],\n", + " [-0.2116, -0.0548, 0.2336],\n", + " [-0.2170, -0.0552, 0.2842]], device='cuda:0',\n", + " grad_fn=)\n", + "Pred probs:\n", + "tensor([[0.2685, 0.3139, 0.4176],\n", + " [0.2707, 0.3142, 0.4151],\n", + " [0.2659, 0.3126, 0.4215],\n", + " [0.2615, 0.3074, 0.4311],\n", + " [0.2609, 0.3092, 0.4299],\n", + " [0.2653, 0.3123, 0.4224],\n", + " [0.2653, 0.3123, 0.4224],\n", + " [0.2659, 0.3127, 0.4214],\n", + " [0.2681, 0.3136, 0.4184],\n", + " [0.2614, 0.3072, 0.4314]], device='cuda:0', grad_fn=)\n", + "Pred labels:\n", + "tensor([2, 2, 2, 2, 2, 2, 2, 2, 2, 2], device='cuda:0')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss function and optimizer\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.Adam(model_1.parameters(),\n", + " lr=0.02)" + ], + "metadata": { + "id": "54EqLRKLo0AW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Build a training loop for the model\n", + "epochs = 1000\n", + "\n", + "# Loop over data\n", + "for epoch in range(epochs):\n", + " ## Training\n", + " model_1.train()\n", + " # 1. forward pass\n", + " y_logits = model_1(X_train)\n", + " y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1)\n", + "\n", + " # 2. calculate the loss\n", + " loss = loss_fn(y_logits, y_train)\n", + " acc = acc_fn(y_pred, y_train)\n", + " # 3. optimizer zero grad\n", + " optimizer.zero_grad()\n", + "\n", + " # 4. loss backwards\n", + " loss.backward()\n", + "\n", + " # 5. optimizer step\n", + " optimizer.step()\n", + "\n", + " ## Testing\n", + " model_1.eval()\n", + " with torch.inference_mode():\n", + " # 1. Forward pass\n", + " test_logits = model_1(X_test)\n", + " test_pred = torch.softmax(test_logits, dim=1).argmax(dim=1)\n", + " # 2. Caculate loss and acc\n", + " test_loss = loss_fn(test_logits, y_test)\n", + " test_acc = acc_fn(test_pred, y_test)\n", + " # Print out what's happening every 100 epochs\n", + "if epoch % 100 == 0:\n", + " print(f\"Epoch: {epoch} | Loss: {loss:.2f} Acc: {acc:.2f} | Test loss: {test_loss:.2f} Test acc: {test_acc:.2f}\")\n" + ], + "metadata": { + "id": "vIlExkUHnmxi" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot decision boundaries for training and test sets\n", + "plt.figure(figsize=(12, 6))\n", + "plt.subplot(1, 2, 1)\n", + "plt.title(\"Train\")\n", + "plot_decision_boundary(model_1, X_train, y_train)\n", + "plt.subplot(1, 2, 2)\n", + "plt.title(\"Test\")\n", + "plot_decision_boundary(model_1, X_test, y_test)\n" + ], + "metadata": { + "id": "JrwVRbaE0keT", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 545 + }, + "outputId": "d713592b-7440-4b02-9dfe-e9476998a1bf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 0e7d7033d776640624c6f54a616965808090038e Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Sun, 23 Feb 2025 00:26:43 +0000 Subject: [PATCH 12/17] Created using Colab --- .../week4/week4solution.ipynb | 3564 +++++++++++++++++ 1 file changed, 3564 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb b/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb new file mode 100644 index 0000000..4fa17b3 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb @@ -0,0 +1,3564 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "03_pytorch_computer_vision_exercises.ipynb", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "13e8e56312674d3386224a2f00fd866f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0294fb9eb6fe4aff8d147f1f7cc1d553", + "IPY_MODEL_abfa0e7b82bf486e92f9d90960284d3e", + "IPY_MODEL_47b74eed37a84415a3fc42d1f19c5c4e" + ], + "layout": "IPY_MODEL_d7499f26238d4ec8a0d4ae459db82a5a" + } + }, + "0294fb9eb6fe4aff8d147f1f7cc1d553": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d3c8abcf41f4fee8069a63c0b7e603c", + "placeholder": "​", + "style": "IPY_MODEL_42ac5a11f588411dae6f326c558ff1fd", + "value": "100%" + } + }, + "abfa0e7b82bf486e92f9d90960284d3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e879e28f80d74fb4a91ba371ef73e0bc", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7f9038bdc08459fa2638e92d9090832", + "value": 5 + } + }, + "47b74eed37a84415a3fc42d1f19c5c4e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_59125daa8589482a84193b4f52778612", + "placeholder": "​", + "style": "IPY_MODEL_47b099254fd7441cbcc3ab185374b22d", + "value": " 5/5 [04:17<00:00, 50.76s/it]" + } + }, + "d7499f26238d4ec8a0d4ae459db82a5a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d3c8abcf41f4fee8069a63c0b7e603c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42ac5a11f588411dae6f326c558ff1fd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e879e28f80d74fb4a91ba371ef73e0bc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7f9038bdc08459fa2638e92d9090832": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "59125daa8589482a84193b4f52778612": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47b099254fd7441cbcc3ab185374b22d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63e8ded88a124e61be96e5ecb60bfa8f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bb7d551f066841259a0881d98d9f677d", + "IPY_MODEL_74d4bcf2fd1f49efbf1b0393ab9bfb97", + "IPY_MODEL_688974c6acb948d9a503736947cd9d7b" + ], + "layout": "IPY_MODEL_ace5b23c36684cc7b767948efa2e5738" + } + }, + "bb7d551f066841259a0881d98d9f677d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0851980655a4669b356d632bf906959", + "placeholder": "​", + "style": "IPY_MODEL_2b88ffbcb8f54670b8da513dd1b99f02", + "value": "100%" + } + }, + "74d4bcf2fd1f49efbf1b0393ab9bfb97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b378dc2ab434c8a8b636e4b0f60431d", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dc5d8f1541954a3b83695a4dd55c48eb", + "value": 5 + } + }, + "688974c6acb948d9a503736947cd9d7b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_402e5c1c13bf4b34a73b9bd332edc798", + "placeholder": "​", + "style": "IPY_MODEL_660ab68ad7a64d38aec90fb79de21009", + "value": " 5/5 [01:29<00:00, 17.90s/it]" + } + }, + "ace5b23c36684cc7b767948efa2e5738": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0851980655a4669b356d632bf906959": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b88ffbcb8f54670b8da513dd1b99f02": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b378dc2ab434c8a8b636e4b0f60431d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc5d8f1541954a3b83695a4dd55c48eb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "402e5c1c13bf4b34a73b9bd332edc798": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "660ab68ad7a64d38aec90fb79de21009": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2963dd0080b449d8f7f90573c4da188": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9db0a911e60c4271b78101ea50573155", + "IPY_MODEL_cbdaec3285264cd2a71bab7d8a8216f9", + "IPY_MODEL_0d573b771475435fa51639e5bfb8cb28" + ], + "layout": "IPY_MODEL_c08d9d15e6eb4e818aa97aa31c66ec95" + } + }, + "9db0a911e60c4271b78101ea50573155": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_08da86e0e8404cd1b02654bd24c62732", + "placeholder": "​", + "style": "IPY_MODEL_45397b429d5d47feab451defd8614c0d", + "value": "" + } + }, + "cbdaec3285264cd2a71bab7d8a8216f9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3beb124807bb4957940a8e9638f0fa5c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c49009c851e94e55b2c1f3c4c901e205", + "value": 1 + } + }, + "0d573b771475435fa51639e5bfb8cb28": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ae0360136974b5ba1b7b607de3686c1", + "placeholder": "​", + "style": "IPY_MODEL_2e9c4f7159c545efb4f667c1be12a5b0", + "value": " 313/? [00:03<00:00, 137.66it/s]" + } + }, + "c08d9d15e6eb4e818aa97aa31c66ec95": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08da86e0e8404cd1b02654bd24c62732": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "45397b429d5d47feab451defd8614c0d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3beb124807bb4957940a8e9638f0fa5c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "c49009c851e94e55b2c1f3c4c901e205": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8ae0360136974b5ba1b7b607de3686c1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e9c4f7159c545efb4f667c1be12a5b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d97f28b38c98433896ac99037182b3cd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5171e7d0c89349d1942872a271d098d5", + "IPY_MODEL_73a16e5349d341b5af0b013731ced828", + "IPY_MODEL_7e44d7a46ba4402cb164b2433ffdd3bf" + ], + "layout": "IPY_MODEL_1b5f5ad03c8b4abbbcd9e9ff4c28b149" + } + }, + "5171e7d0c89349d1942872a271d098d5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_062c9c612da0434ba794c973c5857510", + "placeholder": "​", + "style": "IPY_MODEL_04ac343c4b8e419fab2787d7972b4da1", + "value": "100%" + } + }, + "73a16e5349d341b5af0b013731ced828": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_458a4274c8b74a289184eedd1180e26c", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2b92883149594d35a1b72a9bbdd3e41a", + "value": 5 + } + }, + "7e44d7a46ba4402cb164b2433ffdd3bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f9fb380066f4175aceea26385626884", + "placeholder": "​", + "style": "IPY_MODEL_1940c92f2cd1436cb186071674146a15", + "value": " 5/5 [01:14<00:00, 15.47s/it]" + } + }, + "1b5f5ad03c8b4abbbcd9e9ff4c28b149": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "062c9c612da0434ba794c973c5857510": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04ac343c4b8e419fab2787d7972b4da1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "458a4274c8b74a289184eedd1180e26c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b92883149594d35a1b72a9bbdd3e41a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f9fb380066f4175aceea26385626884": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1940c92f2cd1436cb186071674146a15": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4aa82d89f2074e89bb514adf1f407d60": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e8de50e36e644606b76bee73e655e11e", + "IPY_MODEL_2491b725d5cf46b9ad30ba1b46c2c7a8", + "IPY_MODEL_7063a77f761f4402a0dbd434f6475939" + ], + "layout": "IPY_MODEL_6aa262b1d0284761918302feaf86796c" + } + }, + "e8de50e36e644606b76bee73e655e11e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d98b13403cf47858fc9be646fcb151d", + "placeholder": "​", + "style": "IPY_MODEL_c887d4b92fd14828ba47c71ee383932c", + "value": "100%" + } + }, + "2491b725d5cf46b9ad30ba1b46c2c7a8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_104ae0dd35bb440283deb4a98686e985", + "max": 313, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1280745dd25547799bd36c359e1ab41b", + "value": 313 + } + }, + "7063a77f761f4402a0dbd434f6475939": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb1b53c81546478985715a780717505b", + "placeholder": "​", + "style": "IPY_MODEL_5e1911efa81c48ed9c36093c74466df5", + "value": " 313/313 [00:01<00:00, 192.77it/s]" + } + }, + "6aa262b1d0284761918302feaf86796c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d98b13403cf47858fc9be646fcb151d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c887d4b92fd14828ba47c71ee383932c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "104ae0dd35bb440283deb4a98686e985": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1280745dd25547799bd36c359e1ab41b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb1b53c81546478985715a780717505b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e1911efa81c48ed9c36093c74466df5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 03. PyTorch Computer Vision Exercises\n", + "\n", + "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n", + "\n", + "They're a bunch of fun.\n", + "\n", + "You're going to get to write plenty of code!\n", + "\n", + "## Resources\n", + "\n", + "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n", + "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n", + " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n", + "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)." + ], + "metadata": { + "id": "Vex99np2wFVt" + } + }, + { + "cell_type": "code", + "source": [ + "# Check for GPU\n", + "!nvidia-smi" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GaeYzOTLwWh2", + "outputId": "da9ed536-173b-4653-b8b3-a1db937068a2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Sat Feb 22 23:56:08 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n", + "|-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 39C P8 9W / 70W | 2MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Exercises require PyTorch > 1.10.0\n", + "print(torch.__version__)\n", + "\n", + "# TODO: Setup device agnostic code\n", + "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "DNwZLMbCzJLk", + "outputId": "86cfee87-a6ad-487f-eaa5-e5af432dc160" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.5.1+cu124\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 33 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. What are 3 areas in industry where computer vision is currently being used?" + ], + "metadata": { + "id": "FSFX7tc1w-en" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "VyWRkvWGbCXj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n", + "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n", + "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n" + ], + "metadata": { + "id": "ZOnG1GHLZKMc" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find." + ], + "metadata": { + "id": "oBK-WI6YxDYa" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "d1rxD6GObCqh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n" + ], + "metadata": { + "id": "xOtfv8elZwOI" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n", + "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those." + ], + "metadata": { + "id": "XeYFEqw8xK26" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "ocvOdWKcbEKr" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n", + "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n", + "3. Randomly turns off neurons during training to prevent dependency on specific features.\n" + ], + "metadata": { + "id": "LswlbpepaAIG" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n", + "\n", + "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it." + ], + "metadata": { + "id": "DKdEEFEqxM-8" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "TqZaJIRMbFtS" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets." + ], + "metadata": { + "id": "lvf-3pODxXYI" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "# Define transform\n", + "transform = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.1307,), (0.3081,))\n", + "])\n", + "\n", + "# Load train and test datasets\n", + "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n", + "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n", + "\n", + "\n" + ], + "metadata": { + "id": "SHjeuN81bHza" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "train_data, test_data" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "R_uWK0KpFFep", + "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(Dataset MNIST\n", + " Number of datapoints: 60000\n", + " Root location: ./data\n", + " Split: Train\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ),\n", + " Dataset MNIST\n", + " Number of datapoints: 10000\n", + " Root location: ./data\n", + " Split: Test\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ))" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_data), len(test_data)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ePSUg0oGEoHF", + "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(60000, 10000)" + ] + }, + "metadata": {}, + "execution_count": 22 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Get the class names from the dataset\n", + "class_names = train_data.classes\n", + "class_names\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TN6d1nUxD_64", + "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['0 - zero',\n", + " '1 - one',\n", + " '2 - two',\n", + " '3 - three',\n", + " '4 - four',\n", + " '5 - five',\n", + " '6 - six',\n", + " '7 - seven',\n", + " '8 - eight',\n", + " '9 - nine']" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Visualize at least 5 different samples of the MNIST training dataset." + ], + "metadata": { + "id": "qxZW-uAbxe_F" + } + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Function to visualize images\n", + "def show_images(dataset, num_images=5):\n", + " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n", + " for i in range(num_images):\n", + " img, label = dataset[i]\n", + " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n", + " axes[i].set_title(f\"Label: {label}\")\n", + " axes[i].axis(\"off\")\n", + "\n", + "show_images(train_data)\n" + ], + "metadata": { + "id": "QVFsYi1PbItE", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "outputId": "ac991564-8773-4a32-b49f-273fd1284fea" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Turn the MNIST train and test datasets into dataloaders using `torch.utils.data.DataLoader`, set the `batch_size=32`." + ], + "metadata": { + "id": "JAPDzW0wxhi3" + } + }, + { + "cell_type": "code", + "source": [ + "from torch.utils.data import DataLoader\n", + "\n", + "# Define batch size\n", + "batch_size = 32\n", + "\n", + "# Create DataLoaders\n", + "train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", + "test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False)\n", + "\n", + "# Print batch details\n", + "for images, labels in train_dataloader:\n", + " print(f\"Batch size: {images.shape}, Labels: {labels.shape}\")\n", + " break # Print one batch\n" + ], + "metadata": { + "id": "ALA6MPcFbJXQ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "95559a37-fe65-4188-a636-bcca4287d28e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Batch size: torch.Size([32, 1, 28, 28]), Labels: torch.Size([32])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "train_dataloader, test_dataloader" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XHFFOphgfGZW", + "outputId": "a0dfbce4-ce4c-49c0-fe69-96cf6a4d4b36" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_dataloader), len(test_dataloader)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j8dnGKN9fqls", + "outputId": "82b4c2d4-f837-4295-8dcd-f4f796e807ef" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 8. Recreate `model_2` used in notebook 03 (the same model from the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/), also known as TinyVGG) capable of fitting on the MNIST dataset." + ], + "metadata": { + "id": "bCCVfXk5xjYS" + } + }, + { + "cell_type": "code", + "source": [ + "from torch import nn\n", + "class MNIST_model(torch.nn.Module):\n", + " \"\"\"Model capable of predicting on MNIST dataset.\n", + " \"\"\"\n", + " def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n", + " super().__init__()\n", + " self.conv_block_1 = nn.Sequential(\n", + " nn.Conv2d(in_channels=input_shape,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.conv_block_2 = nn.Sequential(\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.classifier = nn.Sequential(\n", + " nn.Flatten(),\n", + " nn.Linear(in_features=hidden_units*7*7,\n", + " out_features=output_shape)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x = self.conv_block_1(x)\n", + " # print(f\"Output shape of conv block 1: {x.shape}\")\n", + " x = self.conv_block_2(x)\n", + " # print(f\"Output shape of conv block 2: {x.shape}\")\n", + " x = self.classifier(x)\n", + " # print(f\"Output shape of classifier: {x.shape}\")\n", + " return x" + ], + "metadata": { + "id": "5IKNF22XbKYS" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "device" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "vEOGcDMleA2p", + "outputId": "0fccc8ce-fb26-47e0-e857-325a2a4ec817" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "zFhrF_r2eB8E" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "G2cEdnITd68u" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uNDTL66DeDHD", + "outputId": "aa9720f2-ce7e-4758-a857-95c7ee868e6b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Try a dummy forward pass to see what shapes our data is\n", + "dummy_x = torch.rand(size=(1, 28, 28)).unsqueeze(dim=0).to(device)\n", + "# dummy_x.shape\n", + "model(dummy_x)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "K4q5XDGGeQQk", + "outputId": "fba05e28-fcae-445d-9744-b564058f7a58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[-0.0237, 0.0819, 0.0189, 0.0228, -0.0252, 0.0080, -0.0020, -0.0176,\n", + " 0.0736, 0.0680]], device='cuda:0', grad_fn=)" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dummy_x_2 = torch.rand(size=([1, 10, 7, 7]))\n", + "dummy_x_2.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Lt9JtODAeXNE", + "outputId": "bbea492f-6ad4-49b9-8638-ccfc885dc3fd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 10, 7, 7])" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "flatten_layer = nn.Flatten()\n", + "flatten_layer(dummy_x_2).shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A9OT0ZW-eZ13", + "outputId": "32667c27-984c-4ce9-f951-4df41f3729c2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 490])" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 9. Train the model you built in exercise 8. for 5 epochs on CPU and GPU and see how long it takes on each." + ], + "metadata": { + "id": "sf_3zUr7xlhy" + } + }, + { + "cell_type": "code", + "source": [ + "%%time\n", + "from tqdm.auto import tqdm\n", + "\n", + "# Train on CPU\n", + "model_cpu = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(\"cpu\")\n", + "\n", + "# Create a loss function and optimizer\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_cpu.parameters(), lr=0.1)\n", + "\n", + "### Training loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss = 0\n", + " for batch, (X, y) in enumerate(train_dataloader):\n", + " model_cpu.train()\n", + "\n", + " # Put data on CPU\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Forward pass\n", + " y_pred = model_cpu(X)\n", + "\n", + " # Loss calculation\n", + " loss = loss_fn(y_pred, y)\n", + " train_loss += loss\n", + " # Optimizer zero grad\n", + " optimizer.zero_grad()\n", + "\n", + " # Loss backward\n", + " loss.backward()\n", + "\n", + " # Step the optimizer\n", + " optimizer.step()\n", + "\n", + " # Adjust train loss for number of batches\n", + " train_loss /= len(train_dataloader)\n", + "\n", + " ### Testing loop\n", + " test_loss_total = 0\n", + "\n", + " # Put model in eval mode\n", + " model_cpu.eval()\n", + "\n", + " # Turn on inference mode\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(test_dataloader):\n", + " # Make sure test data on CPU\n", + " X_test, y_test = X_test.to(\"cpu\"), y_test.to(\"cpu\")\n", + " test_pred = model_cpu(X_test)\n", + " test_loss = loss_fn(test_pred, y_test)\n", + "\n", + " test_loss_total += test_loss\n", + "\n", + " test_loss_total /= len(test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Loss: {train_loss:.3f} | Test loss: {test_loss_total:.3f}\")" + ], + "metadata": { + "id": "jSo6vVWFbNLD", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 170, + "referenced_widgets": [ + "13e8e56312674d3386224a2f00fd866f", + "0294fb9eb6fe4aff8d147f1f7cc1d553", + "abfa0e7b82bf486e92f9d90960284d3e", + "47b74eed37a84415a3fc42d1f19c5c4e", + "d7499f26238d4ec8a0d4ae459db82a5a", + "9d3c8abcf41f4fee8069a63c0b7e603c", + "42ac5a11f588411dae6f326c558ff1fd", + "e879e28f80d74fb4a91ba371ef73e0bc", + "c7f9038bdc08459fa2638e92d9090832", + "59125daa8589482a84193b4f52778612", + "47b099254fd7441cbcc3ab185374b22d" + ] + }, + "outputId": "d75a4a87-a629-4fd4-a671-180d8e20e320" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ] + }, + "metadata": {}, + "execution_count": 41 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Logits -> Prediction probabilities -> Prediction labels\n", + "model_pred_logits = model_gpu(test_data[0][0].unsqueeze(dim=0).to(device)) # make sure image is right shape + on right device\n", + "model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + "model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "model_pred_label\n", + "num_to_plot = 5\n", + "for i in range(num_to_plot):\n", + " # Get image and labels from the test data\n", + " img = test_data[i][0]\n", + " label = test_data[i][1]\n", + "\n", + " # Make prediction on image\n", + " model_pred_logits = model_gpu(img.unsqueeze(dim=0).to(device))\n", + " model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + " model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "\n", + " # Plot the image and prediction\n", + " plt.figure()\n", + " plt.imshow(img.squeeze(), cmap=\"gray\")\n", + " plt.title(f\"Truth: {label} | Pred: {model_pred_label.cpu().item()}\")\n", + " plt.axis(False);" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "8qlR_6njh0Kp", + "outputId": "a4e56a0e-25e8-47b7-ea34-9e59abcc9441" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 11. Plot a confusion matrix comparing your model's predictions to the truth labels." + ], + "metadata": { + "id": "qQwzqlBWxrpG" + } + }, + { + "cell_type": "code", + "source": [ + "# See if torchmetrics exists, if not, install it\n", + "try:\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " assert int(mlxtend.__version__.split(\".\")[1]) >= 19, \"mlxtend verison should be 0.19.0 or higher\"\n", + "except:\n", + " !pip install -q torchmetrics -U mlxtend # <- Note: If you're using Google Colab, this may require restarting the runtime\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " # Import mlxtend upgraded version\n", + "import mlxtend\n", + "print(mlxtend.__version__)\n", + "assert int(mlxtend.__version__.split(\".\")[1]) >= 19" + ], + "metadata": { + "id": "vSrXiT_AbQ6e", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "40248d65-99ff-43d7-af57-cabb3e8933bf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m49.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m109.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m84.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m51.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m12.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m86.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hmlxtend version: 0.23.4\n", + "0.23.4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make predictions across all test data\n", + "from tqdm.auto import tqdm\n", + "model_gpu.eval()\n", + "y_preds = []\n", + "with torch.inference_mode():\n", + " for batch, (X, y) in tqdm(enumerate(test_dataloader)):\n", + " # Make sure data on right device\n", + " X, y = X.to(device), y.to(device)\n", + " # Forward pass\n", + " y_pred_logits = model_gpu(X)\n", + " # Logits -> Pred probs -> Pred label\n", + " y_pred_labels = torch.argmax(torch.softmax(y_pred_logits, dim=1), dim=1)\n", + " # Append the labels to the preds list\n", + " y_preds.append(y_pred_labels)\n", + " y_preds=torch.cat(y_preds).cpu()\n", + "len(y_preds)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 66, + "referenced_widgets": [ + "a2963dd0080b449d8f7f90573c4da188", + "9db0a911e60c4271b78101ea50573155", + "cbdaec3285264cd2a71bab7d8a8216f9", + "0d573b771475435fa51639e5bfb8cb28", + "c08d9d15e6eb4e818aa97aa31c66ec95", + "08da86e0e8404cd1b02654bd24c62732", + "45397b429d5d47feab451defd8614c0d", + "3beb124807bb4957940a8e9638f0fa5c", + "c49009c851e94e55b2c1f3c4c901e205", + "8ae0360136974b5ba1b7b607de3686c1", + "2e9c4f7159c545efb4f667c1be12a5b0" + ] + }, + "id": "YmzNi-X_iaN7", + "outputId": "73f9d0e9-0adb-40dd-a91a-2aded6723ef1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "0it [00:00, ?it/s]" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "a2963dd0080b449d8f7f90573c4da188" + } + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "10000" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "source": [ + "test_data.targets[:10], y_preds[:10]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qQC7oh1tig9S", + "outputId": "a80a26d7-182a-4fc3-a1ea-f9edb46e8337" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]),\n", + " tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]))" + ] + }, + "metadata": {}, + "execution_count": 46 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from torchmetrics import ConfusionMatrix\n", + "from mlxtend.plotting import plot_confusion_matrix\n", + "\n", + "# Setup confusion matrix\n", + "confmat = ConfusionMatrix(task=\"multiclass\", num_classes=len(class_names))\n", + "confmat_tensor = confmat(preds=y_preds,\n", + " target=test_data.targets)\n", + "\n", + "# Plot the confusion matrix\n", + "fix, ax = plot_confusion_matrix(\n", + " conf_mat=confmat_tensor.numpy(),\n", + " class_names=class_names,\n", + " figsize=(10, 7)\n", + ")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 638 + }, + "id": "czblDny_in5U", + "outputId": "11864434-840c-4d49-d8c9-4c974f04fb55" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAosAAAKDCAYAAAByuUB6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAst9JREFUeJzs3XdUFGfbBvBr6b0pRRQERbAi1YIdiTUq0diCihiN3fDajSaWWKJpxtj1tSX62nsssQCisStGo2LsjWahLCoKO98ffm7cyCiwu8zuev3OmXPcmdmZ+/HZmb322dlBJgiCACIiIiKiQhhJXQARERER6S6GRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRJlIXQAVTqFQ4P79+7C1tYVMJpO6HCIiIjIwgiAgJycH7u7uMDISHz9kWNRR9+/fh4eHh9RlEBERkYG7c+cOKlSoILqcYVFH2draAgDMW38LmamlxNVo1q3lPaUugYiI6L2Xk50NH28PZeYQw7Coo1599SwztTS4sGhnZyd1CURERPT/3nW5G3/gQkRERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMOigbKxMMGs3nVxeUEXPFzdCwentUVw5bLK5U829il0im1fU2U7rYIqIGFGOzxc3Qv3VkRh3ejmpd2UElk4fx78fLzgYGOBRmF1cfLECalLUtvhxEPoFNkO3p7usDSVYfu2rVKXpDGG2F8A26Uvvp05Aw3qhcLZ0Rae7i7o3CkSV5KTpS5LbTxn6B9dbZdehcV58+bBy8sLFhYWqFu3Lk7oyH+iLpo/sCHCa7vj0zkJCB2xBQfO3cfOr1rB3ckKAODd938qU/95iVAoBGw9dku5jQ51K2Lp0Cb4Je4K6o7ciuYTfsO6xOtSNanINqxfhzGjhmP8hIk4euIM/P1ro33blkhPT5e6NLXk5uailn9tzJ4zT+pSNMpQ+4vt0h+JhxIwYOBgJBw+hp279yH/xQt82KYFcnNzpS5NLTxn6BddbpdMEARB6iKKYt26dejVqxcWLlyIunXrYvbs2diwYQOSk5Ph4uIidXlKz58/h5mZmdrbyc7Ohr29PSzaz4XM1LJYz7UwM0b6Lz3RZeZ+7DlzVzn/yMz2+P3sXUxee+aN56wb3Rw2lqZoO3kPAMDYSIbLC7pg6rozWHnwb/Ua8y+P1vbR6Pb+rVFYXQSHhGL2nLkAAIVCAR9vDwwcPBSjRo/V6r5Li6WpDOs2bkH7DpFSl6I2Q+0vtkt/ZWRkwNPdBfsOJqBho8ZSl6MRPGfoPinalZ2dDdcy9sjKyoKdnZ3oenozsvjDDz+gX79+iImJQfXq1bFw4UJYWVlh2bJlam23adOmkMlkb0w3b94EAGRmZqJv375wdnaGnZ0dwsPDce7cOeXzJ02ahICAACxduhTe3t6wsLAAANy+fRsdOnSAjY0N7Ozs0KVLF6SlpalVa1GZGMlgYmyEZy8KVOY/fV6A+tVc31jfxd4CrYI8sPLAFeW8wEplUL6MNRQCcPTbDri+pBu2jm+B6h4O2i5fLc+fP8fZM6cR3jxCOc/IyAjh4RE4ceyohJVRYQy1v9gu/ZadlQUAcHR0krgS+jdDfQ3qerv0Iiw+f/4cp0+fRkSE6n9iREQEjh5V7z9x8+bNSElJUU4dO3aEn58fXF1fhqrOnTsjPT0du3fvxunTpxEUFITmzZvj0aNHym1cvXoVmzZtwubNm5GUlASFQoEOHTrg0aNHSEhIwL59+3D9+nV07dpVrVqLSv4sH8eS0zD24wCUc7SEkZEM3RpVRl1fZ7g5WL2xflTTKsh5+gLbjv/zFbSXqy0AYHyXQHyzMQmdZuzDY3ke9kxuA0cb9UdOteXBgwcoKCiAi4tqKHZxdUVqaqpEVZEYQ+0vtkt/KRQKjBoRi/phDVCjZs13P4FKlaG+BnW9XSZSF1AUr/4TXwW4V1xdXXH58mW1tu3k9M8nxx9//BEHDx7E8ePHYWlpicOHD+PEiRNIT0+Hubk5AOC7777D1q1bsXHjRnz22WcAXobZVatWwdnZGQCwb98+nD9/Hjdu3ICHhwcAYNWqVahRowZOnjyJ0NDQN+rIy8tDXl6e8nF2drZa7fp0ziEsHNQQ15Z0R36BAknXH2L9kesIrFT2jXV7hVfBusRryHttJNJIJgMAzNp0Thki+89LxN+LuqJjfW/8d5/+X/xNRPRvsUMH46+/LuBA/GGpSyHSGXoxslgSiYmJsLGxUU6rV69+6/q7d+/G2LFjsW7dOvj6+gIAzp07B7lcjjJlyqhs68aNG7h27ZryuRUrVlQGRQC4dOkSPDw8lEERAKpXrw4HBwdcunSp0P3PmDED9vb2yun155bEjbQctJy4G2WjVsG3/zo0HrcDpsZGuJmWo7JeWDVX+JV3wIrXvoIGgNTHT1625W6mct7zfAVupsvhUdZGrdq0qWzZsjA2NkZ6uupX/ulpaXBzc5OoKhJjqP3Fdumn2GFDsGvXTuzdF4cKFSpIXQ4VwlBfg7reLr0Ii6/+E/99zV/aW/4TQ0JCkJSUpJzat28vuv2LFy+iW7du+Oabb9CiRQvlfLlcjnLlyqlsJykpCcnJyRg1apRyPWtrazVbCIwbNw5ZWVnK6c6dO2pvEwCe5OUjNfMpHKzNEBFQHjtP3lZZHh3uizPXHuD8rUcq889ef4hnz/Ph6/7PBa8mxjJ4OtvgdoZcI7Vpg5mZGQKDghF38IBynkKhQFzcAdSpV1/CyqgwhtpfbJd+EQQBscOGYPu2Ldjz+0F4eXtLXRKJMNTXoK63Sy++hjYzM0NwcDAOHDiAyMhIAC//Ew8cOIAhQ4YU+hxLS0v4+Pi8c9sPHjxAu3bt0KlTJ/znP/9RWRYUFITU1FSYmJjAy8uryPVWq1YNd+7cwZ07d5QjhBcvXkRmZiaqV69e6HPMzc2VX3VrQkTt8pDJgCv3s1DZzQ7Te4biyr0srIr7ZwTR1tIUHet7YdyqN29BlPP0BZb+nowJXYNw92EubmfI8Z/2tQAAm4/e0Fid2jAsdjj69YlGcHAIQkLrYO6c2XiSm4te0TFSl6YWuVyOa1evKh/fvHED55KS4OjkBE9PTwkrU4+h9hfbpT9ihw7GurVrsGHzNtjY2iqvEbO3t4elZfHuRqFLeM7QL7rcLr0IiwAwfPhwREdHIyQkBHXq1MHs2bORm5uLmBj1/hM7deoEKysrTJo0SeUiUmdnZ0RERKB+/fqIjIzErFmz4Ovri/v37+O3337DRx99hJCQkEK3GRERgVq1aiEqKgqzZ89Gfn4+Bg0ahCZNmog+R9PsrMwwJSoY5ctY47E8D1uP3cSk/51GfsE/d0rq3KASZDIZ1h8u/N6JX/xyAvkKBZYObQJLM2Oc/DsDbSbtRmbu81JpQ0l17tIVDzIyMGXyV0hLTYV/7QBs27nnjWte9c2Z06fQMqKZ8vGYUcMBAD16RmPJshUSVaU+Q+0vtkt/LF60AADQonlT1flLl6NndO/SL0hDeM7QL7rcLr25zyIAzJ07F99++y1SU1MREBCAOXPmoG7dumptU/b/P+T4txs3bsDLyws5OTkYP348Nm3ahIyMDLi5uaFx48aYMWMGPDw8MGnSJGzduhVJSUkqz799+zaGDh2KAwcOwMjICK1atcLPP/9c5E5X5z6Luk7b91kkIiKidyvqfRb1Kiy+TxgWiYiISJsM7qbcRERERFT6GBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCTKROoC6O1uLe8JOzs7qcvQKMfQIVKXoBWPT86VugQiIiKN48giEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSy+5xbOnwc/Hy842FigUVhdnDxxQuqSVDQIqoyNs/vj+u/T8PTsXLRr6q+yvEN4beyYPxh342bi6dm58Pctr7Lc0c4KP4zpjHNbvsSjoz/gyq4p+H70x7CzsVBZL7i6J3YtHIqUQ7NwP2EWts8bjFr/2pbUDiceQqfIdvD2dIelqQzbt22VuiSN0fXXYXF9O3MGGtQLhbOjLTzdXdC5UySuJCdLXZbGsL/0g6GeMwy1XYDuHlt6GxYPHTqEdu3awd3dHTKZDFu3bpW6JL2zYf06jBk1HOMnTMTRE2fg718b7du2RHp6utSlKVlbmuP8lXuInbGu0OVWlmb4I+kaJszZWujycs72KOdsj3E/bkFw5+noN/FXfBBWHQsnRr22DzNsmzcYd1Ifo3HP79A85gfInzzD9nmDYWKiO4dIbm4uavnXxuw586QuRaP04XVYXImHEjBg4GAkHD6Gnbv3If/FC3zYpgVyc3OlLk1t7C/9YajnDENtly4fWzJBEASpiyiJ3bt348iRIwgODkbHjh2xZcsWREZGSl2WxmRnZ8Pe3h5pD7NgZ2enlX00CquL4JBQzJ4zFwCgUCjg4+2BgYOHYtTosVrZJwA4hg4p0fOenp2LLv9ZjB3xf76xzLOcE5J3TUHdrjPw55V7b91Ox4hALJvWC2XCRqCgQIGg6p44sno0qrSagLtpmQCAGj7uOLXhC9RoPwnX7zwoUn2PT84tdptKytJUhnUbt6B9h8hS26e2SPU6LE0ZGRnwdHfBvoMJaNiosdTlqIX9pZ8M6ZzxOkNqlxTHVnZ2NlzL2CMr6+1ZQ3eGTYqpdevWmDp1Kj766CONbzshIQF16tSBubk5ypUrh7FjxyI/P1+5vGnTphg2bBhGjx4NJycnuLm5YdKkSSrbyMzMRN++feHs7Aw7OzuEh4fj3LlzGq+1pJ4/f46zZ04jvHmEcp6RkRHCwyNw4thRCSvTPjtbC2TnPkNBgQIAcOVmGh48liM6MgymJsawMDdF78j6uHQ9BbfuP5K4WsP2vrwOs7OyAACOjk4SV6Ie9heRduj6saW3YVFb7t27hzZt2iA0NBTnzp3DggUL8N///hdTp05VWW/lypWwtrbG8ePHMWvWLEyZMgX79u1TLu/cuTPS09Oxe/dunD59GkFBQWjevDkePdKN8PHgwQMUFBTAxcVVZb6LqytSU1Mlqkr7yjhYY1y/1li26Q/lPPmTPLTs9xO6twnF42M/4sGR7/FBWDVEDpmvDJSkHe/D61ChUGDUiFjUD2uAGjVrSl2OWthfRNqh68eWidQF6Jr58+fDw8MDc+fOhUwmQ9WqVXH//n2MGTMGX331FYyMXuZrf39/TJw4EQBQpUoVzJ07FwcOHMAHH3yAw4cP48SJE0hPT4e5uTkA4LvvvsPWrVuxceNGfPbZZ2/sNy8vD3l5ecrH2dnZpdDa94uttQW2zBmIS9dTMHXRb8r5FuamWDgxCkfPXUf0uOUwNjZCbK/m2DxnIBr2+BbP8l5IWDXpu9ihg/HXXxdwIP6w1KVQEbC/iN703ows3r59GzY2Nspp+vTpha536dIl1K9fHzKZTDmvQYMGkMvluHv3rnKev7/qr3LLlSunvAj13LlzkMvlKFOmjMo+b9y4gWvXrhW63xkzZsDe3l45eXh4qNvktypbtiyMjY2Rnp6mMj89LQ1ubm5a3bcUbKzMsX3eIOQ8eYauw5cgP/+fEcOurUPg6e6Ezyb+itMXb+PE+ZuIHrcCXuXLvPHra9IsQ38dxg4bgl27dmLvvjhUqFBB6nLUxv4i0g5dP7bem7Do7u6OpKQk5TRgwAC1tmdqaqryWCaTQaF4GUDkcjnKlSunsr+kpCQkJydj1KhRhW5v3LhxyMrKUk537txRq753MTMzQ2BQMOIOHlDOUygUiIs7gDr16mt136XN1toCOxcMwfMXBfg4dhHynuerLLeyMINCIeD133opBAGCABi99qGBNM9QX4eCICB22BBs37YFe34/CC9vb6lL0gj2F5F26Pqx9d58DW1iYgIfH593rletWjVs2rQJgiAoRxePHDkCW1vbIn/SDAoKQmpqKkxMTODl5VWk55ibmyu/si4tw2KHo1+faAQHhyAktA7mzpmNJ7m56BUdU6p1vI21pRkqezgrH3uVLwN/3/J4nP0Ed1Ifw9HOCh5ujijnYg8A8PV6eb1H2sNspD3MeRkU5w+GpYUZYsavhJ21BeysX95jMeOxHAqFgAPHLmN6bCRmj+uCBWsTYCSTYWRMC+QXFCDh1JXSb7QIuVyOa1evKh/fvHED55KS4OjkBE9PTwkrU48+vA6LK3boYKxbuwYbNm+Dja2t8poje3t7WFpaSlydethf+sNQzxmG2i5dPrb09tY5crkcV///xRIYGIgffvgBzZo1g5OaL5Z79+7B19cXMTExGDJkCJKTk9G3b18MHjxY+Yvnpk2bIiAgALNnz1Y+LzIyEg4ODlixYgUEQUDjxo2Rk5ODWbNmwdfXF/fv38dvv/2Gjz76CCEhIe+sozRunQMAC+bNxY8/fIu01FT41w7A9z/OQZ26dbW2P6B4t85pFFwFvy/9/I35v2w/hs8m/ooe7epiyZSebyyfunAXpi3aJfp8APBr8xVup7z8wVF43aoY3781qvuUg0Ih4Nzlu5g0bwdOnL9Z5Fq1feucQwnxaBnR7I35PXpGY8myFVrdt7ZJ8TrUJkvTwkekFy9djp7RvUu3GC1gf+kHQz1nGGq7gNI/top66xy9DYvx8fFo1uzNF0t0dDRWrFih1rYTEhIwatQonDt3Dk5OToiOjsbUqVNhYvJyIPZdYREAcnJyMH78eGzatAkZGRlwc3ND48aNMWPGjCJdj1haYVEKJb3Poq4rzfssEhERqcvgw6KhY1jUPwyLRESkTwz+ptxEREREpH0Mi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEmUidQH0/nl8cq7UJWiFY9vvpS5BKx7/NkLqEoiISEIcWSQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGxffcwvnz4OfjBQcbCzQKq4uTJ05IXZJG6Hq7GtQsj42TI3F9TX883TsC7er7vLHOl73CcH1NfzzaPgy/ffMxKrs7KJd5utphwX9a4NLKvni0fRj+Wv4pJvQMg6nJP4f0+B718XTviDemB9uGlUYTi0XX+6u4Fi9cgNBAf7g42cHFyQ5NGtbH3j27pS5LYwytv15hu/TDtzNnoEG9UDg72sLT3QWdO0XiSnKy1GVphK72ld6GxRkzZiA0NBS2trZwcXFBZGQkkjXwYlmxYgUcHBzUL1APbFi/DmNGDcf4CRNx9MQZ+PvXRvu2LZGeni51aWrRh3ZZW5ji/PUMxM49UOjyEV1CMahDIIb9vB+NP1+D3GcvsGN6J5ibGgMA/DycYGQkw5Cf9iHos5UYvSgefdv6Y0pMI+U2Zm88Ba9uC1Smi7ceYPMh3Tqp6kN/FVf5ChXw9fRv8Mfx0zhy7BSaNgtH544dcPGvv6QuTW2G2F8A26VPEg8lYMDAwUg4fAw7d+9D/osX+LBNC+Tm5kpdmlp0ua9kgiAIUhdREq1atUK3bt0QGhqK/Px8fPHFF7hw4QIuXrwIa2vrEm93xYoViI2NRWZmpuaKLYHs7GzY29sj7WEW7OzstLKPRmF1ERwSitlz5gIAFAoFfLw9MHDwUIwaPVYr+ywNUrXLse33JXre070j0GXSNuw4elU57/qa/piz+TRmbzwFALCzMsOtdQPx2Xd7sCGh8LD3n49D0O/D2qje+7+FLq9VyRknFvRCxIi1OHLhXpHre/zbiGK0pvgM9XX4b+4uTpj+zbfo3edTqUtRi6H2F9ulvzIyMuDp7oJ9BxPQsFFjqcspMSn6Kjs7G65l7JGV9fasobcji3v27EHv3r1Ro0YN1K5dGytWrMDt27dx+vTpEm8zPj4eMTExyMrKgkwmg0wmw6RJkzB37lzUrFlTud7WrVshk8mwcOFC5byIiAhMmDBB+XjBggWoXLkyzMzM4Ofnh19++aXEdWnD8+fPcfbMaYQ3j1DOMzIyQnh4BE4cOyphZeoxhHZ5udmjXBkbHDxzSzkv+8lznLycgrrV3EWfZ2dtjkc5z0SXx7SqhSt3HhUrKGqbIfTXuxQUFGD9urXIzc1F3Xr1pS5HLYbaX2yXfsvOygIAODo6SVxJyel6X+ltWPy3rP9/sTg5lfzFEhYWhtmzZ8POzg4pKSlISUnByJEj0aRJE1y8eBEZGRkAgISEBJQtWxbx8fEAgBcvXuDo0aNo2rQpAGDLli34/PPPMWLECFy4cAH9+/dHTEwM4uLi1GqjJj148AAFBQVwcXFVme/i6orU1FSJqlKfIbTLzenlyHh65hOV+emZT+DqVPioeSV3BwzsEIj/7vqz0OXmpsboGl4VK/de0GyxajKE/hJz4fx5lHWwgb21OYYNHoB1G7egWvXqUpelFkPtL7ZLfykUCowaEYv6YQ1Q47VBHX2j631lEGFRoVAgNjYWDRo0UBkBLC4zMzPY29tDJpPBzc0Nbm5usLGxQc2aNeHk5ISEhAQAL0cgR4wYoXx84sQJvHjxAmFhYQCA7777Dr1798agQYPg6+uL4cOHo2PHjvjuu+9E952Xl4fs7GyViago3MvYYPu0jth86AqW7z5f6DodGlSBraUZft2n/9fM6QtfPz8cP5WEQ0eOo1//gejXJxqXLl6UuiwigxI7dDD++usCVq1eK3UpBs0gwuLgwYNx4cIFrF0r/mJJTEyEjY2Nclq9enWRty+TydC4cWPEx8cjMzMTFy9exKBBg5CXl4fLly8jISEBoaGhsLKyAgBcunQJDRo0UNlGgwYNcOnSJdF9zJgxA/b29srJw8OjyPWVRNmyZWFsbIz09DSV+elpaXBzc9PqvrXJENqV+ujlRdouDlYq810crJD2SPUC7nJO1tgzqzOOXbyPwT/9LrrN3q1qYvfx62+MVkrNEPpLjJmZGSr7+CAoOBhfT5uBWv61Me/nn6QuSy2G2l9sl36KHTYEu3btxN59cahQoYLU5ahF1/tK78PikCFDsHPnTsTFvf3FEhISgqSkJOXUvn37Yu2nadOmiI+PR2JiIgIDA2FnZ6cMkAkJCWjSpIla7Rg3bhyysrKU0507d9Ta3ruYmZkhMCgYcQf/+TWuQqFAXNwB1NHj66oMoV03U7OQ8lCOZoGeynm2VmYIrVoOxy/dV85zL2ODvd92wdm/0/HZ93sh9lO1iq52aFLbEyt07CtowDD6q6gUCgXy8vKkLkMthtpfbJd+EQQBscOGYPu2Ldjz+0F4eXtLXZLadL2vTKQuoKQEQcDQoUOxZcsWxMfHw/sdLxZLS0v4+Lx5L7t/MzMzQ0FBwRvzmzRpgtjYWGzYsEF5bWLTpk2xf/9+HDlyBCNG/POL0WrVquHIkSOIjo5Wzjty5Aiqv+V6JXNzc5ibm7+zPk0aFjsc/fpEIzg4BCGhdTB3zmw8yc1Fr+iYUq1D0/ShXdYWpir3TfRys4N/JWc8znmGOxk5mLf1DMZ0r4er9zJxMzULE6MbIOWhHNv/ePmL6VdB8XZ6NsYtSYCzvaVyW2mPVUcPo1vWROojOfaevFEqbSsufeiv4vpy/Di0bNUaHh6eyMnJwbq1a3AoIR47du2VujS1GWJ/AWyXPokdOhjr1q7Bhs3bYGNrq7ymz97eHpaWlu94tu7S5b7S27A4ePBgrFmzBtu2bYOtBl8sXl5ekMvlOHDgAGrXrg0rKytYWVnB398fjo6OWLNmDXbu3AngZVgcOXIkZDKZytfOo0aNQpcuXRAYGIiIiAjs2LEDmzdvxv79+9VrtIZ17tIVDzIyMGXyV0hLTYV/7QBs27kHrq6u736yDtOHdgX5uuL3b7sqH88a0AwA8MvvF/DZ93vx/fqTsLIwxdzPP4CDjTn++Ose2o/fjLwXLz/IhAdVhE95R/iUd8S1Nf1Vtm3Z8p9b+MhkQM8WNfHLvr+gUOjmXbL0ob+KKyM9HZ/G9EJqSgrs7e1Rs5Y/duzai+YRH0hdmtoMsb8AtkufLF60AADQonlT1flLl6NndO/SL0hDdLmv9PY+izKZrND5y5cvR+/evdXa9sCBA7FhwwY8fPgQEydOxKRJkwAAkZGR+O233/D48WPY2NhAoVCgbNmy8PPzw9Gjqj9tX7BgAb777jvcuXMH3t7emDBhAnr27FnkGkrjPoukWSW9z6Ku0/Z9FomISBpFvc+i3oZFQ8ewqH8YFomISJ8Y/E25iYiIiEj7GBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCTKROoCiAzFo53DpS5BKxw7L5G6BK14vKGf1CVonEIhSF2CVhgZyaQugei9xpFFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJeq/DopeXF2bPni11GZJaOH8e/Hy84GBjgUZhdXHyxAmpS1Lb4cRD6BTZDt6e7rA0lWH7tq1Sl6S2qVMmwcrMSGUKqFlN6rLeycbCFN/2qYfkRd3waG0M4ma0R7BPWeVyawsT/NgvDFeXdMejtTE4M+dj9G35T7s8nW3wdEu/QqeOYd5SNKlY9P34Opx4CB9/1B6VvcrD2twIO147ll68eIEJX4xBaJA/nB1tUNmrPPr2iUbK/fvSFawmfe+vf/t25gw0qBcKZ0dbeLq7oHOnSFxJTpa6LLUZ4jle1/tKp8LiggUL4O/vDzs7O9jZ2aF+/frYvXu32ttdsWIFHBwc1C/QwGxYvw5jRg3H+AkTcfTEGfj710b7ti2Rnp4udWlqyc3NRS3/2pg9Z57UpWhU9eo1cP32feW0Pz5R6pLeacHgRgivXQF9fopHSOwm7E+6i98mtYW7kxUAYGZMPXwQWAExs+MRMHQD5u64gB/7haFtqCcA4O7DXHjF/KoyTfnfKeQ8fY69Z+5I2bR3MoTj6+Wx5I8ff5r7xrInT54g6exZjP1iAo4cO43/rduEv68ko3OnDhJUqj5D6K9/SzyUgAEDByPh8DHs3L0P+S9e4MM2LZCbmyt1aWoxxHO8rveVidQFvK5ChQr45ptvUKVKFQiCgJUrV6JDhw44e/YsatSoIXV5AF5+mjY1NZW6DI2YM/sHxHzaD716xwAAfp6/ELt3/4aVK5Zh1OixEldXci1btUbLVq2lLkPjjE1M4ObmJnUZRWZhZozI+t7oPON3HLmYCgCYtu4M2oR6ol+r6pi85hTqVXXFr3F/I/GvFADAsn2X8WnLqgip4oLfTt6GQiEgLfOpynbb1/XCpiM3kPssv9TbVByGcHy97Viyt7fHzt2/q8z7YfbPaNygLu7cvg0PT8/SKFFjDKG//m37b3tUHi/+7wp4urvg7JnTaNiosURVqc8Qz/G63lc6NbLYrl07tGnTBlWqVIGvry+mTZsGGxsbHDt2rMTbjI+PR0xMDLKysiCTySCTyTBp0iTl8idPnqBPnz6wtbWFp6cnFi9erFx28+ZNyGQyrFu3Dk2aNIGFhQVWr14NAFi6dCmqVasGCwsLVK1aFfPnz1fZ7507d9ClSxc4ODjAyckJHTp0wM2bN0vcDk17/vw5zp45jfDmEcp5RkZGCA+PwIljRyWsjMRcu/o3KlUsj+p+lRHTqwfu3L4tdUlvZWJkBBNjIzx7XqAy/9nzAoRVcwUAHLuchg9DKypHGhvXLIcq7vbYn3S30G0GViqLgEplsXL/Ze0Wr6b39fh6dZ6117Nvct6X/srOygIAODo6SVwJvYuu9ZVOhcXXFRQUYO3atcjNzUX9+vVLvJ2wsDDMnj0bdnZ2SElJQUpKCkaOHKlc/v333yMkJARnz57FoEGDMHDgQCT/6zqBsWPH4vPPP8elS5fQsmVLrF69Gl999RWmTZuGS5cuYfr06fjyyy+xcuVKAC9HH1u2bAlbW1skJibiyJEjsLGxQatWrfD8+fMSt0WTHjx4gIKCAri4uKrMd3F1RWpqqkRVkZjQOnWxeOlybNuxGz/9PB83b95ARHhj5OTkSF2aKPmzFzh2OQ3jugSinKMVjIxk6NbEB3V9XeDm+DIcDl/yBy7dfYxr/41C9oZPsf2r1ohd/IdyJPLfoiP8cOnOYxxL1u2vBt/H4+vZs2f4cvxYdO7aHXZ2dlKXUyzvQ38pFAqMGhGL+mENUKNmTanLobfQxb7Sqa+hAeD8+fOoX78+nj17BhsbG2zZsgXVq1cv8fbMzMxgb28PmUxW6Fd4bdq0waBBgwAAY8aMwY8//oi4uDj4+fkp14mNjUXHjh2VjydOnIjvv/9eOc/b2xsXL17EokWLEB0djXXr1kGhUGDp0qWQyWQAgOXLl8PBwQHx8fFo0aLFG3Xk5eUhLy9P+Tg7O7vEbSbD8/pXLrX8/RFapy6q+nhh08b16B3zqYSVvV2fn+KwaEgTXF8WhfwCBZKuP8D6w9cQWPnlj1wGta2BOr4u6DRtL25nyNGwuhtmfxaGlEe5iPtT9YcSFmbG6Nq4Mr5Zf1aKptBbvHjxAj0/6QpBEPDTz/Pf/QQqdbFDB+Ovvy7gQPxhqUuhd9DFvtK5sOjn54ekpCRkZWVh48aNiI6ORkJCQqGBMTExEa1b//MmumjRIkRFRRVrf/7+/sp/vwqU/76gOSQkRPnv3NxcXLt2DZ9++in69eunnJ+fnw97e3sAwLlz53D16lXY2tqqbOfZs2e4du1aoXXMmDEDkydPLlbt6ihbtiyMjY2Rnp6mMj89LU2vrot7Xzk4OMCnii+uX70qdSlvdSM1By0m7ISVuQnsrEyR+vgpfhkRjhupObAwM8bkqFB0nbkPe06//LHKhVuP4O9dBrEd/N8Iix/V94aVmQlWx/8tRVOK5X06vl4Fxdu3b2HX3gN6N6oIGH5/xQ4bgl27dmL/wUOoUKGC1OXQW+hqX+lcWDQzM4OPjw8AIDg4GCdPnsRPP/2ERYsWvbFuSEgIkpKSlI9dXV3fWOdd/v1jFZlMBoVCoTLP2tpa+W+5XA4AWLJkCerWrauynrGxsXKd4OBg5fWNr3N2di60jnHjxmH48OHKx9nZ2fDw8ChGS4rHzMwMgUHBiDt4AO07RAJ4OfQdF3cAAwYN0dp+STPkcjluXL8Gt6geUpdSJE/y8vEkLx8O1maICKyA8StPwNTYCGamxlAIgsq6BQoBRkayN7bRO8IPv528hQfZz0qr7BJ7X46vV0Hx6tW/sfv3gyhTpozUJZWIofaXIAj4z+dDsX3bFvy+Px5e3rp/u6n3la73lc6FxX9TKBQqX8++ztLSUhks38bMzAwFBQXvXK8oXF1d4e7ujuvXr4uOYgYFBWHdunVwcXEp8qdsc3NzmJuba6TGohoWOxz9+kQjODgEIaF1MHfObDzJzUWv6JhSrUPT5HI5rr024nbzxg2cS0qCo5MTPPXsF5qvjBszEm3atoOnZ0WkpNzH1CmTYGxsjM5du0td2ltFBFSATAZcuZeFyuXsMD26Lq7czcSqg8nILxBw6MJ9TI+ui6d5BbidIUejGm6IaloFY5ar/qitkpsdGlYvh8ipe0T2pHsM4fiSy+W4du21Y+nmDZw7lwQnRye4lSuHqG6dkZR0Bhu37EBBQYHy+j4nJyeYmZlJVXaJGEJ//Vvs0MFYt3YNNmzeBhtbW2X/2Nvbw9LSUuLqSs4Qz/G63lc6FRbHjRuH1q1bw9PTEzk5OVizZg3i4+Oxd+9etbbr5eUFuVyOAwcOoHbt2rCysoKVlVWJtzd58mQMGzYM9vb2aNWqFfLy8nDq1Ck8fvwYw4cPR1RUFL799lt06NABU6ZMQYUKFXDr1i1s3rwZo0eP1pmh5c5duuJBRgamTP4Kaamp8K8dgG0795RohFaXnDl9Ci0jmikfjxn1csS2R89oLFm2QqKq1HPv7j1E9/wEjx4+RFlnZ4SFNUR84lHRkWpdYW9lhik9Q1G+jDUe5eRh27EbmLj6JPILXo4m9vr+IKb0CMWK/zSDo405bmfIMWnNKSzZe0llO9HNfXHvYa7or6R1kSEcX2dOn0LrFuHKx2NHjwAARPWMxvgJE/Hbzu0AgPqhgSrP2/37QTRu0rTU6tQEQ+ivf1u8aAEAoEXzpqrzly5Hz+jepV+QhhjiOV7X+0omCP/6DkhCn376KQ4cOICUlBTY29vD398fY8aMwQcffKD2tgcOHIgNGzbg4cOHmDhxIiZNmgQvLy/ExsYiNjZWuV5AQAAiIyMxadIk3Lx5E97e3jh79iwCAgJUtrdmzRp8++23uHjxIqytrVGrVi3Exsbio48+AgCkpqZizJgx2LVrF3JyclC+fHk0b94c3333XZFGG7Ozs2Fvb4+0h1l6eQ3Q+0iHDiWNcuqyVOoStOLxhn7vXknPKBSG+Ros7LIEIlJfdnY2XMvYIyvr7VlDp8Ii/YNhUf8Y6qHEsKg/GBaJqDiKGhZ19j6LRERERCQ9hkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIlInUBRAZCplMJnUJWvF4Qz+pS9CKMt2XS12Cxj38X4zUJRAZLEEQpC5B44raJo4sEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWHzN1q1b4ePjA2NjY8TGxkpdTqlYOH8e/Hy84GBjgUZhdXHyxAmpS9IIQ2vXtzNnoEG9UDg72sLT3QWdO0XiSnKy1GVpjL71l42FCWb1roNL8zvjweqeODC1LYIql1Uuz90QU+gU276mch1HGzMsG9YYKSujcG/FJ5g/sAGsLUykaE6x6Vt/Fce3s76BpakMI4fHSl2Kxhhafx1OPIROke3g7ekOS1MZtm/bKnVJGjF1yiRYmRmpTAE1q0ldFgCgSGem7du3F3mD7du3L3ExxfXNN99g3Lhx+PzzzzF79my1t9e/f3/ExMRg2LBhsLW1Vb9AHbdh/TqMGTUcP89biNA6dTF3zmy0b9sS5/5KhouLi9TllZghtivxUAIGDByM4JBQ5OfnY+KXX+DDNi1w9s+LsLa2lro8tehjf80b2BDVPRzQ9+dDSHn8BN0aVcbOr1oi+D9bkPLoCSr1W6uyfouA8pg/sCG2HrupnLdsWBO4OVqi3dd7YWpihIWDGmFu/zDE/HSolFtTPPrYX0V16uRJ/HfJItSq5S91KRpjiP2Vm5uLWv610at3H3Tr3FHqcjSqevUa2Llnn/KxiYlufICUCYIgvGslI6OiDUDKZDIUFBSoXVRRnDx5El26dIGdnR2aNWumdliUy+WwtbXFwYMH0axZM80UKeLFixcwNTV96zrZ2dmwt7dH2sMs2NnZaaWORmF1ERwSitlz5gIAFAoFfLw9MHDwUIwaPVYr+ywNhtqu12VkZMDT3QX7DiagYaPGUpejFqn6q0z35SV6noWZMdJW9UCXWQew98xd5fzDM9vh97P3MGXtmTees3ZUOGwtTdF2yl4AgF95e5yZ3RENx2zH2esPAQAfBJTH5nEfoMqAdUh9/LREtT38X0yJnlcchnp8yeVy1K8ThJ9+no9vpk+Ff+0AfPfDbKnLUpuh9tcrlqYyrNu4Be07RGp9X0WIS2qZOmUSdmzfhuOnzmp1P6/Lzs6GW1kHZGW9PWsUKQUqFIoiTaUVFOVyOaKiorBkyRI4Ojqqvb34+HjlSGJ4eDhkMhni4+MBAJs2bUKNGjVgbm4OLy8vfP/99yrPlclk2Lp1q8o8BwcHrFixAgBw8+ZNyGQyrFu3Dk2aNIGFhQVWr16tds3qev78Oc6eOY3w5hHKeUZGRggPj8CJY0clrEw9htquf8vOygIAODo6SVyJevSxv0yMZDAxNkLec9Xz3dPnBahf9c2RGhd7C7QK8sDKg38r59X1dcFjeZ4yKALAwT/vQyEICK3irL3i1aSP/VVUsUMHo1Xrtipt03eG3F+G6trVv1GpYnlU96uMmF49cOf2balLAqDmNYvPnj3TVB3FMnjwYLRt2xYREZo5qMPCwpD8/9d/bdq0CSkpKQgLC8Pp06fRpUsXdOvWDefPn8ekSZPw5ZdfKoNgcYwdOxaff/45Ll26hJYtW76xPC8vD9nZ2SqTNj148AAFBQVwcXFVme/i6orU1FSt7lubDLVdr1MoFBg1Ihb1wxqgRs2a736CDtPH/pI/y8ex5HSM+bg23BwtYWQkQ7dGlVDX1xlujlZvrB/VxAc5z15g2/FbynkuDpbIyFY9fxYoBDyW58HVwVLrbSgpfeyvoli/bi2Szp7B19NmSF2KRhlqfxmq0Dp1sXjpcmzbsRs//TwfN2/eQER4Y+Tk5EhdWtGuWXxdQUEBpk+fjoULFyItLQ1XrlxBpUqV8OWXX8LLywuffvqpNupUWrt2Lc6cOYOTJ09qbJtmZmbKazecnJzg5uYGAPjhhx/QvHlzfPnllwAAX19fXLx4Ed9++y169+5drH3ExsaiY0fxaytmzJiByZMnl6wB9F6JHToYf/11AQfiD0tdynur78+HsGBQQ1xb3A35BQok3XiIDYdvIKBSmTfW7RleBesSryHvRel880LFc+fOHYwa/jl27t4HCwsLqcuh91jLVq2V/67l74/QOnVR1ccLmzauR+8Y7Wardyn2yOK0adOwYsUKzJo1C2ZmZsr5NWvWxNKlSzVa3L/duXMHn3/+OVavXl3kgzoxMRE2NjbKqThfAV+6dAkNGjRQmdegQQP8/fffxf7KPSQk5K3Lx40bh6ysLOV0586dYm2/uMqWLQtjY2Okp6epzE9PS1OGZX1kqO16JXbYEOzatRN798WhQoUKUpejNn3trxtpOWg1cTece/wCvwHr0WTcTpiYGOFmuuoIQFhVV/iVd8DKA1dU5qdnPoWzneo5zNhIBkcbc6Rllux6xdKgr/31NmfPnEZ6ejrq1wmCjYUJbCxMkHgoAfPnzoGNhUmpXV6lDYbYX+8TBwcH+FTxxfWrV6UupfhhcdWqVVi8eDGioqJgbGysnF+7dm1cvnxZo8X92+nTLw/qoKAgmJiYwMTEBAkJCZgzZw5MTAo/qENCQpCUlKScNP1rbZlM9sZFry9evHhjvXf9YtXc3Bx2dnYqkzaZmZkhMCgYcQcPKOcpFArExR1AnXr1tbpvbTLUdgmCgNhhQ7B92xbs+f0gvLy9pS5JI/S9v57k5SM18ykcrM0QUdsdO0+qXl8U3bwKzlx7gPO3HqvMP34lHY425iojkU1rloORTIaTf2eUSu0loe/9VZhm4c1x6ux5HD+VpJyCgkPQrXsUjp9KUnmf0zeG2F/vE7lcjhvXr8GtXDmpSyn+19D37t2Dj4/PG/MVCkWhIUmTmjdvjvPnz6vMi4mJQdWqVTFmzJhCD2pLS8tC6y2KatWq4ciRIyrzjhw5Al9fX+W+nJ2dkZKSolz+999/48mTJyXaX2kbFjsc/fpEIzg4BCGhdTB3zmw8yc1Fr2jt/6JSmwyxXbFDB2Pd2jXYsHkbbGxtldcb2dvbw9JSd69xKwp97K+I2u6QyWS4cj8Lld3sMK1nCK7cy8Ivcf/8iMXW0hQf1fPCuFVvXjKTfC8Lv5+9i3n9G2DYkj9gamyE7z+th41/XC/xL6FLiz7219vY2tq+ce2vtbU1nMqU0ftrggHD6y/gZYi69tpo280bN3AuKQmOTk7w9PSUsDL1jBszEm3atoOnZ0WkpNzH1CmTYGxsjM5du0tdWvHDYvXq1ZGYmIiKFSuqzN+4cSMCAwM1VlhhbG1tUbOQg7pMmTJvzNeEESNGIDQ0FF9//TW6du2Ko0ePYu7cuZg/f75ynfDwcMydOxf169dHQUEBxowZ887b4uiKzl264kFGBqZM/gppqanwrx2AbTv3wNXV9d1P1mGG2K7FixYAAFo0b6o6f+ly9IzuXfoFaZA+9pedlRkmfxKM8mWs8Vieh63Hb2Hy/04jv+Cfbxk+buANmUyGDUeuF7qNPnMS8MOn9fDbV62gEARsO3YTI5cfL60mlJg+9tf7zBD768zpU2gZ8c8t7saMGg4A6NEzGkuWrZCoKvXdu3sP0T0/waOHD1HW2RlhYQ0Rn3gUzs7S3yGhSPdZfN22bdsQHR2NcePGYcqUKZg8eTKSk5OxatUq7Ny5Ex988IG2ai1U06ZNERAQoPZ9FjMzM+Ho6Ii4uDg0bdpUOX/Tpk346quv8Pfff6NcuXIYOnQoRo4cqVx+//59xMTE4MiRI3B3d8dPP/2E7t27Y/bs2ejduzdu3rwJb29vnD17FgEBAUWupzTus0j0PivpfRZ1WWncZ5HofaXt+yxKoaj3WSx2WARe/mhkypQpOHfuHORyOYKCgvDVV1+hRYsWahVN/2BYJNIuhkUiKo73OSyW6O/INGrUCPv27Xv3ikRERESk10r8RwdPnTqFS5cuAXh5HWNwcLDGiiIiIiIi3VDssHj37l10794dR44cgYODA4CX1/uFhYVh7dq1BnHvNyIiIiJ6qdj3Wezbty9evHiBS5cu4dGjR3j06BEuXboEhUKBvn37aqNGIiIiIpJIsUcWExIS8Mcff8DPz085z8/PDz///DMaNWqk0eKIiIiISFrFHln08PAo9ObbBQUFcHd310hRRERERKQbih0Wv/32WwwdOhSnTp1Szjt16hQ+//xzfPfddxotjoiIiIikVaSvoR0dHSGTyZSPc3NzUbduXZiYvHx6fn4+TExM0KdPH0RGRmqlUCIiIiIqfUUKi+r+dRQiIiIi0k9FCovR0dHaroOIiIiIdFCJb8oNAM+ePcPz589V5vFP0xEREREZjmL/wCU3NxdDhgyBi4sLrK2t4ejoqDIRERERkeEodlgcPXo0Dh48iAULFsDc3BxLly7F5MmT4e7ujlWrVmmjRiIiIiKSSLG/ht6xYwdWrVqFpk2bIiYmBo0aNYKPjw8qVqyI1atXIyoqSht1EhEREZEEij2y+OjRI1SqVAnAy+sTHz16BABo2LAhDh06pNnqiIiIiEhSxQ6LlSpVwo0bNwAAVatWxfr16wG8HHF0cHDQaHFEREREJK1ih8WYmBicO3cOADB27FjMmzcPFhYW+M9//oNRo0ZpvEAiIiIikk6xr1n8z3/+o/x3REQELl++jNOnT8PHxwf+/v4aLY6IiIiIpKXWfRYBoGLFiqhYsaImaiEiIiIiHVOksDhnzpwib3DYsGElLoaIiIiIdItMEAThXSt5e3sXbWMyGa5fv652UQRkZ2fD3t4eaQ+z+FdxiKhIKg/bInUJWnH1p0ipS9AKmUwmdQn0nsvOzoZrGXtkZb09axRpZPHVr5+JiIiI6P1S7F9DExEREdH7g2GRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREokoUFhMTE9GjRw/Ur18f9+7dAwD88ssvOHz4sEaLIyIiIiJpFTssbtq0CS1btoSlpSXOnj2LvLw8AEBWVhamT5+u8QKJiIiISDrFDotTp07FwoULsWTJEpiamirnN2jQAGfOnNFocUREREQkrWKHxeTkZDRu3PiN+fb29sjMzNRETURERESkI4odFt3c3HD16tU35h8+fBiVKlXSSFFEREREpBuKHRb79euHzz//HMePH4dMJsP9+/exevVqjBw5EgMHDtRGjUREREQkkSL9bejXjR07FgqFAs2bN8eTJ0/QuHFjmJubY+TIkRg6dKg2aiQiIiIiiRQ7LMpkMowfPx6jRo3C1atXIZfLUb16ddjY2GijPiIiIiKSULHD4itmZmaoXr26JmshIiIiIh1T7LDYrFkzyGQy0eUHDx5UqyAiIiIi0h3FDosBAQEqj1+8eIGkpCRcuHAB0dHRmqqLiIiIiHRAscPijz/+WOj8SZMmQS6Xq10QEREREemOEv1t6ML06NEDy5Yt09TmiIiIiEgHaCwsHj16FBYWFpraHBERERHpgGKHxY4dO6pMH330EerVq4eYmBj0799fGzWSFnw7cwYa1AuFs6MtPN1d0LlTJK4kJ0tdlsYsnD8Pfj5ecLCxQKOwujh54oTUJWmEIbbrcOIhdIpsB29Pd1iayrB921apS9IYfeovIxkw6sNqODqlBa7Obo8jkz9AbGs/lXWszI0xtYs/Tk1rhauz2yPuy+bo2chLZR1zEyNM61obF2a1xZUf2mFxvzooa2teii0pvqlTJsHKzEhlCqhZTeqy1Gaox5YhtkvX35OLHRbt7e1VJicnJzRt2hS7du3CxIkTtVFjqdu6dSt8fHxgbGyM2NhYrFixAg4ODlKXpVGJhxIwYOBgJBw+hp279yH/xQt82KYFcnNzpS5NbRvWr8OYUcMxfsJEHD1xBv7+tdG+bUukp6dLXZpaDLVdubm5qOVfG7PnzJO6FI3St/4a3MIXvRp7Y8L6c2g6ZT+mb/0LAz+ogj5N//kzrhM71ULT6q4YuuIUmk7Zj6UHr2Fql9r4oJabcp1JH9fCB7Xc0H/pcXT6MRFu9pZY+lldKZpULNWr18D12/eV0/74RKlLUpuhHluG2C5df0+WCYIgFHXlgoICHDlyBLVq1YKjo6M263qnSZMmYfLkySrz/Pz8cPnyZbW37erqipiYGAwbNgy2trYwMTFBTk4OXFxc1N52UWVnZ8Pe3h5pD7NgZ2en9f1lZGTA090F+w4moGGjxlrfnzY1CquL4JBQzJ4zFwCgUCjg4+2BgYOHYtTosRJXV3KG2q7XWZrKsG7jFrTvECl1KWqTor8qD9tS4ueuHFgfGTnPMPLXs8p5i/vVwbMXBRi24jQA4MCE5thx+i5m7/5nxGP32KaI+ysNs3Zcgq2FCf6c1RZDlp/Eb2fvv6zJ1QaHJn6AdrPicebm4xLVdvWnyBK3qyimTpmEHdu34fips+9cV5Pedhs6TTOkY+t1htqu0npPzs7OhmsZe2RlvT1rFGtk0djYGC1atEBmZqa69WlEjRo1kJKSopwOHz6s9jblcjnS09PRsmVLuLu7w9bWFpaWlqUaFKWQnZUFAHB0dJK4EvU8f/4cZ8+cRnjzCOU8IyMjhIdH4MSxoxJWph5DbZeh0sf+OnX9IRr6OaOSy8u/xlW9vB3qVC6DuL/SVNb5wL8c3OxfXp8e5lsWlVxskHDp5Wipv6cDzEyMkHg5Q/mca2ly3H34BMGVdPvccu3q36hUsTyq+1VGTK8euHP7ttQl0XtM196Ti/01dM2aNXH9+nVt1FJsJiYmcHNzU05ly5ZVa3vx8fGwtbUFAISHh0MmkyE+Pl7la+grV65AJpO9MYL5448/onLlysrHFy5cQOvWrWFjYwNXV1f07NkTDx48UKs+bVEoFBg1Ihb1wxqgRs2aUpejlgcPHqCgoAAuLq4q811cXZGamipRVeoz1HYZKn3sr7m/X8G2U/eQ8FUEbv7cAXvHhWNp3DVsOXlXuc6X6//E3yk5OD2jNW7+3AG/Dg7D+HXncPzqQwCAs50F8l4UIPvpC5VtZ+Q8g7Od7v4AMrROXSxeuhzbduzGTz/Px82bNxAR3hg5OTlSl0bvIV18Ty52WJw6dSpGjhyJnTt3IiUlBdnZ2SpTafr777/h7u6OSpUqISoqCrfV/CQYFhaG5P+/oHTTpk1ISUlBWFiYyjq+vr4ICQnB6tWrVeavXr0an3zyCQAgMzMT4eHhCAwMxKlTp7Bnzx6kpaWhS5cuovvOy8uT7P8yduhg/PXXBaxavbbU9klEuqVdUHl0rFMBg5efRKsZcYhddRoDmldB57qeynVimlZCkLcjei84itbfxGHK5guY1rU2Gvk5S1i5+lq2ao2OH3dGLX9/fNCiJbZs/w1ZmZnYtHG91KXRe0gX35OLfVPuNm3aAADat2+vcr2FIAiQyWQoKCjQXHVvUbduXaxYsQJ+fn5ISUnB5MmT0ahRI1y4cEE5OlhcZmZmyq+bnZyc4ObmVuh6UVFRmDt3Lr7++msAL0cbT58+jV9//RUAMHfuXAQGBmL69OnK5yxbtgweHh64cuUKfH1939jmjBkz3rgGszTEDhuCXbt2Yv/BQ6hQoUKp71/TypYtC2NjY6Snp6nMT09LE+1PfWCo7TJU+thfX3asibl7r2D76XsAgMv3s1HByQpDWvpiw/HbsDA1wtj2NdB38TEcuPCyXZfuZaNGBXv0j6iCxOQMZGQ/g7mpMewsTVVGF51tLZCR/UySdpWEg4MDfKr44vrVq1KXQu8ZXX1PLvbIYlxcnHI6ePCgcnr1uLS0bt0anTt3hr+/P1q2bIldu3YhMzMT69cX/kkwMTERNjY2yunfI4PF0a1bN9y8eRPHjh0D8HJUMSgoCFWrVgUAnDt3DnFxcSr7e7Xs2rVrhW5z3LhxyMrKUk537twpcX1FIQgCYocNwfZtW7Dn94Pw8vbW6v5Ki5mZGQKDghF38IBynkKhQFzcAdSpV1/CytRjqO0yVPrYX5amJvj3zx0LBAFG/z8oYGJsBDMTIygUqusoFAKM/v+d5M/bmXier0DD10YaK7vYoEIZK5y+/kib5WuUXC7HjevX4FaunNSl0HtC19+Tiz2y6O3tDQ8Pjzd+xSUIgtYDzts4ODjA19cXV0U+CYaEhCApKUn52NXVtdD1isLNzQ3h4eFYs2YN6tWrhzVr1mDgwIHK5XK5HO3atcPMmTPfeG45kZOPubk5zM1L715ksUMHY93aNdiweRtsbG2V11HZ29vD0tKy1OrQhmGxw9GvTzSCg0MQEloHc+fMxpPcXPSKjpG6NLUYarvkcjmuvXbc3rxxA+eSkuDo5ARPT8+3PFO36Vt/7TufgmGt/HDv8RMk389BTQ97fBbug7VHbwEA5M/y8ceVDEzoWBPPXhTg7qMnqF+lLDrV9cSUTecBADnP8rH2j5uY2KkWMp88R87TfEzt6o9T1x+W+JfQpWHcmJFo07YdPD0rIiXlPqZOmQRjY2N07tpd6tLUYqjHliG2S9ffk0sUFlNSUt74dfCjR4/g7e1dal9D/5tcLse1a9fQs2fPQpdbWlrCx8dHY/uLiorC6NGj0b17d1y/fh3dunVTLgsKCsKmTZvg5eUFE5Ni/xeXisWLFgAAWjRvqjp/6XL0jO5d+gVpUOcuXfEgIwNTJn+FtNRU+NcOwLade9T6gKALDLVdZ06fQsuIZsrHY0YNBwD06BmNJctWSFSV+vStvyas/xOj21XD9K4BKGNrjrSsp/j18A38uOufH/MNWnYS4zrUwM8xIXCwMsO9R08wa/tFrEq8oVxn0sbzUAjA4n51YW5ihPhL6fhibZIELSq6e3fvIbrnJ3j08CHKOjsjLKwh4hOPwtlZv6/FNNRjyxDbpevvycW6zyLw8vYPaWlpbxxEt27dQvXq1UvtBpIjR45Eu3btULFiRdy/fx8TJ05EUlISLl68qNYBnpmZCUdHR8TFxaFp06YAgBUrViA2NlbllkE5OTlwdXWFr68vypYti/379yuX3b9/HwEBAWjSpAlGjx4NJycnXL16FWvXrsXSpUthbGz8zjpK+z6LRKT/1LnPoi7T9n0WpVKa91kkKkxR77NY5GGv4cNfJneZTIYvv/wSVlZWymUFBQU4fvw4AgICSl5xMd29exfdu3fHw4cP4ezsjIYNG+LYsWOl9knQ1tYW7dq1w/r167Fs2TKVZe7u7jhy5AjGjBmDFi1aIC8vDxUrVkSrVq1gZKSxP8dNREREpHVFHlls1uzlkG9CQgLq168PMzMz5TIzMzN4eXlh5MiRqFKlinYqfc9wZJGIiosji/qFI4skNY2PLMbFxQEAYmJi8NNPPzHAEBEREb0Hiv3ri+XLl2ujDiIiIiLSQbyAjoiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKBOpCyAiIs24NucjqUvQCrfoX6UuQStSV/aQugSiIuHIIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEgDg21nfwNJUhpHDY6UuRW2HEw+hU2Q7eHu6w9JUhu3btkpdksYsnD8Pfj5ecLCxQKOwujh54oTUJWmEobbrFUM5vvT12LKxMMGMHsE4/1MkUpZ3w96JLRFYqUyh6/7Qpw4yV/fAwFZVC11uZmKExOltkLm6B2pVdNRm2RpjyMeXoRxbr+hqXzEsasDNmzchk8mQlJQkdSklcurkSfx3ySLUquUvdSkakZubi1r+tTF7zjypS9GoDevXYcyo4Rg/YSKOnjgDf//aaN+2JdLT06UuTS2G2q5XDOn40tdja06/emhaqxz6L/gDYWN3Iu58CraOa45yjpYq630Y4oFQn7K4/+iJ6LamdA9CyuOn2i5ZYwz5+DKkYwvQ7b4yyLB479499OjRA2XKlIGlpSVq1aqFU6dOaW1/Hh4eSElJQc2aNbW2D22Ry+WIiY7C/IVL4OCoH5+S36Vlq9aYNGUqOkR+JHUpGjVn9g+I+bQfevWOQbXq1fHz/IWwtLLCyhXLpC5NLYbaLsDwji99PLYsTI3RPtQTE/93Fn9cTseNNDm+2fwnbqTloE+Er3K9co6WmBkdgn7zjiC/QFHotiJqu6NZrXL4cs2Z0ipfbYZ6fBnasQXodl8ZXFh8/PgxGjRoAFNTU+zevRsXL17E999/D0ctvpiMjY3h5uYGExMTre1DW2KHDkar1m0R3jxC6lLoLZ4/f46zZ06r9JORkRHCwyNw4thRCStTj6G26xUeX9IzMZbBxNgIz14UqMx/+rwA9X1dAAAyGbBoYAP8vPMiLt/LKnQ7znYW+KlvXfRfcARP8/K1XrcmGPLxZWjHlq73lcGFxZkzZ8LDwwPLly9HnTp14O3tjRYtWqBy5cpqbffx48eIioqCs7MzLC0tUaVKFSxfvhzAm19DT5kyBe7u7nj48KHy+W3btkWzZs2gUBT+iVUK69etRdLZM/h62gypS6F3ePDgAQoKCuDi4qoy38XVFampqRJVpT5DbRfA40tXyJ/l4/iVDIyOrAU3B0sYyWTo0sAbdaqUhavDy6+hY9vVQL5CgYV7k0W3M39AfSw/8DeSbjwqrdLVZqjHlyEeW7reVwYXFrdv346QkBB07twZLi4uCAwMxJIlS9Te7pdffomLFy9i9+7duHTpEhYsWICyZcsWuu748ePh5eWFvn37AgDmzZuHP/74AytXroSRUeH/5Xl5ecjOzlaZtOnOnTsYNfxzLF+1GhYWFlrdF9H7hseXbum/4AhkMuDyvE5IX9kd/Vv6YeMft6AQBNT2csKAllUxaKH46E3/ln6wsTDFD9v+KsWqqTA8tqShf9+bvsP169exYMECDB8+HF988QVOnjyJYcOGwczMDNHR0SXe7u3btxEYGIiQkBAAgJeXl+i6xsbG+PXXXxEQEICxY8dizpw5WLp0KTw9PUWfM2PGDEyePLnE9RXX2TOnkZ6ejvp1gpTzCgoKcDjxEBbOn4us3DwYGxuXWj30dmXLloWxsTHS09NU5qenpcHNzU2iqtRnqO3i8aVbbqbL0XbqPliZG8PW0gxpmU+xbGhD3EyXI6yqC5ztLHBhzj/XYZoYG2FqVBAGtqoK/9itaFzdDXWqlEX6yu4q2437ujU2HLmBgYuk/5qwMIZ4fBnqsaXrfWVwYVGhUCAkJATTp08HAAQGBuLChQtYuHBhoWHx9u3bqF69uvLxF198gS+++OKN9QYOHIhOnTrhzJkzaNGiBSIjIxEWFiZaR6VKlfDdd9+hf//+6Nq1Kz755JO31j1u3DgMHz5c+Tg7OxseHh7vbG9JNQtvjlNnz6vM+6xvDPz8qmLEqDF6ebAZMjMzMwQGBSPu4AG07xAJ4OVrPS7uAAYMGiJtcWow1Hbx+NJNT/IK8CTvKeytzNC8lju++t8ZbD95G/EXUlTW2zSmOdYdvo7Vh64DAMasOompG5KUy90crbBlbHP0+TkRp649hK4yxOPLUI8tXe8rgwuL5cqVUwl/AFCtWjVs2rSp0PXd3d1Vbnnj5ORU6HqtW7fGrVu3sGvXLuzbtw/NmzfH4MGD8d1334nWcujQIRgbG+PmzZvIz89/6w9gzM3NYW5u/paWaZatrS1q/OvX29bW1nAqU+aN+fpGLpfj2tWrysc3b9zAuaQkODo5vXV0V9cNix2Ofn2iERwcgpDQOpg7Zzae5OaiV3SM1KWpxRDbZajHl74eW+G1ykEmA66mZMPb1RZffxKEKylZWH3oGvILBDyWP1dZP79AgfSsZ7ia8vJyoLsPVW+lk/vs5Q9cbqTL33qbHV1gaMeXoR5bgG73lcGFxQYNGiA5WfUi5StXrqBixYqFrm9iYgIfH58ibdvZ2RnR0dGIjo5Go0aNMGrUKNGwuG7dOmzevBnx8fHo0qULvv7661L9mvl9dub0KbSMaKZ8PGbUyxHbHj2jsWTZComqUl/nLl3xICMDUyZ/hbTUVPjXDsC2nXvg6ur67ifrMENtlyHS12PLzsoUE7sGwt3JCo/lz7H95G1MXZ+E/AJB6tK0jseX/tDlvpIJgmBQR8vJkycRFhaGyZMno0uXLjhx4gT69euHxYsXIyoqqsTb/eqrrxAcHIwaNWogLy8PY8eORXp6Oo4fP46bN2/C29sbZ8+eRUBAAO7evQt/f39MnjwZQ4cOxd69e/Hhhx8iMTER9erVK9L+srOzYW9vj7SHWbCzsytx3URE+s4t+lepS9CK1JU9pC6B3nPZ2dlwLWOPrKy3Zw2D+zV0aGgotmzZgv/973+oWbMmvv76a8yePVutoAi8vJ5g3Lhx8Pf3R+PGjWFsbIy1a9e+sZ4gCOjduzfq1KmDIUNeXmfQsmVLDBw4ED169IBcLlerDiIiIqLSZHAji4aCI4tERC9xZJFIO97bkUUiIiIi0hyGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEiUidQF0PtHEASpS9AKhWE2C8ZGMqlLoPdc6soeUpegFY6dFkpdglY83jRA6hK0whDfu4raJo4sEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMPie27h/Hnw8/GCg40FGoXVxckTJ6QuSW337t1Dn+ieqOBWFk52VggN9Mfp06ekLqtYDiceQueP2sPHqzxszI2wY9tWleX9+8bAxtxIZYr8sLU0xarh25kz0KBeKJwdbeHp7oLOnSJxJTlZ6rLUtnjhAoQG+sPFyQ4uTnZo0rA+9u7ZLXVZGmOI5w1A/9plY2mKbz8NQ/KSKDxa3xdxMyMR7OOsXO5ib4nFw5rh+vKeeLj+U2yb2AaVy9m/sZ26fq7Y/XU7PFj3KdL+1wf7preHhZlxaTalWA4nHkKnyHbw9nSHpakM2/91ftRXU6dMgpWZkcoUULOa1GUBYFh8r21Yvw5jRg3H+AkTcfTEGfj710b7ti2Rnp4udWkl9vjxYzRv2hAmpqbYsmMXzpz7CzNmfQdHB0epSyuWJ7m5qOnvjx9+miu6zgctWuHarfvKafkva0qxQs1IPJSAAQMHI+HwMezcvQ/5L17gwzYtkJubK3VpailfoQK+nv4N/jh+GkeOnULTZuHo3LEDLv71l9Slqc0QzxuAfrZrwZAmCA+ogD4/HkTIsPXYf/YufpvyIdydrAEA679oCW83W3Setgf1/rMRt9Pl2DXlQ1iZmyi3UdfPFdsmtsGBpDtoNHIzGo7chIW//QWFQpCqWe+Um5uLWv61MXvOPKlL0bjq1Wvg+u37yml/fKLUJQEAZIIgSPaK8PLywq1bt96YP2jQIMybZ3gvguLIzs6Gvb090h5mwc7OTiv7aBRWF8EhoZg952UgUSgU8PH2wMDBQzFq9Fit7BMAtPmS+/KLsTh69A/sjzuktX2I0da51cbcCP9bvxntOkQq5/XvG4OszEys3bhFOzt9jbGRTOv7eCUjIwOe7i7YdzABDRs1LrX9lgZ3FydM/+Zb9O7zqdSlqEWq84a2SdEux04LS/xcCzNjZKz9FJ2n7cGe07eV84983wm/n7mN1XFXcH5BdwQNWYdLdx4DAGQy4OaKaEz89ThW7LsMAEiY9REOJN3FlDUn1WvMax5vGqCxbb2LpakM6zZuQfvXzo/aou24NHXKJOzYvg3HT53V6n5el52dDbeyDsjKenvWkHRk8eTJk0hJSVFO+/btAwB07txZyrLeC8+fP8fZM6cR3jxCOc/IyAjh4RE4ceyohJWp57edOxAUHIyobl1Qsbwr6oUGYdl/l0hdllYkHoqHVwVXBNasis+HDMTDhw+lLklt2VlZAABHRyeJK9GcgoICrF+3Frm5uahbr77U5ajFUM8b+tguE2MjmBgb4dmLApX5z57nI6xaOZibvvwa+fXlggA8zy9AWLVyAABnewvU8XNFRtZTxM2MxM2VvfD7tPYIq+ZWeg0hFdeu/o1KFcujul9lxPTqgTu3b7/7SaVA0rDo7OwMNzc35bRz505UrlwZTZo0UWu7t27dQrt27eDo6Ahra2vUqFEDu3btUi6/cOECWrduDRsbG7i6uqJnz5548OABAGDx4sVwd3eHQqFQ2WaHDh3Qp08f5eNt27YhKCgIFhYWqFSpEiZPnoz8/HzlcplMhqVLl+Kjjz6ClZUVqlSpgu3bt6vVLk168OABCgoK4OLiqjLfxdUVqampElWlvhs3rmPJooWo7OODbTv3oF//ARj5n8/x66qVUpemUREtWmLxf1di5579mDLtGxxOPISO7dugoKDg3U/WUQqFAqNGxKJ+WAPUqFlT6nLUduH8eZR1sIG9tTmGDR6AdRu3oFr16lKXpRZDPW/oY7vkT1/g2OVUjOsSjHJOVjAykqFbkyqo6+cKNycrJN/NxO30HHzdsy4crM1gamKEER0DUKGsDdycrAAA3q4vR5LGdwvBst8vocOk35B0/QF2fd2u0GsbSbtC69TF4qXLsW3Hbvz083zcvHkDEeGNkZOTI3VpunPN4vPnz/Hrr7+iT58+kMnU+9pr8ODByMvLw6FDh3D+/HnMnDkTNjY2AIDMzEyEh4cjMDAQp06dwp49e5CWloYuXboAeDmq+fDhQ8TFxSm39+jRI+zZswdRUVEAgMTERPTq1Quff/45Ll68iEWLFmHFihWYNm2aSh2TJ09Gly5d8Oeff6JNmzaIiorCo0ePCq05Ly8P2dnZKhMVn0KhQEBgEKZMnY6AwEB82vczxHzaF0uXLJK6NI3q3KUb2rZrj5o1a6Fdh0hs3LIDp0+dxKGEeKlLK7HYoYPx118XsGr1WqlL0QhfPz8cP5WEQ0eOo1//gejXJxqXLl6UuiwyIH1+PAiZDLi+vBeyNvbD4A9rYX3iVSgUAvILFOj2zV74uNsjZU0fPFrfF41ruWPPqdvK6xGN/v8Sk//uvYhfDiTj3I2HGP3fP3DlXiaiI/ykbNp7qWWr1uj4cWfU8vfHBy1aYsv235CVmYlNG9dLXRpM3r1K6di6dSsyMzPRu3dvtbd1+/ZtdOrUCbVq1QIAVKpUSbls7ty5CAwMxPTp05Xzli1bBg8PD1y5cgW+vr5o3bo11qxZg+bNmwMANm7ciLJly6JZs2YAXobAsWPHIjo6Wrn9r7/+GqNHj8bEiROV2+3duze6d+8OAJg+fTrmzJmDEydOoFWrVm/UPGPGDEyePFntthdV2bJlYWxsjPT0NJX56WlpcHPT368g3MqVQ9Vqqr8e86taDVu3bJaootLhXakSypQti+vXrqJZeHOpyym22GFDsGvXTuw/eAgVKlSQuhyNMDMzQ2UfHwBAUHAwTp86iXk//4S5C/T3g4uhnjf0tV03UrPRYvx2WJmbwM7KDKmPn+CXURG4kfZysOHstQeo95+NsLMyg5mJER5kP8Ohbz/C6asZAICUR08AQHlN4yvJdx/Dw9m2dBtDb3BwcIBPFV9cv3pV6lJ0Z2Txv//9L1q3bg13d3fRdRITE2FjY6OcVq9eXeh6w4YNw9SpU9GgQQNMnDgRf/75p3LZuXPnEBcXp7KdqlWrAgCuXbsGAIiKisKmTZuQl5cHAFi9ejW6desGIyMj5TamTJmiso1+/fohJSUFT548Ue7L399f+W9ra2vY2dmJ/rJu3LhxyMrKUk537twpyn9biZmZmSEwKBhxBw8o5ykUCsTFHUAdPb6uqn79Bvj7yhWVeVf/vgJPz4oSVVQ67t29i0cPH8LNrZzUpRSLIAiIHTYE27dtwZ7fD8LL21vqkrRGoVAozyn6ylDPG/rerid5+Uh9/AQO1maICPDAzuM3VZZnP3mOB9nPULmcPYIqOyuX30rPwf2HufAt76Cyvo+7A26nS//V5/tOLpfjxvVrcCsn/XldJ0YWb926hf3792Pz5reP/oSEhCApKUn52NXVtdD1+vbti5YtW+K3337D77//jhkzZuD777/H0KFDIZfL0a5dO8ycOfON55X7/w5p164dBEHAb7/9htDQUCQmJuLHH39UrieXyzF58mR07NjxjW1YWFgo/21qaqqyTCaTvXEt5Cvm5uYwNzcXb7wWDIsdjn59ohEcHIKQ0DqYO2c2nuTmold0TKnWoUlDPo9FeOMGmPXNdHT6uAtOnTyBZUuXYO58/RrNkcvluH7tn0+Tt27ewJ/nkuDo6ARHJyfMmDoZHT7qBFdXN1y/fg1ffjEGlSv7IKJFSwmrLr7YoYOxbu0abNi8DTa2tsrrw+zt7WFpaSlxdSX35fhxaNmqNTw8PJGTk4N1a9fgUEI8duzaK3VpajPE8wagn+2KCKwAGWS4ci8TlcvZY3rverhyLxOrDry8V2nHsErIyH6GOxk5qFmxDL7r2wA7jt/EgaS7ym38uCUJE7qH4PzNhzh3/QF6hPvBr7wDPpn5u1TNeie5XI5rr4223bxxA+eSkuDo5ARPT08JK1PPuDEj0aZtO3h6VkRKyn1MnTIJxsbG6Ny1u9Sl6UZYXL58OVxcXNC2bdu3rmdpaQmf//9a5108PDwwYMAADBgwAOPGjcOSJUswdOhQBAUFYdOmTfDy8oKJSeHNt7CwQMeOHbF69WpcvXoVfn5+CAoKUi4PCgpCcnJykWvRVZ27dMWDjAxMmfwV0lJT4V87ANt27hEN4fogJCQUazdsxsQJX2DGtK/h5eWNWd//iG6fREldWrGcOX0KbVqEKx+PHT0CABDVMxqzf56PC+fPY/Wvq5CVmYly7u4Ib/4Bvpz0dal/4FDX4kULAAAtmjdVnb90OXpG9y79gjQkIz0dn8b0QmpKCuzt7VGzlj927NqL5hEfSF2a2gzxvAHoZ7vsrcwxpWcdlC9rg0c5z7Dt6A1M/PUE8gteDkq4OVlh5qdhcLG3ROrjJ1gddwUz1p9W2cbcHedhYWaMWZ+GwdHGHOdvPsSHE3fiRqruXjd/5vQptIxopnw8ZtRwAECPntFYsmyFRFWp797de4ju+QkePXyIss7OCAtriPjEo3B2dn73k7VM0vssAi+H+r29vdG9e3d88803GtlmbGwsWrduDV9fXzx+/BiDBg1CxYoVsW7dOty/fx8BAQFo0qQJRo8eDScnJ1y9ehVr167F0qVLYWz88nYD+/fvx4cffggvLy/06NEDEyZMUG5/7969+PDDDzFhwgR8/PHHMDIywrlz53DhwgVMnToVwMtRxC1btiAyMlL5PAcHB8yePbtI12WWxn0WpSLxS05rdPgetmopzfssEr1P1LnPoi4rzfssliZDfO/Si/ssAi9D2e3bt1VuS6OugoICDB48GNWqVUOrVq3g6+uL+fPnAwDc3d1x5MgRFBQUoEWLFqhVqxZiY2Ph4OCgvCYRAMLDw+Hk5ITk5GR88sknKttv2bIldu7cid9//x2hoaGoV68efvzxR1SsaNjXxREREdH7R/KRRSocRxb1D0cWiag4OLKoXwzxvUtvRhaJiIiISHcxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiTKQugN4/MplM6hK0wtgwm0VEWvJ40wCpS9AK56iVUpegFRmro6UuQeOK+n7MkUUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWHxPfTtzBhrUC4Wzoy083V3QuVMkriQnS12WxiycPw9+Pl5wsLFAo7C6OHnihNQladS3s76BpakMI4fHSl2KRhhafxnq8XU48RA6RbaDt6c7LE1l2L5tq9QlaQTbpVtsLEzwTXQo/prbCem/RGH/lNYIqlxGZR2/8vZYNyocd5d3R+rKTxA/vS0qlLFWLv+pXz2c+6kj0n+Jwo0lXbF2ZDP4utuVdlOKTVfPhQyLr2natCliY2OL9RyZTIatW7dqpR5tSjyUgAEDByPh8DHs3L0P+S9e4MM2LZCbmyt1aWrbsH4dxowajvETJuLoiTPw96+N9m1bIj09XerSNOLUyZP475JFqFXLX+pSNMIQ+8tQj6/c3FzU8q+N2XPmSV2KRrFdumVu/zCE13LHZ/MOo97I7Tjw531sn9AC5RytAADerrb4fXIrXLmfhTaT96L+6B2YtelPPHtRoNxG0vWHGLTwCEKGb0Xk9H0v36vHfwAjmUyqZr2TLp8LZYIgCFIX8bqCggJMmjQJv/76K1JTU+Hu7o7evXtjwoQJkGm5kx89egRTU1PY2toW+TkymQxbtmxBZGRkocvj4+PRrFkzPH78GA4ODkXebnZ2Nuzt7ZH2MAt2dtr/NJSRkQFPdxfsO5iAho0aa31/2tQorC6CQ0Ixe85cAIBCoYCPtwcGDh6KUaPHSlydeuRyOerXCcJPP8/HN9Onwr92AL77YbbUZanFkPvrFUM6vl6xNJVh3cYtaN8hUupSNIrtUp9z1MoSP9fC1BgpKz9Bt28PYu/Ze8r5h2Z8iH1J9/D1urNY/nljvMhX4LN5h4u83Rqejjj2bXv4D9uMG2k5JaotY3V0iZ5XVFKcC7Ozs+Faxh5ZWW/PGjo3sjhz5kwsWLAAc+fOxaVLlzBz5kzMmjULP//8s9b37eTkVKygaEiys7IAAI6OThJXop7nz5/j7JnTCG8eoZxnZGSE8PAInDh2VMLKNCN26GC0at1WpX36zND76xVDOb6ItM3EWAYTYyOVUUIAePY8H/X9XCCTAS0DK+BqSja2fBGB64u74ODUNvgwxEN0m1bmJujR1Ac30nJw94Fuju7r+rlQ58LiH3/8gQ4dOqBt27bw8vLCxx9/jBYtWuCEBr63v3DhAlq3bg0bGxu4urqiZ8+eePDggXL5v7+GTklJQdu2bWFpaQlvb2+sWbMGXl5emD17tsp2Hzx4gI8++ghWVlaoUqUKtm/fDgC4efMmmjVrBgBwdHSETCZD79691W6HpikUCowaEYv6YQ1Qo2ZNqctRy4MHD1BQUAAXF1eV+S6urkhNTZWoKs1Yv24tks6ewdfTZkhdisYYcn+9YkjHF5G2yZ/l43hyOsZ0rA03R0sYyWTo2rAS6vg6w83REs52FrC1NMXwDjWxP+k+Okzbh50nb2P1iGZoUE31PNK3hR9SVn6CtFVRaBFQHh2m7cOLAoVELXs7XT8X6lxYDAsLw4EDB3DlyhUAwLlz53D48GG0bt1are1mZmYiPDwcgYGBOHXqFPbs2YO0tDR06dJF9Dm9evXC/fv3ER8fj02bNmHx4sWFXjswefJkdOnSBX/++SfatGmDqKgoPHr0CB4eHti0aRMAIDk5GSkpKfjpp58K3VdeXh6ys7NVptISO3Qw/vrrAlatXltq+6TiuXPnDkYN/xzLV62GhYWF1OVQMfD4IiqefvMOQyYD/l7YBQ9X98CA1tWw4cgNKAQBRkYvL0f77dQdzNt1EedvPcYP2y5gz5m7+PQDP5XtrE+8joZjdqDVpD24mpKNlbFNYG6qc7FHL5hIXcC/jR07FtnZ2ahatSqMjY1RUFCAadOmISoqSq3tzp07F4GBgZg+fbpy3rJly+Dh4YErV67A19dXZf3Lly9j//79OHnyJEJCQgAAS5cuRZUqVd7Ydu/evdG9e3cAwPTp0zFnzhycOHECrVq1gpPTy6+dXFxc3nrN4owZMzB58mS12lgSscOGYNeundh/8BAqVKhQ6vvXtLJly8LY2Bjp6Wkq89PT0uDm5iZRVeo7e+Y00tPTUb9OkHJeQUEBDicewsL5c5GVmwdjY2MJKywZQ+2vVwzt+CIqDTfSctB68l5YmZvA1tIUaZlPseLzxriZJsfD7Dy8yFfg8r0sleck38tE/aqqo3LZT18g++kLXEvNwYkrGbizrBvahVbExj9ulGZzikTXz4U6F7HXr1+P1atXY82aNThz5gxWrlyJ7777DitXFn7B7O3bt2FjY6OcXg+Drzt37hzi4uJU1q1atSoA4Nq1a2+sn5ycDBMTEwQF/fPm7OPjA0dHxzfW9ff/51ep1tbWsLOzK/avl8aNG4esrCzldOfOnWI9v7gEQUDssCHYvm0L9vx+EF7e3lrdX2kxMzNDYFAw4g4eUM5TKBSIizuAOvXqS1iZepqFN8eps+dx/FSScgoKDkG37lE4fipJL4MiYLj9ZajHF1FpepKXj7TMp3CwNkPz2uXx26nbeFGgwJlrD1ClnOqPMXzK2eN2hlx0WzLZyx+k6urIoq6fC3VuZHHUqFEYO3YsunXrBgCoVasWbt26hRkzZiA6+s1fIrm7uyMpKUn5+NVI3r/J5XK0a9cOM2fOfGNZuXLl1KrZ1NRU5bFMJoNCUbzrIszNzWFubq5WHcURO3Qw1q1dgw2bt8HG1lZ5TYS9vT0sLS1LrQ5tGBY7HP36RCM4OAQhoXUwd85sPMnNRa/oGKlLKzFbW9s3rneztraGU5kyen8dnCH2l6EeX3K5HNeuXlU+vnnjBs4lJcHRyQmenp4SVqYetku3NK/tDhmAv+9no5KbLab2CMHf97PwS/zLtvy04y+siG2MPy6l4dBfqYgIKI/WwRXQZvJeAICXiw06hXnhwLn7eJCdh/JlrDC8Qy08e56v8gtrXaPL50KdC4tPnjyBkZFq8jc2NhYNXyYmJvDx8XnndoOCgrBp0yZ4eXnBxOTdzfbz80N+fj7Onj2L4OBgAMDVq1fx+PHjIrTiH2ZmZgBefmWoSxYvWgAAaNG8qer8pcvRM7p36RekQZ27dMWDjAxMmfwV0lJT4V87ANt27oGrq+u7n0ylzhD7y1CPrzOnT6FlRDPl4zGjhgMAevSMxpJlKySqSn1sl26xszTFpO7BKF/GCo/ledh2/DamrD2D/IKXd/rbcfI2Ypccw/DIWpgVUwd/389Gjx/icTT55Td6z14UoH5VVwxqXR0ONmZIz3yGI5fTEPHlbjzIfiZl095Kl8+FOnefxd69e2P//v1YtGgRatSogbNnz+Kzzz5Dnz59Ch0VLKr79+8jICAATZo0wejRo+Hk5ISrV69i7dq1WLp0KYyNjdG0aVMEBAQof+38wQcf4NGjR1iwYAFMTU0xYsQIHDt2DDNmzMDnn38OoPD7LDo4OGD27Nno3bs37t27Bw8PDyxfvhxt2rSBpaUlbGxs3llvad9nkYiISBPUuc+iLtP2fRaloLf3Wfz555/x8ccfY9CgQahWrRpGjhyJ/v374+uvv1Zru+7u7jhy5AgKCgrQokUL1KpVC7GxsXBwcHhjJPOVVatWwdXVFY0bN8ZHH32Efv36wdbWtli/Ri1fvjwmT56MsWPHwtXVFUOGDFGrHURERESlSedGFnXZ3bt34eHhgf3796N58+Za3RdHFomISB9xZFF/FHVkUeeuWdQlBw8ehFwuR61atZCSkoLRo0fDy8sLjRsbxp/rIiIiInoXhsW3ePHiBb744gtcv34dtra2CAsLw+rVq9/49TMRERGRoWJYfIuWLVuiZcuWUpdBREREJBmd+4ELEREREekOhkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSgTqQsgIpKCQiFIXYLGyWRSV6AdMgNtmCAY3msQADJWR0tdglY4dVsmdQkaJ7x4WqT1OLJIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDIvvqcULFyA00B8uTnZwcbJDk4b1sXfPbqnLUpuhtuvbmTPQoF4onB1t4enugs6dInElOVnqsjRm4fx58PPxgoONBRqF1cXJEyekLkltOTk5GDUiFlWreKGMvRXCmzTA6VMnpS5LLVOnTIKVmZHKFFCzmtRlqe1w4iF0imwHb093WJrKsH3bVqlL0ghD7S99PM/bWJhgVu+6uLygCx6u7oWD09oiuHJZ5fInG/sUOsW2r6lcx6ecHdaPaY7byz5B6qoe2P91WzSu4VYq9TMsFsGkSZMQEBAgdRkaVb5CBXw9/Rv8cfw0jhw7habNwtG5Ywdc/OsvqUtTi6G2K/FQAgYMHIyEw8ewc/c+5L94gQ/btEBubq7Upaltw/p1GDNqOMZPmIijJ87A37822rdtifT0dKlLU8vgAf0Qd2A/li5bhROn/0TziA/wYesPcP/ePalLU0v16jVw/fZ95bQ/PlHqktSWm5uLWv61MXvOPKlL0ThD7C99PM/PH9gQ4bXd8emcBISO2IID5+5j51et4O5kBQDw7vs/lan/vEQoFAK2Hrul3MamcR/AxMgIbSbvRoPR23H+1iNsGvcBXB0stV6/TBAEQet70YCcnBx8+eWX2LJlC9LT0xEYGIiffvoJoaGhWt+3XC5HXl4eypQpo/V9vZKdnQ17e3ukPcyCnZ1dqezT3cUJ07/5Fr37fFoq+ysthtiujIwMeLq7YN/BBDRs1FjqctTSKKwugkNCMXvOXACAQqGAj7cHBg4eilGjx2ptvwqF9k59T58+hWsZO6zfuBWt2rRVzm9QLwQtWrbCxMlTtbJfmUwrm1WaOmUSdmzfhuOnzmp3R/8i03bDXmNpKsO6jVvQvkOk1vel7bff96G/XimN87xTt2Ulep6FmTHSf+mJLjP3Y8+Zu8r5R2a2x+9n72Ly2jNvPGfd6OawsTRF28l7AABlbM1xZ3kUIr78DX9cSgPwcrQy/ddeaDt5D+LO3y9RbcKLp3i2fQiyst6eNfRmZLFv377Yt28ffvnlF5w/fx4tWrRAREQE7pXCp3QbG5tSDYqlraCgAOvXrUVubi7q1qsvdTkaY6jtAoDsrCwAgKOjk8SVqOf58+c4e+Y0wptHKOcZGRkhPDwCJ44dlbAy9eTn56OgoADmFhYq8y0tLXH0jyMSVaUZ167+jUoVy6O6X2XE9OqBO7dvS10SvYWh95c+nOdNjGQwMTbCsxcFKvOfPi9A/Wqub6zvYm+BVkEeWHnginLew5w8JN/LRFQTH1iZm8DYSIZPW1RFWuZTnL3+QOtt0Iuw+PTpU2zatAmzZs1C48aN4ePjg0mTJsHHxwcLFixQa9vx8fGQyWQ4cOAAQkJCYGVlhbCwMCS/dj3Yv7+G7t27NyIjI/Hdd9+hXLlyKFOmDAYPHowXL14o18nLy8PIkSNRvnx5WFtbo27duoiPj1erVk27cP48yjrYwN7aHMMGD8C6jVtQrXp1qctSm6G26xWFQoFRI2JRP6wBatSs+e4n6LAHDx6goKAALi6qJ0wXV1ekpqZKVJX6bG1tUbdefcycMRUp9++joKAA/1vzK44fO4rUlBSpyyux0Dp1sXjpcmzbsRs//TwfN2/eQER4Y+Tk5EhdGhXCkPtLn87z8mf5OJachrEfB6CcoyWMjGTo1qgy6vo6w83B6o31o5pWQc7TF9h2/JbK/A8n70Ft7zJI/6UnHv8vGsM+rInIaXuRmftc623Qi7D46lO6RSGf0g8fPqyRfYwfPx7ff/89Tp06BRMTE/Tp0+et68fFxeHatWuIi4vDypUrsWLFCqxYsUK5fMiQITh69CjWrl2LP//8E507d0arVq3w999/F7q9vLw8ZGdnq0za5uvnh+OnknDoyHH06z8Q/fpE49LFi1rfr7YZarteiR06GH/9dQGrVq+VuhR6i6XLVkEQBPh4V4CjrQUWzPsZnbt2h5GRXpx2C9WyVWt0/Lgzavn744MWLbFl+2/IyszEpo3rpS6NCmHI/aVv5/lP5xyCDMC1Jd2R+b9oDGpTHeuPXIeikEsReoVXwbrEa8j710jkj/3qIyPrKSK+/A2Nx+7AjhO3sHHsB3ArhWsW9eKsZWtri/r16+Prr7/G/f//lP7rr7/i6NGjSNHQp/Rp06ahSZMmqF69OsaOHYs//vgDz549E13f0dERc+fORdWqVfHhhx+ibdu2OHDgAADg9u3bWL58OTZs2IBGjRqhcuXKGDlyJBo2bIjly5cXur0ZM2bA3t5eOXl4eGikXW9jZmaGyj4+CAoOxtfTZqCWf23M+/knre9X2wy1XQAQO2wIdu3aib374lChQgWpy1Fb2bJlYWxsjPT0NJX56WlpcHMrnV/5aUulypWxd3880h/lIPnabRw6chz5L17Ay7uS1KVpjIODA3yq+OL61atSl0JFYEj9pW/n+RtpOWg5cTfKRq2Cb/91aDxuB0yNjXAzTXWUN6yaK/zKO2DFa19BA0DTWuXQOsgDvX6Mx7HkdCTdeIjYpUfx9Hk+oppW0Xr9ehEWAeCXX36BIAgoX748zM3NMWfOHHTvLv4p/fbt27CxsVFO06dPf+v2/f39lf8uV64cALz115g1atSAsbGxynNerX/+/HkUFBTA19dXpYaEhARcu3at0O2NGzcOWVlZyunOnTtvrVcbFAoF8vLySn2/2mYI7RIEAbHDhmD7ti3Y8/tBeHl7S12SRpiZmSEwKBhxBw8o5ykUCsTFHUAdHb3+qLisra1Rrlw5PH78GPv37cWH7dpLXZLGyOVy3Lh+DW7/f84k3WbI/aUv5/kneflIzXwKB2szRASUx86TqteQRof74sy1Bzh/65HKfCszEwB4YyRSoQBK48sKE+3vQjMqV66MhIQE5ObmIjs7G+XKlUPXrl1RqVLhn9Ld3d2RlJSkfOzk9PYfApiamir//eqXXAqFokjrv3rOq/XlcjmMjY1x+vRplUAJvPyxTGHMzc1hbm7+1ho16cvx49CyVWt4eHgiJycH69auwaGEeOzYtbfUatAGQ21X7NDBWLd2DTZs3gYbW1vl9Xz29vawtNT+VxDaNCx2OPr1iUZwcAhCQutg7pzZeJKbi17RMVKXppZ9v++FIAjw9fXDtWtXMX7caPj6VUVPPW7XuDEj0aZtO3h6VkRKyn1MnTIJxsbG6Ny1u9SlqUUul+Paa6NtN2/cwLmkJDg6OcHT01PCytRjqP2lj+f5iNrlIZMBV+5nobKbHab3DMWVe1lYFffPCKKtpSk61vfCuFVv3mf2+JV0PM59jiVDGmPGhiQ8fZ6PmAg/eLnYYM/pu2+sr2l6ExZfsba2hrW1NR4/foy9e/di1qxZha5nYmICHx+fUq7upcDAQBQUFCA9PR2NGjWSpIZ3yUhPx6cxvZCakgJ7e3vUrOWPHbv2onnEB1KXphZDbdfiRS9/yNWieVPV+UuXo2d079IvSIM6d+mKBxkZmDL5K6SlpsK/dgC27dwDV9c3fyWoT7KzszBxwhe4d+8uHJ2cEBnZEROnTHvjg6Y+uXf3HqJ7foJHDx+irLMzwsIaIj7xKJydnaUuTS1nTp9Cy4hmysdjRg0HAPToGY0ly1ZIVJX6DLW/9PE8b2dlhilRwShfxhqP5XnYeuwmJv3vNPIL/hkp7NygEmQyGdYfvv7G8x/m5CFy2l5M7B6MXZNawdTYCJfuZKLLrANvjEJqg97cZ3Hv3pef0v38/HD16lWMGjUKFhYWSExMVOvkGx8fj2bNmuHx48dwcHAAACQlJSEwMBA3btyAl5cXJk2ahK1btypHKnv37o3MzExs3bpVuZ3Y2FgkJSUpf/Hco0cPHDlyBN9//z0CAwORkZGBAwcOwN/fH23btsW7SHGfRaL3iTbvsygVCW5vVyqkuG9fadCTt99iM9T+Kul9FnWZwd1nMSsrC4MHD0bVqlXRq1cvNGzYEHv37tXZT+nLly9Hr169MGLECPj5+SEyMhInT57U6680iIiI6P2jNyOL7xuOLBJpF0cW9YehjlQZ6tuvofYXRxaJiIiIiArBsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISJSJ1AVQ4QRBAADkZGdLXAmRYVIoBKlL0DiZTOoKtENmoA17dZ43NAbbXy+eSl2Cxr1q07teiwyLOionJwcA4OPtIXElREREZMhycnJgb28vulwmGOpHGz2nUChw//592Nraav1TWnZ2Njw8PHDnzh3Y2dlpdV+lie3SH4bYJoDt0jdsl35hu9QnCAJycnLg7u4OIyPxKxM5sqijjIyMUKFChVLdp52dnUEdcK+wXfrDENsEsF36hu3SL2yXet42ovgKf+BCRERERKIYFomIiIhIFMMiwdzcHBMnToS5ubnUpWgU26U/DLFNANulb9gu/cJ2lR7+wIWIiIiIRHFkkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomItOTV7wez+Tfe9QZ/86k/FAqF1CW8NxgWiYi0RCaTYdOmTZgwYQLS0tKkLkdrDOFN+1VIvH37tsSVaJchheFXf57u8uXLEldi+BgW32OvThoXL15EYmIidu3aZRAnEkNoQ2FetSslJQXJycnIzMzE8+fPJa5KPa/adOHCBSQmJmLz5s0GFTxu3bqFYcOGoVatWnB1dZW4KvW9atepU6ewatUqfP/997h+/fpb/6asvpDJZDh79izatm2Lhw8fGtTr8M8//8TOnTtx/PhxyGQyiatS3/r16zFv3jwAwPDhwzFy5EjI5XKJq9IMnX3/Eui9pFAoBEEQhA0bNgjlypUTfHx8BHt7eyEoKEjYt2+fkJeXJ3GFJfOqXXFxccKUKVOErl27Crt27RJu3rwpcWXqedWuzZs3C9WrVxdcXV2FWrVqCVFRUUJ6errE1ZXMqzZt2rRJ8PDwEOrUqSO4ubkJ9erVE7Zv365crq8OHDggLFiwQBg0aJDw4sULqcvRmI0bNwrlypUTGjduLDRv3lwwNTUVli9fLjx79kzq0tR28OBBwcrKSkhJSZG6FI3ZvHmzYGFhIVStWlWQyWTCyJEj9fp8+OLFC2Hq1KmCTCYTWrZsKdjY2AhJSUlSl6URr855iYmJwvz584Xhw4cLR48eFR4/fixtYYIgMCy+x44fPy7Y29sLK1asEK5duybcv39faNq0qVCjRg3h4MGDUpdXYps2bRLs7e2FXr16Cb179xbc3d2Fnj17CqmpqVKXppa4uDjBwsJC+PHHH4UjR44I33//vdCwYUOhTp06QkZGhtTllcgff/whODo6CitWrBAEQRAuX74syGQyYdGiRRJXpr4+ffoIMplMqFmzpk6c7DXh7Nmzgqurq/Df//5XEARBePTokSCTyYSpU6dKXFnJ/PsDSU5OjlClShXhxIkTgiAIehvyX7UrJSVFaNiwobB06VLhwYMHwsaNGwVbW1thwIABwvXr1yWuUj1BQUGCTCYTxo8fLwiCIBQUFEhckWa8ev/q0aOH0LBhQyEoKEjo27evkJubK2ldDIvvkX+fGBcvXiwEBwcLcrlc5UBr1KiRULdu3dIuTyOuXr0q+Pr6CkuWLBEEQRDy8/MFMzMzYcKECRJXVnIKhUIoKCgQxowZI0RFRaksO3jwoNCgQQOhb9++evnGtmjRIqFjx46CILwMipUrVxb69u2rXP7kyROpSiu2V8dXTk6Oct7o0aMFY2NjYe3atVKVpVG7du0SPvzwQ0EQBOHKlSuCh4eH8NlnnymXZ2dnC4Lw5rlGl/z7Q+P+/fuFmTNnCtu3bxfOnTsnlC9fXliwYIFE1WnO3r17hdGjRws9e/YUMjMzlfO3b98u2NvbC/3799fbwJifny8MHjxYGDRokCCTyYS5c+cql+lzaLx48aLg7e0tLF26VBCEl2Hf1NRUmDhxorSFCQyL75VXJ/CEhARBEAThxx9/FLy8vJTLX31yuXLlimBvby8kJiaWfpFqunjxohAcHCwoFArh8uXLQoUKFVTCx59//ik8ffpUwgpLrm/fvkKdOnXemD9lyhQhMDBQL4PV559/LvTo0UMoKCgQKlSoIHz22WfKZb/88oswZ84cKcsstri4OCEyMlLla7G+ffsK1tbWwq5duySsrGT+HfrmzZsnBAQECDdv3hQqVqwofPbZZ8o35y1btgi9e/eWfATkbWbPni3Url1beZlNVlaW8NlnnwlVqlQRKleuLHh7ewv29vaCu7u7MGjQIGHevHnC8ePHhaNHj0pcefEtXbpUkMlkQtmyZYXk5GRBEP7pz507dwply5YVPvnkE+HGjRsSVlk0r38Q/veH4ldfSc+bN09l/qlTp0qlNk1KSEgQAgMDBUF4+T5csWJFoV+/fsrlSUlJkl0ixrD4ntm3b58gk8mEAwcOCFevXhUcHR3fGHU7d+6cULlyZeHcuXMSVVlyCQkJgo+Pj5CcnCxUqlRJ6Nevn/LN7OjRo0JMTIzw999/S1xl0Z05c0YZMhYtWiQEBgYKCQkJKifMXbt2CZUqVRLu3LkjVZkllpCQIHh7ews2NjbC4MGDVZYNGjRI+OSTTwS5XC5RdcV3+vRpwcrKSujSpYvw559/Kuf36dNHsLGxEXbv3i1hdSUTHx8vDBkyRBAEQbh165bQpEkTwdraWujdu7cgCP+M5IwaNUpo27atTn/lnpmZqQxO/35dFRQUCCdPnhS6desmBAQECO3atRPq1asnODg4CJUrV9bLy1jWrFkjyGQyYfTo0cLDhw9Vlm3evFmoWLGiTl+fee3aNSE/P1/5eM6cOcKAAQOEAQMGCLdv3xYUCoWQn58vTJs27f/au/O4nNL/f+DvUxElkbTRYmlFqyRLZTI01oQh1BhMimyJpgz5MExjyzJjvh5jbCNlK4wwY8uSiEZZSmUrJUK0adF9v35/9LvPdKts07jvk+v5j0f3fcr73Pc513mf67yv64KioiLWrFmD/Px8DB8+vNZTGHlWM4l3dnbGkydPYGBgIHX9OnPmDAIDA2XWzrNk8RNy9+5drF+/nu+tKS8vx+rVq9G5c2eEhIQAAJ4+fYrQ0FB07txZrhsRoP5HXf369QPHcfzFTCIoKAi9e/fG48ePP0Z4/4pYLEZJSQn69++PCRMmAKiuD7OysoKzszNOnTrFN6KzZ8+Gg4MDCgsLZRnyG0m+q1u3buGvv/7C2bNncf/+fYhEIkyZMgUdOnTAzp07AVQ/JgwJCUHbtm2Rmpoqy7Dfi2Qfr169Ch0dHXh4eOD69ev8+z4+PuA4Dn/99ZesQnxvIpEIa9euha2tLXJyclBWVobg4GAYGxtjwYIFKC0tRUZGBoKDg6GhoYEbN27IOuR3cuHCBXTo0IGPt2Zb8uOPP8LW1pa/IcvMzJT7QWSS+G/fvo3ExEQkJCSgsrISQHW5Ecdx+O6771BQUCD1e/J8IzZjxgzo6enh77//BlDdg9iiRQt89dVX0NbWhqmpKY4ePYqqqipUVVVh9erV4DgOFhYW6NKlC7//8qqu69fz58+hpaUFjuMQEBAg9V5AQABcXV1rJf0fC0sWPxG3bt2ChYUF9PT0pOqnHj58iPDwcGhoaEBXVxddunSBjo4OkpKSZBjt20lOtLNnzyIkJAQbNmzge3JOnTqFHj16oHfv3khLS8Px48cxb948qKmpyX1v6esNyMmTJ6GkpITIyEgAQH5+PmxtbWFtbQ0zMzMMHjwY6urquHr1qgyifTc1Rz0bGhrC0tISDg4O6Nq1K65cuYJbt27By8sLrVu3hrGxMezt7WFoaMhfJOTdzZs38fDhQwD/7GtSUhK0tLQwfPhwqYRxxowZSEtLk0mcH+rWrVvQ0tLC2rVrAVTXJc6YMQOWlpZo1qwZbG1tYWZmJpjvC6juYbS0tISFhQV/QyL57uLj42FiYlIrsZJXNc8vc3NzdO7cGQ4ODrCxscHTp08BAFu2bAHHcQgNDeVfq/m78qi0tBTm5uawtrZGQkICxo0bJ1UO8Nlnn8HMzAxHjhzhE/urV6/i0KFD/I20vNZxSz73CxcuYOXKldi3bx9u3boFoLqmVEdHBxMnTsSDBw9w+fJlzJ8/H+rq6lJtycfGksVPRFpaGvz8/NCyZctaj50rKyuRm5uLzZs348CBA4KZViE2NhZKSkoYMGAA1NTUMGDAAOzduxdA9aPZPn36oEWLFjA3N0fv3r0FM71CfHw8Dhw4wBelBwcHw9ramr8Yv3jxAlFRUQgKCsKPP/7IP1aTZwkJCVBXV8fGjRsBVDeIHMfhf//7H4Dqm5YLFy4gLCwMBw8eRFZWlizDfSdisRjPnj0Dx3Hw8vLie+JrJozKysr46quvBFE/9erVq3qTh9WrV8PExIRPrMrLy/HgwQPs3bsXV69eFcxTiMzMTP58efHiBXr37g1jY2OpHuxHjx6hefPmiIuLk0msHyIuLg6qqqrYtGkTysrKcPDgQXAcxyf4wD8J47Jly+R+EIikV/Dly5cwNjaGqakpHBwcapUQffbZZzA3N8eRI0dq1aLXfHwtjw4cOAAVFRVYW1tDT08PgwYN4scJ7Nq1Czo6OtDV1YWZmRns7Oxk3iHAksVGqq5G/969e5g+fTq0tbWlioHl9e6rLpL9ysnJgZ+fHz/Fyo0bNzBixAg4OTlhz549/PaXL1/Go0ePBNNL8PTpU7Rt2xatWrWCh4cHsrOzkZaWhuHDhyMsLEyuHxu9yfr16zF27FgAQHZ2NgwMDDBt2jT+fSGUBtRU8/yKjY1Fs2bN4OPjw/cwSjg7O/MlEfI6d2lYWJhUneGRI0ewceNGvqcDqK6dtbOzQ0REBAD57pF6Xc05Srt27Yr169fz9YfPnz9Hr169pBLGnJwc9OzZUxA3LBJhYWGYMWMGgH/Or5o1wJI2fseOHbh586ZMYnxXkkRW8r29fPkS3bt3B8dxOHLkSK1j7/PPP4eGhgYuXLjw0WN9HzWT19zcXPj6+vKjng8fPowRI0bA0dERZ8+eBVA9+OrUqVNITU2Vi6nRWLLYCNWc2HP9+vXw8/NDYmIiSktL8fjxY8yaNQumpqZS00PI+51mTYmJiRg1ahQcHR2legtTU1MxcuRIODk5YceOHTKM8MMVFRXhu+++g6urK8aNGwdtbW3s2rULY8eORbdu3fjiZnlP8CXHYHp6OkpKSrBq1Sp8/fXXuHfvHj/qWXLMHTt2DD/88IPUlDPySrJfks9f8u+RI0egqKhYK2EMDAzEvn37kJGR8fGDfQfXrl3D0KFDpR6NL1myBK1bt0afPn0we/ZsPpEMCgqCkZERv89CShj/+OMPqKioYO3atbUuvEVFRXBwcICFhQX/mE+eB+nUZdKkSZg6dSpyc3NrzSqwZ88erF69WlBtPFD9hOXOnTsAgLKyMpibm8PS0hJJSUm1jr2ZM2fKbU/i8ePHpX5OSkrCkCFD4OzsLPVU6NSpU3zCeOLEiY8d5luxZLGR2r9/P1q3bo0vv/wSbm5u0NfXx8yZM/Hq1StkZGRg9uzZ6NKlC8LDw2Ud6ns7f/48bGxs0Lx5c2zfvl3qvbS0NIwZMwbW1taCmtvu6tWr/GPn5ORkmJmZIS4uDrGxsZgwYQImTpwIjuMwePBgwVyko6Oj0b59e1y+fBlbtmyBiYkJdHV1MXXqVH4bkUgEX19f+Pj4yPWUK2KxmP/cjx8/Dl9fX3z55ZdYvHgxsrOzAVT3MCorK2PcuHEIDw9HUFAQdHV1ZVaQ/jZLlizBkiVL+OPu3LlzfA/89evXsWnTJhgZGcHW1hYBAQGIj49Hz549+VICoSgoKEDfvn2xfPlyANU9VTk5Odi2bRv2798PoHqgh7m5OWxsbFBZWSmIc+zSpUuIiYkBAPz2229wc3ODnp4eP1WYWCxGZWUl/Pz8MGfOHLmfWqtmMhsXF4dWrVph6dKl/A3yy5cvYWJiAmtr63pr6uUtYYyNjYWtrS0eP37M79+OHTtgZ2cHdXV1XLx4UWr7U6dOYfTo0bCwsOB7GOUFSxYbodTUVBgZGWHLli0Aqu/KJMXNEnfv3sXkyZNhb28vuLtooLp3sU+fPujfvz+OHTsm9d6NGzfg7e0t97WXkrqc7OxsfPHFF9DR0eFXztm9ezf09fVx//593L9/HxEREVBVVYWGhoZcj8ysOTG1t7e31M3IqFGjwHEczp49i8LCQhQWFuLbb7+FlpaW3I56fj2BjYmJQbNmzeDr64tBgwahZ8+e0NPT43sITp06hT59+qBbt26wtLSUeZ1RfTZs2AAFBQW+5+bZs2dwcHCAkZGRVHJbVlaGH374AQMHDoSSkhI4jsP48ePlfqRpTZWVlejfvz8WLVqEnJwcBAYGwtnZGXp6elBTU8OSJUsAVNcwCmHOQbFYjOLiYgwcOJCfg+/+/fuwtLSElpYWPwikpKQEISEh0NXVlSopkEc1k/Pw8HCEhYVBVVUV6urqWLJkCX9DVlpaytfwvZ5oyaOcnBz+ScPt27f516Ojo9GjRw/079+/1sCwP//8E15eXnJ3LLJksRFKSEjgJ29OS0uDgYGB1MTUkobjzp07cj93WM0pV+Li4nD+/Hn+Ah4fH4++fftiyJAhtRJGeb6YZWVl8cXYhw8fxooVK3Djxg34+PhAV1cXvr6+OHbsGMLCwhASEsL3CDx8+FAQKy6cO3cOlpaWcHZ2lmrQS0tL4ezsjHbt2sHQ0BAuLi5o37693I6iDQ0NxbJly/jeiqdPn8LW1hZhYWH8NqmpqRgyZAjat2+PnJwcANWJ14sXL+S2TvbVq1eYPXs2Jk+eDKB6IvHExEScPHmST3Rfj10sFmPr1q0YOnSoYKbHkSgvL8eUKVPg6OgIJSUleHh4YMuWLcjLy8OUKVPg5eUl6xA/SEREBJo1a8YPnsrMzISBgQHs7OxgamqKQYMGQUdHR27PL4maieKSJUugrq6OQ4cOITY2FjNnzqyzh7FVq1a1pkaTZxkZGfx0UxKRkZFwdXXFsGHDag2+lMenLCxZFLiaj8ckF7Xo6GhYWloiPz8fRkZGUhN7nj59GtOmTUNubq7MYn5Xkv3at28f9PX1oa+vD0NDQ3To0IGfAuf8+fPo27cvRowYgUOHDsky3HdSUlICJycnWFlZISIiAhzHYd++ffz7O3fuxPjx42FgYABra2sMGDBA7nsFXpeTkwNLS0twHIc//vgDgPQFYf/+/fjpp58QExMjt4MINmzYACUlJanegJycHGhra+Pw4cP8ayKRCNevX0ePHj0QHh7OL80o70JDQ6GiooLQ0FBwHIfTp08DqJ6KqmfPnrC0tOSfONSsjy0vL5dBtB9OctxJBgvExMRIHYvjxo3D1KlT5f47qxmz5PuoqKiAu7s7pk+fztf75uTkICIiAkFBQfj999/l+uby9Z7BoqIi2NvbS92MAcDChQvRrFkzLF26lG8vysvL5b5uu6bs7GzMnTsXXbt2xdKlS/nXd+3aBVdXV3h4eMj9jAksWRSwmonioUOH+NFvlZWVsLKyAsdxUvVhQPUqC/369ZOaa0ueXbx4ES1atMCvv/6KzMxMJCYmYujQoWjTpg3fw3H+/Hl069YNnp6ecj9a+NWrV7h06RIMDAygrKzMj4arWU+UnZ2NiIgI6OrqguM4jB49WlbhvlV9F9mcnBxYWVnB0tKSf5wi7xdkidd73k6ePIm///4blZWVcHR0xLx582rtS+/evWuda/KoZtLRo0cPKCsrY+7cufxrIpGozoRRnnvq36au4+7x48eYP38+NDQ05H50sER8fHytWMPCwmBsbCy42QT8/PwwY8YMqeOxsLAQNjY2WLFiBQBITYUzbNgw6OrqIiwsTGpf5a1GUaK+2UgWLFgAU1NTqYQxKioKdnZ2GDdunFzfjLFkUaBqJor79u0Dx3HgOA7nzp2DSCTC7t270a1bN4wcORJPnjzBxYsXERQUhJYtW0otQybvNm/ejH79+kndRZaWlmLQoEEwNzfnk6zExES5r1GUuHfvHnR0dKCjo4O+ffvyDcTrU6vcv38fM2fOlMt6PklPhuQYTElJwb59+5CcnMw38jk5OTA3N4e9vb3c9iDW5/WeN0mZQ0BAABwcHLB7926p7UeOHIng4GCp81JeicViPHz4EDo6OrCxsYGGhgaOHj3Kn2OShLFPnz7Q19fnB8A0FjExMRg7diyMjY3ltqb0dU+ePMHgwYPBcRwCAwP5gS0AYG9vL6hHskB1eyG5AZHUzQLAhAkT0KlTJ/5YlGzj7+8POzs7aGtr84OS5PXmU3L+x8XFISwsDMuWLePrgLOysupMGPft2yf3bSRLFgVKckDu3r0bioqKWLlyJWxtbfmJZAsLC7Ft2zaYm5ujZcuWMDMzQ/fu3QXTOEqEhYWhTZs2/M+SRuTkyZMwMjKS+xVZ6lJWVobbt28jPj4eVlZWcHR05BMsSeMoScbk8c55/fr1mDdvHl9DFB0dDVVVVRgbG0NRURFBQUFSc9aZmZnB0dFR7gq26/K2nrfi4mIMHToU9vb2mDZtGnbu3Inp06dDTU1NUCuzlJWV8d/fmDFj0Lp1axw7dow/3kQiEU6ePInPP/9c6mIuBG9LIoqKivD7778L5uayph07dmDEiBHQ1tbG6NGjceLECaxbtw7u7u6CK1cBgO3bt8PJyYkvV8nJyYGFhQV69OiB4uJivr0fNWoUEhMT4eXlBRMTE7lNFCUkE247ODjAwMAAOjo6fF1idnY2FixYgK5du+Lbb7+VcaTvjiWLArZ//35wHMePenZwcJCqfxOLxXj16hVOnz6NzMxMuZjY831dv34dXbp0wbJly6QeS6SkpAhqSbi6vHr1CsePH4eVlRV69+7NJ4obNmzA2rVrIRKJ5LKXKjQ0FNra2li8eDGSkpLg6uqKTZs2obCwEJs2bYKxsTH8/Pz4MoHc3Fxoa2vjs88+E0SdUX09b5Ke3+LiYoSEhMDZ2RkmJiZwcXERzOpANdU8tjw9PWsljGKxWO6nW3mdJPaHDx8iKiqq1s2WvCcZEjXXGY+JicFvv/3Gr/1eUFCACxcuoFevXnB1dUW7du3AcRx+/fVXWYb8QeLi4uDo6Ijhw4fjzz//BFBdemRlZQVtbW24urqia9eu6NSpEwDg559/ho2NjVzeREu+s7KyMgQEBGDr1q2oqqpCVlYWhg8fDk1NTb4uMTs7G7Nnz4a9vT2ePHkil+3861iyKFCVlZXw8vLCzp07+dfs7e2xaNEiAMJpFN+mtLQUM2bMgIuLC5YsWYKqqioUFhZiwYIFMDMzE1ytzuuqqqpw4sQJ2NjYQF9fH5MmTQLHcTJdA/RdrFixAgYGBliwYAE8PT2lHlVu27YNpqam8PPz42usHj58KDVYRN7V1/MmSegljfuTJ0/kcuTiu3o9YdTS0pJaW1dIJG3e/fv30bZtW3z//fcyjujf2bdvH9q3b48ePXrA1tYWmpqaOHToEH8MlpaW4vjx45gyZQqaN28u921GfdckyawWgwcPxsmTJwFUD2BZvnw5vv32W4SGhvL7PGnSJAwePBhlZWVymWAlJCRAX18frq6uUutYFxQUwN3dHZqamvwckTk5OXI9DdrrWLIoYJITSHISjhgxAnPmzOHfDwwMxOzZs+XypHoXkrifP3/OTyKuqqoKBwcHtG3btt6JWYVGJBLh2rVr8PX1xbhx4+Su0a/ZyNfsaVq3bh1UVVWhra1d6xHY9u3b0bVrV3h5eQnq8WxNb+t5ayxq7ueQIUPQoUMHuR8oVp/Hjx+jefPm8PX1FWy7B1TXYLdp04Z/avTw4UNwHIfVq1cDqJ14yXtdac14IyMjsWLFCgQEBPArGyUmJtY7DRoA5OXlYcaMGdDQ0JDrqZvS09Ph7OwMBQUFxMfHA/hn358/f87PNSu0cjCAJYuNSmBgIL788ksAQEhICJSUlAQxcembSE60ly9f4t69e9i0aROio6MFUf9W07v29Mrr+sE154aMjo7GunXrAAA//fQT2rRpg2+//ZbviZPYtGkT7O3tkZeX99HjbSj19bwJMRF50zFYc38k80XKE0nsbzuPnj17hg0bNgj+yUpUVBRGjRoFoHqOPkNDQ/j4+PDvS25YXu/plneBgYEwMDCAu7s7hg0bBo7jEBkZCaC6V87JyQnDhw+XGsDz8OFD/PTTT3BwcBBEkpWeno6+ffuiY8eO/DzGku/n2bNnGD9+vNQyf0LBksVGZOHChXBzc8OyZcvQtGlTwfW81dfAC6UhrI+kYX/8+DHOnTtX5/7I8z7WNTfkrl27+PdXrFiB9u3bY/HixbXm75T3Ho930Rh63oR8DErahVu3biE8PFxq7e3GavHixXBxccHTp09hYGAgtZZ6REQEAgIC5Pb7qs+ePXugq6vLJ3xxcXHgOA579+7lt4mPj4e5uTnmz58v9buPHj2S22Uz65KZmQlHR0d06tSJTxgl35/QvjcJliw2Ir/88gs4joOGhgYuX74s63Dey9sK04WqZh1V69atBbkWd31zQ9YccPTjjz+iXbt2WLp0Kb80FyCshlHIPW9vIuRjUBL7tWvXoKGhgW+++abWFCNCOsbqIok/Ozub74W/fv06evfujRYtWvCrb0k+i4CAAIwcORJFRUWyCfgDrVu3jt+XqKgoqKmp4ZdffgFQ/YhWMoAnJSVFalS+UEkSRjMzs0Zxg8OSRQF524nz6NEjWFtbC246mcZWmP66R48eQU1NTdB1VPXNDVkzYVy5ciWaNWuGsLAwwSX7Qu55exdCPgbz8vJgZmaGwMBA/rXy8nKpY09ox5uE5Ls4cOAA7OzssHPnThQWFuLZs2fw9fVF586d+eT+wYMHCAkJgaampmAmEq8pODgYQ4YMwdGjR6GmpoaNGzfy761btw5+fn5SZThC/U5run37NszNzWFrayv4/WHJokC87WImmZJEqAdkYylMr0tycjJWrlwp6LvkN80NWfOi/euvv/JF60LRGHre3kbIx2BSUhKcnJxQWlqKiooK+Pn5wdnZGS4uLpg3bx6/nVDbvoMHD0JFRQUrV66UKuPIzc2Ft7c3OnbsCA0NDdjb26NTp06CnS4sISEB9vb2UFJSwvr16/nXJXOXTp8+XXBt/7ucT3fu3BFcjX1dOAAgRq6JxWJSUFCgrKwssrGxoUWLFtHs2bPr3BYAcRz3cQNsAAUFBbRr1y6aNm0aKSgoyDocph5VVVUUFxdH8+bNIxUVFTp9+jQ1bdqU1q5dS0pKSuTv7y/rED/I48ePydjYmMaPH08bN24UxDkkaRdu3rxJ6enp5OHhIeuQ/hO///47hYaG0t27d2n48OFUVlZGQ4cOpTt37tDp06dJX1+fDh8+LOswP0h+fj65ubnR+PHjae7cuVRRUUEvX76kM2fOkImJCVlYWFBmZiadPHmSLCwsqFOnTtSuXTtZh/1BSktLaeHChfTnn3/SqFGjyMfHh7Kysuj777+nvLw8unz5MikpKQnmGiYSiUhRUZHy8vLo7NmzNGrUKFJUVJR1WP8d2eaqzLsS8mOkxiozMxOBgYEYNWoUFi1aJKg5s/6N+uaGlMdlJF+/86/v3BFaz5skzuTkZCgrKze60o2a7ty5Azs7O6xYsQL9+/dHZmYmgOrPIDo6GtbW1vwScEJTUFCA3r17Y9u2bcjLy8OiRYvg7OyM1q1bo2PHjvjtt99kHWKDqDkN2qxZs2BpaYkmTZrAzs4OAwYM4Ed1C6V3uLGXTtWF9SwKREpKCh0/fpwCAgIE1fOWm5tLjx49IhsbG0HF/TY3btygzz//nBwdHUlVVZUOHjxIQ4cOpYiICFmH9lGIxWK6efMmbdy4kYqKiig4OJi6du0q67CkSHre8vLy6Pnz52RhYSHrkBqEZL9SUlKoV69e5OfnR6tWrapzWwikl+ZNnj17RmPGjKH79++TiooKJSYmUrNmzYiIqKSkhOzs7Oirr76ikJAQGUf6/kpLS2no0KFUXl5OycnJ9MUXX1D//v2pX79+FBAQQF27dqUVK1bIOswGITluKysrqaysjFJSUsjQ0JD09fVJQUGBqqqqSElJSdZhvrP8/HwyMjKir776SjBPI/4VGSerDKrvUoS6LNWbpKWloVmzZujWrRuuXLnSaHpEc3Jy0K1bN6k1g1NSUqCqqsqvzd0YCH1uSKD6u2rTpg1GjBghuBkC3uTu3bto0qQJv7ZsRUUFNm/ejIULF2LlypVSExc3hvPu5s2b0NbWllreVGLEiBHYtGmTjCL7cDVXAdqxYwe2b9+Oly9f8q97eHggKChIliF+MMk+vH7s1XcsCvF611jm9HxXjaerR6BSU1PJ29ubBg4cSH5+fhQbG0tERAoKCiQSiWQc3Yd7+vQp+fv7k7u7O1VVVdGkSZMoKSmJ0Ag6sk+cOEFaWlo0Z84cIqqu4zM0NCQDAwMqLy+XcXQNQyQSkYKCAuXn59P58+fr/N4krzVt2vRjh/fOMjMzqbCwkAoLC2nDhg30999/8++JxWISi8UyjO7DAKBjx46RhoYG3xMzbNgw+vnnn+nPP/+ksLAw8vX1pcjISCKiRtHjYWFhQSdPniR9fX0KDw+nRYsWUVxcHM2dO5fOnTtHrq6usg7xvXEcRyKRiDQ1NcnLy4u8vb2pefPmVFxcTMHBwXTmzBn6+uuvZR3me0H1oFniOI5OnTpFO3fulDrH6jsW5eWpkyTWutqG13/W0NAgf39/uYn9v/Zp7KWcSk9Pp169epFIJCJ7e3tKSEigxYsX80mIoqKiYBPG3Nxc6tSpE82ePZuSk5NJJBLR5MmTG0XC6OTkRL169eILzRUVFUldXZ1UVFTo8ePHMo7u3xOLxaSoqEhZWVlkZmZGV65cqbORF0ISYmlpSYMGDaIxY8bQjRs3aM2aNXTz5k3+fSE29BzH0dixYyk4OJgOHDhA6urq1KRJEzpw4ABdunSJbt26RSoqKvTLL7/Qy5cvZR1ug+nSpQudOHGCHBwcKDIykqZNm0Znz56l48ePU6dOnWQd3gd5fUBEZGQkeXl50e7du+n48eNkamoqo8g+DMdxxHEcxcTEkJubG6moqAjmHJM8Jk9NTaWJEydS//79ycfHh6KioohI+B04/5oMezU/aWKxGCEhIfzyfABQVFSE77//HtbW1vjmm2+kthWaly9fSk2uWlZWBgsLC1haWko9DhRKQXN9an43dnZ2UnOHRUVFITExURZh/WuNYUBVVVUV8vPzYWJigpycHERHR8Pe3h7ffPMNevXqhZEjRwIQ5vkFVA8WWLFiBUaPHs2v1iTZl7S0NHAch9OnT8swwv9GZWUliouLkZeXJ7iJqd/2yPL58+cIDw/HnTt3PlJEDS8+Ph4cxwmyNCAtLQ2tW7fG5MmTsXr1agwcOBCdO3eGv78/v43Qr1kfiiWLMjRx4kQ4OTlJvVZUVIRVq1ahe/fuCAsLk1FkDUtS01ZRUSGVMJaVlWHZsmX4+eefZRzhvyOZ47JPnz6IiIgAACxYsAAcxwm20Rfa6OC6SBKn8ePH49ixYwCA2NhYaGpqQk1NDVu3bpVhdA3jxYsXSEhIkKobFYlESEhIgLm5OW7fvi3D6Jia3jZXrhDPtbpifvLkCY4cOSKDaD6cWCxGeXk5xo8fj5kzZ/Kvl5WVwcbGBhzHwdPTU2r7T40w+ocbGfz/x7C2trYkEokoPT2df09NTY0mTZpENjY2dOjQISouLpZVmA2madOmVFVVRU2bNqWrV69SVVUV+fj4kKenJy1evJhcXFxkHeK/InkcKxaLSVlZmZYvX07h4eGUmJhIHTt2lHF0/5DU3FRWVlJpaekbt7WysqLAwEDBPEKqi+R7UVRUpLi4OCIiio6OJpFIRPr6+nTu3DlKTEyUYYT/nrq6OvXs2VOqblRBQYH++OMPUldXp1atWskuOIb3LqUdQjjXMjIy6MqVK3Tjxg0iqo4Zr5UVaWpq0hdffCGL8D4Yx3GkrKxMjx49Ig0NDSIiKi8vp2bNmtHnn39OHh4elJ6ezs86IIQSnAYn62z1U3b79m1oampi0qRJKC4uBiC9TijHcTh69KgsQ2xQkh64oqIiKCgoQENDg19UvjFwdXWFnp4elJWV5W7kraQHIDU1FWPHjoW9vT08PT1x6dIlGUf235GcS9u2bUNoaCj8/Pygq6uLu3fvIjo6Gp06dYKvr6/UCjRCl5CQgKCgILRs2VJwy342FvX1Ogm9tGPr1q0wNzeHtrY2rK2tsWbNGlmH1GDEYjFKS0vRt29feHl58deqnJwcGBoaYsuWLZgwYQL69esn40hlhyWLMnbq1CkoKytj+vTpePLkCf96Xl4erKyscOHCBRlG1/BevnyJ6dOnQ0VFRZDrm9ZFLBZLPa6oOW2JPJAkitevX0ebNm0wadIkrFmzBp06dcLo0aOlthXiRextzpw5A47joKOjgytXrvCvx8TE4O7duzKMrGE9e/YMY8aMgbW1NZKTk2UdzienoKDgje8LubRj9+7dUFVVRUREBJKSkjBx4kS4ublJtReNoZbv/PnzUFBQgJOTE7y8vKCqqoopU6YAqG4/1dTUcOvWrUbZTr4NSxblwKFDh6CsrAwPDw9ERUUhNTUV3377LXR1dfHgwQNZh9egsrOzMWDAgEbZo5Wamiq3CXB2djZMTEyk5m2LiYnBqFGjal3khHgxe5PKykr89ttvfE9bY27oHz16hLy8PFmH8clJS0uDk5MTTp48CaDxHGNisRhFRUUYOnQoVq1axb9+5swZeHp64ty5c7h48SL/emNIGBMTEzFhwgRMmTJFqp7+4MGDMDc3x4sXL2QYneywFVzkxN9//00BAQF0//59UlJSIkVFRYqKiiIbGxtZh9agAFB5eTk1b95c1qF8MgDQ3r176eLFixQUFETa2tpERDR37lw6cOAAcRxHpqam1KdPHwoODpZxtP8NybQYDNPQUlJSyNHRkcrLy2nu3Lm0cuVKWYfUoABQr169yMHBgdauXUtERG5ubnTjxg0Si8XUpk0bateuHR07dky2gTYg1LHy0bx58+jKlSt08OBBatmypYwikx2WLMqRoqIiKigooOLiYtLV1SVNTU1Zh8Q0EoWFhZSVlUWWlpZERLR8+XJatGgRrVmzhjp06ECxsbF0+fJl+umnn8jR0VHG0TKMMEgSxaCgIOrYsSMFBwfToUOHyNbWVtahNZjy8nKaM2cOXb16lQwNDSk/P5+ysrLo0KFDpK6uTjdv3qS5c+eSv78/+fn5yTrcBnf9+nX6v//7P9q5cyedPXuWrKysZB2STAhnIcZPQMuWLT/JOxbmv6eurs4nilVVVdSqVSuKjY2lgQMHEhFRr169SF9fn5KTk1myyDDv4OrVq9SnTx+aM2cOhYaG0uXLlwkAXblyhWxtbRtNb3azZs0oJCSEdu3aRYqKihQdHU1r167l14Jv0aIFERG9ePFChlH+NyoqKuj27dtUUFBA586d49vQTxFLFhnmE6OkpER+fn5SU/5UVlaSvb09de7cWcbRMYz8q6yspKlTp5K/vz8tW7aMiIjs7e3J3d2dvv/+exo5ciS1adNGxlE2HH19fQoKCiIiov3790slhk2aNCENDQ1+ypnGRFlZmQYNGkQDBgwgVVVVWYcjU8K/7WEY5l9RUFCgjRs3UkFBAVlYWMg6HIaRe02bNqWjR4/Sjz/+SETELwM3fvx4UlVVpcOHDxNR7fWEhQwAVVRUUMuWLeno0aN04sQJunbtGnl6elJZWRlNmTJF1iH+J5SVlT/5RJGI1SwyzCft0qVLdODAAdq4ceMnXY/DMA1BLBZT//79iYjo1KlTMo7mv3H16lUaPXo0FRcXk6amJunp6dGRI0eoSZMmJBKJaq13zTQOLFlkmE/U8+fPKSAggG7dukWbNm36pOtxGObfktQoXrhwgYYNG0YbN26kL7/8UtZh/Sdyc3Pp/v371KRJE+revTspKChQVVUVKSmxyrbGiiWLDPMJe/LkCQEgLS0tWYfCMI3Cw4cPadSoUWRlZUW//PKLrMP5KBrLYB6mfuzbZZhPWNu2bVmiyDANSE9Pjzw8PGjv3r1UUlIi63A+CpYoNn6sZ5FhGIZhGoBkMuenT59SZWUl6enpyTokhmkQLFlkGIZhGIZh6sX6jhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYT4iIyMjWrt2Lf8zx3F04MCBjx7H4sWLydraut734+LiiOM4evHixTv/TRcXF5o9e/a/imvbtm3UqlWrf/U3GIZpWCxZZBiGkaG8vDz64osv3mnbtyV4DMMw/wUlWQfAMAwjNJWVldS0adMG+Vs6OjoN8ncYhmH+K6xnkWGYT5qLiwv5+/uTv78/qaurk6amJi1cuJAA8NsYGRnR0qVLydvbm1q2bEk+Pj5ERHT+/Hnq27cvNW/enPT19WnmzJlUWlrK/15+fj4NHTqUmjdvTh06dKCIiIha///rj6FzcnLI09OTNDQ0SFVVlbp3706XLl2ibdu20f/+9z9KSUkhjuOI4zjatm0bERG9ePGCpkyZQm3btqWWLVvSZ599RikpKVL/T1hYGGlra5OamhpNnjyZysvL3+tzevbsGXl6elK7du1IRUWFunXrRpGRkbW2q6qqeuNnWVFRQYGBgdSuXTtSVVUlBwcHiouLe69YGIb5uFiyyDDMJ2/79u2kpKREiYmJtG7dOlqzZg1t3rxZaptVq1aRlZUVXb16lRYuXEh37twhNzc3GjlyJF27do12795N58+fJ39/f/53Jk6cSA8ePKDTp0/Tvn37aOPGjZSfn19vHCUlJeTs7Ey5ubl06NAhSklJofnz55NYLKYxY8bQ3LlzqUuXLpSXl0d5eXk0ZswYIiIaPXo05efn09GjRykpKYlsbW3J1dWVCgoKiIhoz549tHjxYlq+fDlduXKFdHV1aePGje/1GZWXl5OdnR3FxsbSjRs3yMfHh7y8vCgxMfG9Pkt/f39KSEigqKgounbtGo0ePZrc3NwoMzPzveJhGOYjAsMwzCfM2dkZ5ubmEIvF/GtBQUEwNzfnfzY0NIS7u7vU702ePBk+Pj5Sr507dw4KCgooKytDeno6iAiJiYn8+2lpaSAihIeH868REWJiYgAAmzZtgpqaGp49e1ZnrKGhobCysqr1f7Zs2RLl5eVSr3fq1AmbNm0CADg6OmLatGlS7zs4ONT6WzWdPn0aRITnz5/Xu83gwYMxd+5c/ue3fZZZWVlQVFREbm6u1N9xdXVFcHAwAGDr1q1QV1ev9/9kGObjYzWLDMN88nr27Ekcx/E/Ozo60urVq0kkEpGioiIREXXv3l3qd1JSUujatWtSj5YBkFgspnv37lFGRgYpKSmRnZ0d/76ZmdkbR/omJyeTjY0NaWhovHPsKSkpVFJSQm3atJF6vaysjO7cuUNERGlpaeTr6yv1vqOjI50+ffqd/x+RSETLly+nPXv2UG5uLlVWVlJFRQWpqKhIbfemz/L69eskEonIxMRE6ncqKipqxc8wjPxgySLDMMw7UFVVlfq5pKSEpk6dSjNnzqy1rYGBAWVkZLz3/9G8efP3/p2SkhLS1dWts+6vIaegWblyJa1bt47Wrl1L3bp1I1VVVZo9ezZVVla+V6yKioqUlJTEJ+ESLVq0aLBYGYZpWCxZZBjmk3fp0iWpny9evEjGxsa1EpqabG1tKTU1lTp37lzn+2ZmZlRVVUVJSUlkb29PRETp6elvnLfQ0tKSNm/eTAUFBXX2LjZt2pREIlGtOB49ekRKSkpkZGRU5981NzenS5cukbe3t9Q+vo/4+HgaPnw4TZgwgYiIxGIxZWRkkIWFhdR2b/osbWxsSCQSUX5+PvXt2/e9/n+GYWSHDXBhGOaTl52dTQEBAZSenk6RkZG0YcMGmjVr1ht/JygoiC5cuED+/v6UnJxMmZmZdPDgQX6Ai6mpKbm5udHUqVPp0qVLlJSURFOmTHlj76Gnpyfp6OiQu7s7xcfH0927d2n//v2UkJBARNWjsu/du0fJycn09OlTqqiooP79+5OjoyO5u7vTX3/9Rffv36cLFy7QggUL6MqVK0RENGvWLNqyZQtt3bqVMjIyKDQ0lG7evPlen5GxsTEdP36cLly4QGlpaTR16lR6/Pjxe32WJiYmNH78ePL29qbo6Gi6d+8eJSYm0g8//ECxsbHvFQ/DMB8PSxYZhvnkeXt7U1lZGfXo0YOmT59Os2bN4qfHqY+lpSWdOXOGMjIyqG/fvmRjY0OLFi0iPT09fputW7eSnp4eOTs7k4eHB/n4+JCWlla9f7Np06b0119/kZaWFg0aNIi6detGYWFhfA/nyJEjyc3Njfr160dt27alyMhI4jiOjhw5Qk5OTvT111+TiYkJjR07lrKyskhbW5uIiMaMGUMLFy6k+fPnk52dHWVlZZGfn997fUbfffcd2dra0sCBA8nFxYVPat/3s9y6dSt5e3vT3LlzydTUlNzd3eny5ctkYGDwXvEwDPPxcECNCbAYhmE+MS4uLmRtbS21BB/DMAzzD9azyDAMwzAMw9SLJYsMwzAMwzBMvdhjaIZhGIZhGKZerGeRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqdf/A8Ft00FyTuAKAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 12. Create a random tensor of shape `[1, 3, 64, 64]` and pass it through a `nn.Conv2d()` layer with various hyperparameter settings (these can be any settings you choose), what do you notice if the `kernel_size` parameter goes up and down?" + ], + "metadata": { + "id": "lj6bDhoWxt2y" + } + }, + { + "cell_type": "code", + "source": [ + "random_tensor = torch.rand([1, 3, 64, 64])\n", + "random_tensor.shape\n", + "conv_layer = nn.Conv2d(in_channels=3,\n", + " out_channels=64,\n", + " kernel_size=3,\n", + " stride=2,\n", + " padding=1)\n", + "\n", + "print(f\"Random tensor original shape: {random_tensor.shape}\")\n", + "random_tensor_through_conv_layer = conv_layer(random_tensor)\n", + "print(f\"Random tensor through conv layer shape: {random_tensor_through_conv_layer.shape}\")\n" + ], + "metadata": { + "id": "leCTsqtSbR5P", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "18c91e86-d1d6-4db9-9f04-9b3c8146dd02" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Random tensor original shape: torch.Size([1, 3, 64, 64])\n", + "Random tensor through conv layer shape: torch.Size([1, 64, 32, 32])\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 13. Use a model similar to the trained `model_2` from notebook 03 to make predictions on the test [`torchvision.datasets.FashionMNIST`](https://pytorch.org/vision/main/generated/torchvision.datasets.FashionMNIST.html) dataset.\n", + "* Then plot some predictions where the model was wrong alongside what the label of the image should've been.\n", + "* After visualing these predictions do you think it's more of a modelling error or a data error?\n", + "* As in, could the model do better or are the labels of the data too close to each other (e.g. a \"Shirt\" label is too close to \"T-shirt/top\")?" + ], + "metadata": { + "id": "VHS20cNTxwSi" + } + }, + { + "cell_type": "code", + "source": [ + "# Download FashionMNIST train & test\n", + "from torchvision import datasets\n", + "from torchvision import transforms\n", + "\n", + "fashion_mnist_train = datasets.FashionMNIST(root=\".\",\n", + " download=True,\n", + " train=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "fashion_mnist_test = datasets.FashionMNIST(root=\".\",\n", + " train=False,\n", + " download=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "len(fashion_mnist_train), len(fashion_mnist_test)\n", + "# Get the class names of the Fashion MNIST dataset\n", + "fashion_mnist_class_names = fashion_mnist_train.classes\n", + "fashion_mnist_class_names" + ], + "metadata": { + "id": "78a8LjtdbSZj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3dae493e-8c24-4559-8ed8-ec6de4145e58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to ./FashionMNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 26.4M/26.4M [00:02<00:00, 9.29MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 29.5k/29.5k [00:00<00:00, 150kB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 4.42M/4.42M [00:01<00:00, 2.79MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 5.15k/5.15k [00:00<00:00, 11.5MB/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['T-shirt/top',\n", + " 'Trouser',\n", + " 'Pullover',\n", + " 'Dress',\n", + " 'Coat',\n", + " 'Sandal',\n", + " 'Shirt',\n", + " 'Sneaker',\n", + " 'Bag',\n", + " 'Ankle boot']" + ] + }, + "metadata": {}, + "execution_count": 49 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn FashionMNIST datasets into dataloaders\n", + "from torch.utils.data import DataLoader\n", + "\n", + "fashion_mnist_train_dataloader = DataLoader(fashion_mnist_train,\n", + " batch_size=32,\n", + " shuffle=True)\n", + "\n", + "fashion_mnist_test_dataloader = DataLoader(fashion_mnist_test,\n", + " batch_size=32,\n", + " shuffle=False)\n", + "\n", + "len(fashion_mnist_train_dataloader), len(fashion_mnist_test_dataloader)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CLoagbwVKEAL", + "outputId": "c52b3925-b510-47f4-f339-e659dd02e465" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 50 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# model_2 is the same architecture as MNIST_model\n", + "model_2 = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model_2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jDkmCa2tKLZy", + "outputId": "fdaaa05e-de01-44bb-ffa0-b59d1a2ca089" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 51 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss and optimizer\n", + "from torch import nn\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_2.parameters(), lr=0.01)" + ], + "metadata": { + "id": "3k_32qrnKQnY" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup metrics\n", + "from tqdm.auto import tqdm\n", + "from torchmetrics import Accuracy\n", + "\n", + "acc_fn = Accuracy(task = 'multiclass', num_classes=len(fashion_mnist_class_names)).to(device)\n", + "\n", + "# Setup training/testing loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss, test_loss_total = 0, 0\n", + " train_acc, test_acc = 0, 0\n", + "\n", + " ### Training\n", + " model_2.train()\n", + " for batch, (X_train, y_train) in enumerate(fashion_mnist_train_dataloader):\n", + " X_train, y_train = X_train.to(device), y_train.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred = model_2(X_train)\n", + " loss = loss_fn(y_pred, y_train)\n", + " train_loss += loss\n", + " train_acc += acc_fn(y_pred, y_train)\n", + "\n", + " # Backprop and gradient descent\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " train_loss /= len(fashion_mnist_train_dataloader)\n", + " train_acc /= len(fashion_mnist_train_dataloader)\n", + "\n", + " ### Testing\n", + " model_2.eval()\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(fashion_mnist_test_dataloader):\n", + " X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred_test = model_2(X_test)\n", + " test_loss = loss_fn(y_pred_test, y_test)\n", + " test_loss_total += test_loss\n", + "\n", + " test_acc += acc_fn(y_pred_test, y_test)\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " test_loss /= len(fashion_mnist_test_dataloader)\n", + " test_acc /= len(fashion_mnist_test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Train loss: {train_loss:.3f} | Train acc: {train_acc:.2f} | Test loss: {test_loss_total:.3f} | Test acc: {test_acc:.2f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 156, + "referenced_widgets": [ + "d97f28b38c98433896ac99037182b3cd", + "5171e7d0c89349d1942872a271d098d5", + "73a16e5349d341b5af0b013731ced828", + "7e44d7a46ba4402cb164b2433ffdd3bf", + "1b5f5ad03c8b4abbbcd9e9ff4c28b149", + "062c9c612da0434ba794c973c5857510", + "04ac343c4b8e419fab2787d7972b4da1", + "458a4274c8b74a289184eedd1180e26c", + "2b92883149594d35a1b72a9bbdd3e41a", + "9f9fb380066f4175aceea26385626884", + "1940c92f2cd1436cb186071674146a15" + ] + }, + "id": "71Lk8G9-KXh2", + "outputId": "a0d0ca1f-3dfa-4f1f-ad51-a163a34cda43" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 128992556984977354953c80c0e192c06ddb464f Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Wed, 23 Apr 2025 15:49:57 +0100 Subject: [PATCH 13/17] Created using Colab From 7e73bbe428ec8bf91224f001337a649b90fc12c4 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Wed, 23 Apr 2025 15:51:11 +0100 Subject: [PATCH 14/17] Delete Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb --- .../week4/week4solution.ipynb | 3564 ----------------- 1 file changed, 3564 deletions(-) delete mode 100644 Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb b/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb deleted file mode 100644 index 4fa17b3..0000000 --- a/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb +++ /dev/null @@ -1,3564 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "03_pytorch_computer_vision_exercises.ipynb", - "provenance": [], - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - }, - "accelerator": "GPU", - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "13e8e56312674d3386224a2f00fd866f": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_0294fb9eb6fe4aff8d147f1f7cc1d553", - "IPY_MODEL_abfa0e7b82bf486e92f9d90960284d3e", - "IPY_MODEL_47b74eed37a84415a3fc42d1f19c5c4e" - ], - "layout": "IPY_MODEL_d7499f26238d4ec8a0d4ae459db82a5a" - } - }, - "0294fb9eb6fe4aff8d147f1f7cc1d553": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_9d3c8abcf41f4fee8069a63c0b7e603c", - "placeholder": "​", - "style": "IPY_MODEL_42ac5a11f588411dae6f326c558ff1fd", - "value": "100%" - } - }, - "abfa0e7b82bf486e92f9d90960284d3e": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_e879e28f80d74fb4a91ba371ef73e0bc", - "max": 5, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c7f9038bdc08459fa2638e92d9090832", - "value": 5 - } - }, - "47b74eed37a84415a3fc42d1f19c5c4e": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_59125daa8589482a84193b4f52778612", - "placeholder": "​", - "style": "IPY_MODEL_47b099254fd7441cbcc3ab185374b22d", - "value": " 5/5 [04:17<00:00, 50.76s/it]" - } - }, - "d7499f26238d4ec8a0d4ae459db82a5a": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "9d3c8abcf41f4fee8069a63c0b7e603c": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "42ac5a11f588411dae6f326c558ff1fd": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "e879e28f80d74fb4a91ba371ef73e0bc": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c7f9038bdc08459fa2638e92d9090832": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "59125daa8589482a84193b4f52778612": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "47b099254fd7441cbcc3ab185374b22d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "63e8ded88a124e61be96e5ecb60bfa8f": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_bb7d551f066841259a0881d98d9f677d", - "IPY_MODEL_74d4bcf2fd1f49efbf1b0393ab9bfb97", - "IPY_MODEL_688974c6acb948d9a503736947cd9d7b" - ], - "layout": "IPY_MODEL_ace5b23c36684cc7b767948efa2e5738" - } - }, - "bb7d551f066841259a0881d98d9f677d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_e0851980655a4669b356d632bf906959", - "placeholder": "​", - "style": "IPY_MODEL_2b88ffbcb8f54670b8da513dd1b99f02", - "value": "100%" - } - }, - "74d4bcf2fd1f49efbf1b0393ab9bfb97": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_7b378dc2ab434c8a8b636e4b0f60431d", - "max": 5, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_dc5d8f1541954a3b83695a4dd55c48eb", - "value": 5 - } - }, - "688974c6acb948d9a503736947cd9d7b": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_402e5c1c13bf4b34a73b9bd332edc798", - "placeholder": "​", - "style": "IPY_MODEL_660ab68ad7a64d38aec90fb79de21009", - "value": " 5/5 [01:29<00:00, 17.90s/it]" - } - }, - "ace5b23c36684cc7b767948efa2e5738": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "e0851980655a4669b356d632bf906959": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b88ffbcb8f54670b8da513dd1b99f02": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "7b378dc2ab434c8a8b636e4b0f60431d": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "dc5d8f1541954a3b83695a4dd55c48eb": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "402e5c1c13bf4b34a73b9bd332edc798": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "660ab68ad7a64d38aec90fb79de21009": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "a2963dd0080b449d8f7f90573c4da188": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_9db0a911e60c4271b78101ea50573155", - "IPY_MODEL_cbdaec3285264cd2a71bab7d8a8216f9", - "IPY_MODEL_0d573b771475435fa51639e5bfb8cb28" - ], - "layout": "IPY_MODEL_c08d9d15e6eb4e818aa97aa31c66ec95" - } - }, - "9db0a911e60c4271b78101ea50573155": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_08da86e0e8404cd1b02654bd24c62732", - "placeholder": "​", - "style": "IPY_MODEL_45397b429d5d47feab451defd8614c0d", - "value": "" - } - }, - "cbdaec3285264cd2a71bab7d8a8216f9": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_3beb124807bb4957940a8e9638f0fa5c", - "max": 1, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_c49009c851e94e55b2c1f3c4c901e205", - "value": 1 - } - }, - "0d573b771475435fa51639e5bfb8cb28": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_8ae0360136974b5ba1b7b607de3686c1", - "placeholder": "​", - "style": "IPY_MODEL_2e9c4f7159c545efb4f667c1be12a5b0", - "value": " 313/? [00:03<00:00, 137.66it/s]" - } - }, - "c08d9d15e6eb4e818aa97aa31c66ec95": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "08da86e0e8404cd1b02654bd24c62732": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "45397b429d5d47feab451defd8614c0d": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "3beb124807bb4957940a8e9638f0fa5c": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": "20px" - } - }, - "c49009c851e94e55b2c1f3c4c901e205": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "8ae0360136974b5ba1b7b607de3686c1": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2e9c4f7159c545efb4f667c1be12a5b0": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "d97f28b38c98433896ac99037182b3cd": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_5171e7d0c89349d1942872a271d098d5", - "IPY_MODEL_73a16e5349d341b5af0b013731ced828", - "IPY_MODEL_7e44d7a46ba4402cb164b2433ffdd3bf" - ], - "layout": "IPY_MODEL_1b5f5ad03c8b4abbbcd9e9ff4c28b149" - } - }, - "5171e7d0c89349d1942872a271d098d5": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_062c9c612da0434ba794c973c5857510", - "placeholder": "​", - "style": "IPY_MODEL_04ac343c4b8e419fab2787d7972b4da1", - "value": "100%" - } - }, - "73a16e5349d341b5af0b013731ced828": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_458a4274c8b74a289184eedd1180e26c", - "max": 5, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_2b92883149594d35a1b72a9bbdd3e41a", - "value": 5 - } - }, - "7e44d7a46ba4402cb164b2433ffdd3bf": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_9f9fb380066f4175aceea26385626884", - "placeholder": "​", - "style": "IPY_MODEL_1940c92f2cd1436cb186071674146a15", - "value": " 5/5 [01:14<00:00, 15.47s/it]" - } - }, - "1b5f5ad03c8b4abbbcd9e9ff4c28b149": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "062c9c612da0434ba794c973c5857510": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "04ac343c4b8e419fab2787d7972b4da1": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "458a4274c8b74a289184eedd1180e26c": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "2b92883149594d35a1b72a9bbdd3e41a": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "9f9fb380066f4175aceea26385626884": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "1940c92f2cd1436cb186071674146a15": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "4aa82d89f2074e89bb514adf1f407d60": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HBoxModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HBoxView", - "box_style": "", - "children": [ - "IPY_MODEL_e8de50e36e644606b76bee73e655e11e", - "IPY_MODEL_2491b725d5cf46b9ad30ba1b46c2c7a8", - "IPY_MODEL_7063a77f761f4402a0dbd434f6475939" - ], - "layout": "IPY_MODEL_6aa262b1d0284761918302feaf86796c" - } - }, - "e8de50e36e644606b76bee73e655e11e": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_0d98b13403cf47858fc9be646fcb151d", - "placeholder": "​", - "style": "IPY_MODEL_c887d4b92fd14828ba47c71ee383932c", - "value": "100%" - } - }, - "2491b725d5cf46b9ad30ba1b46c2c7a8": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "FloatProgressModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "ProgressView", - "bar_style": "success", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_104ae0dd35bb440283deb4a98686e985", - "max": 313, - "min": 0, - "orientation": "horizontal", - "style": "IPY_MODEL_1280745dd25547799bd36c359e1ab41b", - "value": 313 - } - }, - "7063a77f761f4402a0dbd434f6475939": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "model_module_version": "1.5.0", - "state": { - "_dom_classes": [], - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "HTMLModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/controls", - "_view_module_version": "1.5.0", - "_view_name": "HTMLView", - "description": "", - "description_tooltip": null, - "layout": "IPY_MODEL_eb1b53c81546478985715a780717505b", - "placeholder": "​", - "style": "IPY_MODEL_5e1911efa81c48ed9c36093c74466df5", - "value": " 313/313 [00:01<00:00, 192.77it/s]" - } - }, - "6aa262b1d0284761918302feaf86796c": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "0d98b13403cf47858fc9be646fcb151d": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "c887d4b92fd14828ba47c71ee383932c": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - }, - "104ae0dd35bb440283deb4a98686e985": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "1280745dd25547799bd36c359e1ab41b": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "ProgressStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "bar_color": null, - "description_width": "" - } - }, - "eb1b53c81546478985715a780717505b": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "model_module_version": "1.2.0", - "state": { - "_model_module": "@jupyter-widgets/base", - "_model_module_version": "1.2.0", - "_model_name": "LayoutModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "LayoutView", - "align_content": null, - "align_items": null, - "align_self": null, - "border": null, - "bottom": null, - "display": null, - "flex": null, - "flex_flow": null, - "grid_area": null, - "grid_auto_columns": null, - "grid_auto_flow": null, - "grid_auto_rows": null, - "grid_column": null, - "grid_gap": null, - "grid_row": null, - "grid_template_areas": null, - "grid_template_columns": null, - "grid_template_rows": null, - "height": null, - "justify_content": null, - "justify_items": null, - "left": null, - "margin": null, - "max_height": null, - "max_width": null, - "min_height": null, - "min_width": null, - "object_fit": null, - "object_position": null, - "order": null, - "overflow": null, - "overflow_x": null, - "overflow_y": null, - "padding": null, - "right": null, - "top": null, - "visibility": null, - "width": null - } - }, - "5e1911efa81c48ed9c36093c74466df5": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "model_module_version": "1.5.0", - "state": { - "_model_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_model_name": "DescriptionStyleModel", - "_view_count": null, - "_view_module": "@jupyter-widgets/base", - "_view_module_version": "1.2.0", - "_view_name": "StyleView", - "description_width": "" - } - } - } - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# 03. PyTorch Computer Vision Exercises\n", - "\n", - "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n", - "\n", - "They're a bunch of fun.\n", - "\n", - "You're going to get to write plenty of code!\n", - "\n", - "## Resources\n", - "\n", - "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n", - "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n", - " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n", - "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)." - ], - "metadata": { - "id": "Vex99np2wFVt" - } - }, - { - "cell_type": "code", - "source": [ - "# Check for GPU\n", - "!nvidia-smi" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "GaeYzOTLwWh2", - "outputId": "da9ed536-173b-4653-b8b3-a1db937068a2" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Sat Feb 22 23:56:08 2025 \n", - "+-----------------------------------------------------------------------------------------+\n", - "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n", - "|-----------------------------------------+------------------------+----------------------+\n", - "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", - "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", - "| | | MIG M. |\n", - "|=========================================+========================+======================|\n", - "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", - "| N/A 39C P8 9W / 70W | 2MiB / 15360MiB | 0% Default |\n", - "| | | N/A |\n", - "+-----------------------------------------+------------------------+----------------------+\n", - " \n", - "+-----------------------------------------------------------------------------------------+\n", - "| Processes: |\n", - "| GPU GI CI PID Type Process name GPU Memory |\n", - "| ID ID Usage |\n", - "|=========================================================================================|\n", - "| No running processes found |\n", - "+-----------------------------------------------------------------------------------------+\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Import torch\n", - "import torch\n", - "\n", - "# Exercises require PyTorch > 1.10.0\n", - "print(torch.__version__)\n", - "\n", - "# TODO: Setup device agnostic code\n", - "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", - "device\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 52 - }, - "id": "DNwZLMbCzJLk", - "outputId": "86cfee87-a6ad-487f-eaa5-e5af432dc160" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "2.5.1+cu124\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "'cuda'" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "string" - } - }, - "metadata": {}, - "execution_count": 33 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 1. What are 3 areas in industry where computer vision is currently being used?" - ], - "metadata": { - "id": "FSFX7tc1w-en" - } - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "VyWRkvWGbCXj" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n", - "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n", - "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n" - ], - "metadata": { - "id": "ZOnG1GHLZKMc" - } - }, - { - "cell_type": "markdown", - "source": [ - "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find." - ], - "metadata": { - "id": "oBK-WI6YxDYa" - } - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "d1rxD6GObCqh" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n" - ], - "metadata": { - "id": "xOtfv8elZwOI" - } - }, - { - "cell_type": "markdown", - "source": [ - "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n", - "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those." - ], - "metadata": { - "id": "XeYFEqw8xK26" - } - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "ocvOdWKcbEKr" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n", - "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n", - "3. Randomly turns off neurons during training to prevent dependency on specific features.\n" - ], - "metadata": { - "id": "LswlbpepaAIG" - } - }, - { - "cell_type": "markdown", - "source": [ - "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n", - "\n", - "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it." - ], - "metadata": { - "id": "DKdEEFEqxM-8" - } - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "TqZaJIRMbFtS" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets." - ], - "metadata": { - "id": "lvf-3pODxXYI" - } - }, - { - "cell_type": "code", - "source": [ - "import torch\n", - "import torchvision\n", - "from torchvision import datasets, transforms\n", - "\n", - "# Define transform\n", - "transform = transforms.Compose([\n", - " transforms.ToTensor(),\n", - " transforms.Normalize((0.1307,), (0.3081,))\n", - "])\n", - "\n", - "# Load train and test datasets\n", - "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n", - "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n", - "\n", - "\n" - ], - "metadata": { - "id": "SHjeuN81bHza" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "train_data, test_data" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "R_uWK0KpFFep", - "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(Dataset MNIST\n", - " Number of datapoints: 60000\n", - " Root location: ./data\n", - " Split: Train\n", - " StandardTransform\n", - " Transform: Compose(\n", - " ToTensor()\n", - " Normalize(mean=(0.1307,), std=(0.3081,))\n", - " ),\n", - " Dataset MNIST\n", - " Number of datapoints: 10000\n", - " Root location: ./data\n", - " Split: Test\n", - " StandardTransform\n", - " Transform: Compose(\n", - " ToTensor()\n", - " Normalize(mean=(0.1307,), std=(0.3081,))\n", - " ))" - ] - }, - "metadata": {}, - "execution_count": 21 - } - ] - }, - { - "cell_type": "code", - "source": [ - "len(train_data), len(test_data)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ePSUg0oGEoHF", - "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(60000, 10000)" - ] - }, - "metadata": {}, - "execution_count": 22 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Get the class names from the dataset\n", - "class_names = train_data.classes\n", - "class_names\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "TN6d1nUxD_64", - "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "['0 - zero',\n", - " '1 - one',\n", - " '2 - two',\n", - " '3 - three',\n", - " '4 - four',\n", - " '5 - five',\n", - " '6 - six',\n", - " '7 - seven',\n", - " '8 - eight',\n", - " '9 - nine']" - ] - }, - "metadata": {}, - "execution_count": 23 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 6. Visualize at least 5 different samples of the MNIST training dataset." - ], - "metadata": { - "id": "qxZW-uAbxe_F" - } - }, - { - "cell_type": "code", - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "# Function to visualize images\n", - "def show_images(dataset, num_images=5):\n", - " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n", - " for i in range(num_images):\n", - " img, label = dataset[i]\n", - " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n", - " axes[i].set_title(f\"Label: {label}\")\n", - " axes[i].axis(\"off\")\n", - "\n", - "show_images(train_data)\n" - ], - "metadata": { - "id": "QVFsYi1PbItE", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 155 - }, - "outputId": "ac991564-8773-4a32-b49f-273fd1284fea" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 7. Turn the MNIST train and test datasets into dataloaders using `torch.utils.data.DataLoader`, set the `batch_size=32`." - ], - "metadata": { - "id": "JAPDzW0wxhi3" - } - }, - { - "cell_type": "code", - "source": [ - "from torch.utils.data import DataLoader\n", - "\n", - "# Define batch size\n", - "batch_size = 32\n", - "\n", - "# Create DataLoaders\n", - "train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", - "test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False)\n", - "\n", - "# Print batch details\n", - "for images, labels in train_dataloader:\n", - " print(f\"Batch size: {images.shape}, Labels: {labels.shape}\")\n", - " break # Print one batch\n" - ], - "metadata": { - "id": "ALA6MPcFbJXQ", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "95559a37-fe65-4188-a636-bcca4287d28e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Batch size: torch.Size([32, 1, 28, 28]), Labels: torch.Size([32])\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "train_dataloader, test_dataloader" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "XHFFOphgfGZW", - "outputId": "a0dfbce4-ce4c-49c0-fe69-96cf6a4d4b36" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(,\n", - " )" - ] - }, - "metadata": {}, - "execution_count": 27 - } - ] - }, - { - "cell_type": "code", - "source": [ - "len(train_dataloader), len(test_dataloader)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "j8dnGKN9fqls", - "outputId": "82b4c2d4-f837-4295-8dcd-f4f796e807ef" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(1875, 313)" - ] - }, - "metadata": {}, - "execution_count": 28 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 8. Recreate `model_2` used in notebook 03 (the same model from the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/), also known as TinyVGG) capable of fitting on the MNIST dataset." - ], - "metadata": { - "id": "bCCVfXk5xjYS" - } - }, - { - "cell_type": "code", - "source": [ - "from torch import nn\n", - "class MNIST_model(torch.nn.Module):\n", - " \"\"\"Model capable of predicting on MNIST dataset.\n", - " \"\"\"\n", - " def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n", - " super().__init__()\n", - " self.conv_block_1 = nn.Sequential(\n", - " nn.Conv2d(in_channels=input_shape,\n", - " out_channels=hidden_units,\n", - " kernel_size=3,\n", - " stride=1,\n", - " padding=1),\n", - " nn.ReLU(),\n", - " nn.Conv2d(in_channels=hidden_units,\n", - " out_channels=hidden_units,\n", - " kernel_size=3,\n", - " stride=1,\n", - " padding=1),\n", - " nn.ReLU(),\n", - " nn.MaxPool2d(kernel_size=2)\n", - " )\n", - " self.conv_block_2 = nn.Sequential(\n", - " nn.Conv2d(in_channels=hidden_units,\n", - " out_channels=hidden_units,\n", - " kernel_size=3,\n", - " stride=1,\n", - " padding=1),\n", - " nn.ReLU(),\n", - " nn.Conv2d(in_channels=hidden_units,\n", - " out_channels=hidden_units,\n", - " kernel_size=3,\n", - " stride=1,\n", - " padding=1),\n", - " nn.ReLU(),\n", - " nn.MaxPool2d(kernel_size=2)\n", - " )\n", - " self.classifier = nn.Sequential(\n", - " nn.Flatten(),\n", - " nn.Linear(in_features=hidden_units*7*7,\n", - " out_features=output_shape)\n", - " )\n", - "\n", - " def forward(self, x):\n", - " x = self.conv_block_1(x)\n", - " # print(f\"Output shape of conv block 1: {x.shape}\")\n", - " x = self.conv_block_2(x)\n", - " # print(f\"Output shape of conv block 2: {x.shape}\")\n", - " x = self.classifier(x)\n", - " # print(f\"Output shape of classifier: {x.shape}\")\n", - " return x" - ], - "metadata": { - "id": "5IKNF22XbKYS" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "device" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 35 - }, - "id": "vEOGcDMleA2p", - "outputId": "0fccc8ce-fb26-47e0-e857-325a2a4ec817" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "'cuda'" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "string" - } - }, - "metadata": {}, - "execution_count": 34 - } - ] - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "zFhrF_r2eB8E" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "G2cEdnITd68u" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "model = MNIST_model(input_shape=1,\n", - " hidden_units=10,\n", - " output_shape=10).to(device)\n", - "model" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "uNDTL66DeDHD", - "outputId": "aa9720f2-ce7e-4758-a857-95c7ee868e6b" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "MNIST_model(\n", - " (conv_block_1): Sequential(\n", - " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (1): ReLU()\n", - " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (3): ReLU()\n", - " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " )\n", - " (conv_block_2): Sequential(\n", - " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (1): ReLU()\n", - " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (3): ReLU()\n", - " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " )\n", - " (classifier): Sequential(\n", - " (0): Flatten(start_dim=1, end_dim=-1)\n", - " (1): Linear(in_features=490, out_features=10, bias=True)\n", - " )\n", - ")" - ] - }, - "metadata": {}, - "execution_count": 35 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Try a dummy forward pass to see what shapes our data is\n", - "dummy_x = torch.rand(size=(1, 28, 28)).unsqueeze(dim=0).to(device)\n", - "# dummy_x.shape\n", - "model(dummy_x)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "K4q5XDGGeQQk", - "outputId": "fba05e28-fcae-445d-9744-b564058f7a58" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "tensor([[-0.0237, 0.0819, 0.0189, 0.0228, -0.0252, 0.0080, -0.0020, -0.0176,\n", - " 0.0736, 0.0680]], device='cuda:0', grad_fn=)" - ] - }, - "metadata": {}, - "execution_count": 36 - } - ] - }, - { - "cell_type": "code", - "source": [ - "dummy_x_2 = torch.rand(size=([1, 10, 7, 7]))\n", - "dummy_x_2.shape" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Lt9JtODAeXNE", - "outputId": "bbea492f-6ad4-49b9-8638-ccfc885dc3fd" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "torch.Size([1, 10, 7, 7])" - ] - }, - "metadata": {}, - "execution_count": 37 - } - ] - }, - { - "cell_type": "code", - "source": [ - "flatten_layer = nn.Flatten()\n", - "flatten_layer(dummy_x_2).shape" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "A9OT0ZW-eZ13", - "outputId": "32667c27-984c-4ce9-f951-4df41f3729c2" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "torch.Size([1, 490])" - ] - }, - "metadata": {}, - "execution_count": 38 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 9. Train the model you built in exercise 8. for 5 epochs on CPU and GPU and see how long it takes on each." - ], - "metadata": { - "id": "sf_3zUr7xlhy" - } - }, - { - "cell_type": "code", - "source": [ - "%%time\n", - "from tqdm.auto import tqdm\n", - "\n", - "# Train on CPU\n", - "model_cpu = MNIST_model(input_shape=1,\n", - " hidden_units=10,\n", - " output_shape=10).to(\"cpu\")\n", - "\n", - "# Create a loss function and optimizer\n", - "loss_fn = nn.CrossEntropyLoss()\n", - "optimizer = torch.optim.SGD(model_cpu.parameters(), lr=0.1)\n", - "\n", - "### Training loop\n", - "epochs = 5\n", - "for epoch in tqdm(range(epochs)):\n", - " train_loss = 0\n", - " for batch, (X, y) in enumerate(train_dataloader):\n", - " model_cpu.train()\n", - "\n", - " # Put data on CPU\n", - " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", - "\n", - " # Forward pass\n", - " y_pred = model_cpu(X)\n", - "\n", - " # Loss calculation\n", - " loss = loss_fn(y_pred, y)\n", - " train_loss += loss\n", - " # Optimizer zero grad\n", - " optimizer.zero_grad()\n", - "\n", - " # Loss backward\n", - " loss.backward()\n", - "\n", - " # Step the optimizer\n", - " optimizer.step()\n", - "\n", - " # Adjust train loss for number of batches\n", - " train_loss /= len(train_dataloader)\n", - "\n", - " ### Testing loop\n", - " test_loss_total = 0\n", - "\n", - " # Put model in eval mode\n", - " model_cpu.eval()\n", - "\n", - " # Turn on inference mode\n", - " with torch.inference_mode():\n", - " for batch, (X_test, y_test) in enumerate(test_dataloader):\n", - " # Make sure test data on CPU\n", - " X_test, y_test = X_test.to(\"cpu\"), y_test.to(\"cpu\")\n", - " test_pred = model_cpu(X_test)\n", - " test_loss = loss_fn(test_pred, y_test)\n", - "\n", - " test_loss_total += test_loss\n", - "\n", - " test_loss_total /= len(test_dataloader)\n", - "\n", - " # Print out what's happening\n", - " print(f\"Epoch: {epoch} | Loss: {train_loss:.3f} | Test loss: {test_loss_total:.3f}\")" - ], - "metadata": { - "id": "jSo6vVWFbNLD", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 170, - "referenced_widgets": [ - "13e8e56312674d3386224a2f00fd866f", - "0294fb9eb6fe4aff8d147f1f7cc1d553", - "abfa0e7b82bf486e92f9d90960284d3e", - "47b74eed37a84415a3fc42d1f19c5c4e", - "d7499f26238d4ec8a0d4ae459db82a5a", - "9d3c8abcf41f4fee8069a63c0b7e603c", - "42ac5a11f588411dae6f326c558ff1fd", - "e879e28f80d74fb4a91ba371ef73e0bc", - "c7f9038bdc08459fa2638e92d9090832", - "59125daa8589482a84193b4f52778612", - "47b099254fd7441cbcc3ab185374b22d" - ] - }, - "outputId": "d75a4a87-a629-4fd4-a671-180d8e20e320" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - " 0%| | 0/5 [00:00" - ] - }, - "metadata": {}, - "execution_count": 41 - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Logits -> Prediction probabilities -> Prediction labels\n", - "model_pred_logits = model_gpu(test_data[0][0].unsqueeze(dim=0).to(device)) # make sure image is right shape + on right device\n", - "model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", - "model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", - "model_pred_label\n", - "num_to_plot = 5\n", - "for i in range(num_to_plot):\n", - " # Get image and labels from the test data\n", - " img = test_data[i][0]\n", - " label = test_data[i][1]\n", - "\n", - " # Make prediction on image\n", - " model_pred_logits = model_gpu(img.unsqueeze(dim=0).to(device))\n", - " model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", - " model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", - "\n", - " # Plot the image and prediction\n", - " plt.figure()\n", - " plt.imshow(img.squeeze(), cmap=\"gray\")\n", - " plt.title(f\"Truth: {label} | Pred: {model_pred_label.cpu().item()}\")\n", - " plt.axis(False);" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "8qlR_6njh0Kp", - "outputId": "a4e56a0e-25e8-47b7-ea34-9e59abcc9441" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 11. Plot a confusion matrix comparing your model's predictions to the truth labels." - ], - "metadata": { - "id": "qQwzqlBWxrpG" - } - }, - { - "cell_type": "code", - "source": [ - "# See if torchmetrics exists, if not, install it\n", - "try:\n", - " import torchmetrics, mlxtend\n", - " print(f\"mlxtend version: {mlxtend.__version__}\")\n", - " assert int(mlxtend.__version__.split(\".\")[1]) >= 19, \"mlxtend verison should be 0.19.0 or higher\"\n", - "except:\n", - " !pip install -q torchmetrics -U mlxtend # <- Note: If you're using Google Colab, this may require restarting the runtime\n", - " import torchmetrics, mlxtend\n", - " print(f\"mlxtend version: {mlxtend.__version__}\")\n", - " # Import mlxtend upgraded version\n", - "import mlxtend\n", - "print(mlxtend.__version__)\n", - "assert int(mlxtend.__version__.split(\".\")[1]) >= 19" - ], - "metadata": { - "id": "vSrXiT_AbQ6e", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "40248d65-99ff-43d7-af57-cabb3e8933bf" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m49.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m109.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m84.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m51.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m12.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m86.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hmlxtend version: 0.23.4\n", - "0.23.4\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Make predictions across all test data\n", - "from tqdm.auto import tqdm\n", - "model_gpu.eval()\n", - "y_preds = []\n", - "with torch.inference_mode():\n", - " for batch, (X, y) in tqdm(enumerate(test_dataloader)):\n", - " # Make sure data on right device\n", - " X, y = X.to(device), y.to(device)\n", - " # Forward pass\n", - " y_pred_logits = model_gpu(X)\n", - " # Logits -> Pred probs -> Pred label\n", - " y_pred_labels = torch.argmax(torch.softmax(y_pred_logits, dim=1), dim=1)\n", - " # Append the labels to the preds list\n", - " y_preds.append(y_pred_labels)\n", - " y_preds=torch.cat(y_preds).cpu()\n", - "len(y_preds)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 66, - "referenced_widgets": [ - "a2963dd0080b449d8f7f90573c4da188", - "9db0a911e60c4271b78101ea50573155", - "cbdaec3285264cd2a71bab7d8a8216f9", - "0d573b771475435fa51639e5bfb8cb28", - "c08d9d15e6eb4e818aa97aa31c66ec95", - "08da86e0e8404cd1b02654bd24c62732", - "45397b429d5d47feab451defd8614c0d", - "3beb124807bb4957940a8e9638f0fa5c", - "c49009c851e94e55b2c1f3c4c901e205", - "8ae0360136974b5ba1b7b607de3686c1", - "2e9c4f7159c545efb4f667c1be12a5b0" - ] - }, - "id": "YmzNi-X_iaN7", - "outputId": "73f9d0e9-0adb-40dd-a91a-2aded6723ef1" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "0it [00:00, ?it/s]" - ], - "application/vnd.jupyter.widget-view+json": { - "version_major": 2, - "version_minor": 0, - "model_id": "a2963dd0080b449d8f7f90573c4da188" - } - }, - "metadata": {} - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "10000" - ] - }, - "metadata": {}, - "execution_count": 45 - } - ] - }, - { - "cell_type": "code", - "source": [ - "test_data.targets[:10], y_preds[:10]" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "qQC7oh1tig9S", - "outputId": "a80a26d7-182a-4fc3-a1ea-f9edb46e8337" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]),\n", - " tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]))" - ] - }, - "metadata": {}, - "execution_count": 46 - } - ] - }, - { - "cell_type": "code", - "source": [ - "from torchmetrics import ConfusionMatrix\n", - "from mlxtend.plotting import plot_confusion_matrix\n", - "\n", - "# Setup confusion matrix\n", - "confmat = ConfusionMatrix(task=\"multiclass\", num_classes=len(class_names))\n", - "confmat_tensor = confmat(preds=y_preds,\n", - " target=test_data.targets)\n", - "\n", - "# Plot the confusion matrix\n", - "fix, ax = plot_confusion_matrix(\n", - " conf_mat=confmat_tensor.numpy(),\n", - " class_names=class_names,\n", - " figsize=(10, 7)\n", - ")\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 638 - }, - "id": "czblDny_in5U", - "outputId": "11864434-840c-4d49-d8c9-4c974f04fb55" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 12. Create a random tensor of shape `[1, 3, 64, 64]` and pass it through a `nn.Conv2d()` layer with various hyperparameter settings (these can be any settings you choose), what do you notice if the `kernel_size` parameter goes up and down?" - ], - "metadata": { - "id": "lj6bDhoWxt2y" - } - }, - { - "cell_type": "code", - "source": [ - "random_tensor = torch.rand([1, 3, 64, 64])\n", - "random_tensor.shape\n", - "conv_layer = nn.Conv2d(in_channels=3,\n", - " out_channels=64,\n", - " kernel_size=3,\n", - " stride=2,\n", - " padding=1)\n", - "\n", - "print(f\"Random tensor original shape: {random_tensor.shape}\")\n", - "random_tensor_through_conv_layer = conv_layer(random_tensor)\n", - "print(f\"Random tensor through conv layer shape: {random_tensor_through_conv_layer.shape}\")\n" - ], - "metadata": { - "id": "leCTsqtSbR5P", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "18c91e86-d1d6-4db9-9f04-9b3c8146dd02" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Random tensor original shape: torch.Size([1, 3, 64, 64])\n", - "Random tensor through conv layer shape: torch.Size([1, 64, 32, 32])\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 13. Use a model similar to the trained `model_2` from notebook 03 to make predictions on the test [`torchvision.datasets.FashionMNIST`](https://pytorch.org/vision/main/generated/torchvision.datasets.FashionMNIST.html) dataset.\n", - "* Then plot some predictions where the model was wrong alongside what the label of the image should've been.\n", - "* After visualing these predictions do you think it's more of a modelling error or a data error?\n", - "* As in, could the model do better or are the labels of the data too close to each other (e.g. a \"Shirt\" label is too close to \"T-shirt/top\")?" - ], - "metadata": { - "id": "VHS20cNTxwSi" - } - }, - { - "cell_type": "code", - "source": [ - "# Download FashionMNIST train & test\n", - "from torchvision import datasets\n", - "from torchvision import transforms\n", - "\n", - "fashion_mnist_train = datasets.FashionMNIST(root=\".\",\n", - " download=True,\n", - " train=True,\n", - " transform=transforms.ToTensor())\n", - "\n", - "fashion_mnist_test = datasets.FashionMNIST(root=\".\",\n", - " train=False,\n", - " download=True,\n", - " transform=transforms.ToTensor())\n", - "\n", - "len(fashion_mnist_train), len(fashion_mnist_test)\n", - "# Get the class names of the Fashion MNIST dataset\n", - "fashion_mnist_class_names = fashion_mnist_train.classes\n", - "fashion_mnist_class_names" - ], - "metadata": { - "id": "78a8LjtdbSZj", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "3dae493e-8c24-4559-8ed8-ec6de4145e58" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n", - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to ./FashionMNIST/raw/train-images-idx3-ubyte.gz\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 26.4M/26.4M [00:02<00:00, 9.29MB/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Extracting ./FashionMNIST/raw/train-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", - "\n", - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n", - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw/train-labels-idx1-ubyte.gz\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 29.5k/29.5k [00:00<00:00, 150kB/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Extracting ./FashionMNIST/raw/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", - "\n", - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n", - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 4.42M/4.42M [00:01<00:00, 2.79MB/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Extracting ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", - "\n", - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n", - "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 5.15k/5.15k [00:00<00:00, 11.5MB/s]" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Extracting ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", - "\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "['T-shirt/top',\n", - " 'Trouser',\n", - " 'Pullover',\n", - " 'Dress',\n", - " 'Coat',\n", - " 'Sandal',\n", - " 'Shirt',\n", - " 'Sneaker',\n", - " 'Bag',\n", - " 'Ankle boot']" - ] - }, - "metadata": {}, - "execution_count": 49 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Turn FashionMNIST datasets into dataloaders\n", - "from torch.utils.data import DataLoader\n", - "\n", - "fashion_mnist_train_dataloader = DataLoader(fashion_mnist_train,\n", - " batch_size=32,\n", - " shuffle=True)\n", - "\n", - "fashion_mnist_test_dataloader = DataLoader(fashion_mnist_test,\n", - " batch_size=32,\n", - " shuffle=False)\n", - "\n", - "len(fashion_mnist_train_dataloader), len(fashion_mnist_test_dataloader)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "CLoagbwVKEAL", - "outputId": "c52b3925-b510-47f4-f339-e659dd02e465" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(1875, 313)" - ] - }, - "metadata": {}, - "execution_count": 50 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# model_2 is the same architecture as MNIST_model\n", - "model_2 = MNIST_model(input_shape=1,\n", - " hidden_units=10,\n", - " output_shape=10).to(device)\n", - "model_2" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "jDkmCa2tKLZy", - "outputId": "fdaaa05e-de01-44bb-ffa0-b59d1a2ca089" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "MNIST_model(\n", - " (conv_block_1): Sequential(\n", - " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (1): ReLU()\n", - " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (3): ReLU()\n", - " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " )\n", - " (conv_block_2): Sequential(\n", - " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (1): ReLU()\n", - " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", - " (3): ReLU()\n", - " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", - " )\n", - " (classifier): Sequential(\n", - " (0): Flatten(start_dim=1, end_dim=-1)\n", - " (1): Linear(in_features=490, out_features=10, bias=True)\n", - " )\n", - ")" - ] - }, - "metadata": {}, - "execution_count": 51 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Setup loss and optimizer\n", - "from torch import nn\n", - "loss_fn = nn.CrossEntropyLoss()\n", - "optimizer = torch.optim.SGD(model_2.parameters(), lr=0.01)" - ], - "metadata": { - "id": "3k_32qrnKQnY" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Setup metrics\n", - "from tqdm.auto import tqdm\n", - "from torchmetrics import Accuracy\n", - "\n", - "acc_fn = Accuracy(task = 'multiclass', num_classes=len(fashion_mnist_class_names)).to(device)\n", - "\n", - "# Setup training/testing loop\n", - "epochs = 5\n", - "for epoch in tqdm(range(epochs)):\n", - " train_loss, test_loss_total = 0, 0\n", - " train_acc, test_acc = 0, 0\n", - "\n", - " ### Training\n", - " model_2.train()\n", - " for batch, (X_train, y_train) in enumerate(fashion_mnist_train_dataloader):\n", - " X_train, y_train = X_train.to(device), y_train.to(device)\n", - "\n", - " # Forward pass and loss\n", - " y_pred = model_2(X_train)\n", - " loss = loss_fn(y_pred, y_train)\n", - " train_loss += loss\n", - " train_acc += acc_fn(y_pred, y_train)\n", - "\n", - " # Backprop and gradient descent\n", - " optimizer.zero_grad()\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " # Adjust the loss/acc (find the loss/acc per epoch)\n", - " train_loss /= len(fashion_mnist_train_dataloader)\n", - " train_acc /= len(fashion_mnist_train_dataloader)\n", - "\n", - " ### Testing\n", - " model_2.eval()\n", - " with torch.inference_mode():\n", - " for batch, (X_test, y_test) in enumerate(fashion_mnist_test_dataloader):\n", - " X_test, y_test = X_test.to(device), y_test.to(device)\n", - "\n", - " # Forward pass and loss\n", - " y_pred_test = model_2(X_test)\n", - " test_loss = loss_fn(y_pred_test, y_test)\n", - " test_loss_total += test_loss\n", - "\n", - " test_acc += acc_fn(y_pred_test, y_test)\n", - "\n", - " # Adjust the loss/acc (find the loss/acc per epoch)\n", - " test_loss /= len(fashion_mnist_test_dataloader)\n", - " test_acc /= len(fashion_mnist_test_dataloader)\n", - "\n", - " # Print out what's happening\n", - " print(f\"Epoch: {epoch} | Train loss: {train_loss:.3f} | Train acc: {train_acc:.2f} | Test loss: {test_loss_total:.3f} | Test acc: {test_acc:.2f}\")\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 156, - "referenced_widgets": [ - "d97f28b38c98433896ac99037182b3cd", - "5171e7d0c89349d1942872a271d098d5", - "73a16e5349d341b5af0b013731ced828", - "7e44d7a46ba4402cb164b2433ffdd3bf", - "1b5f5ad03c8b4abbbcd9e9ff4c28b149", - "062c9c612da0434ba794c973c5857510", - "04ac343c4b8e419fab2787d7972b4da1", - "458a4274c8b74a289184eedd1180e26c", - "2b92883149594d35a1b72a9bbdd3e41a", - "9f9fb380066f4175aceea26385626884", - "1940c92f2cd1436cb186071674146a15" - ] - }, - "id": "71Lk8G9-KXh2", - "outputId": "a0d0ca1f-3dfa-4f1f-ad51-a163a34cda43" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - " 0%| | 0/5 [00:00" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file From bc74fba88cd55761acf7289c1d60a22fa74750dc Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Wed, 23 Apr 2025 16:00:36 +0100 Subject: [PATCH 15/17] Created using Colab --- Part_1_Deep_Learning_with_Pytorch/week4/week4 | 3546 +++++++++++++++++ 1 file changed, 3546 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week4/week4 diff --git a/Part_1_Deep_Learning_with_Pytorch/week4/week4 b/Part_1_Deep_Learning_with_Pytorch/week4/week4 new file mode 100644 index 0000000..f88c7f8 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week4/week4 @@ -0,0 +1,3546 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "03_pytorch_computer_vision_exercises.ipynb", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "13e8e56312674d3386224a2f00fd866f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0294fb9eb6fe4aff8d147f1f7cc1d553", + "IPY_MODEL_abfa0e7b82bf486e92f9d90960284d3e", + "IPY_MODEL_47b74eed37a84415a3fc42d1f19c5c4e" + ], + "layout": "IPY_MODEL_d7499f26238d4ec8a0d4ae459db82a5a" + } + }, + "0294fb9eb6fe4aff8d147f1f7cc1d553": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d3c8abcf41f4fee8069a63c0b7e603c", + "placeholder": "​", + "style": "IPY_MODEL_42ac5a11f588411dae6f326c558ff1fd", + "value": "100%" + } + }, + "abfa0e7b82bf486e92f9d90960284d3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e879e28f80d74fb4a91ba371ef73e0bc", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7f9038bdc08459fa2638e92d9090832", + "value": 5 + } + }, + "47b74eed37a84415a3fc42d1f19c5c4e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_59125daa8589482a84193b4f52778612", + "placeholder": "​", + "style": "IPY_MODEL_47b099254fd7441cbcc3ab185374b22d", + "value": " 5/5 [04:17<00:00, 50.76s/it]" + } + }, + "d7499f26238d4ec8a0d4ae459db82a5a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d3c8abcf41f4fee8069a63c0b7e603c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42ac5a11f588411dae6f326c558ff1fd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e879e28f80d74fb4a91ba371ef73e0bc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7f9038bdc08459fa2638e92d9090832": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "59125daa8589482a84193b4f52778612": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47b099254fd7441cbcc3ab185374b22d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63e8ded88a124e61be96e5ecb60bfa8f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bb7d551f066841259a0881d98d9f677d", + "IPY_MODEL_74d4bcf2fd1f49efbf1b0393ab9bfb97", + "IPY_MODEL_688974c6acb948d9a503736947cd9d7b" + ], + "layout": "IPY_MODEL_ace5b23c36684cc7b767948efa2e5738" + } + }, + "bb7d551f066841259a0881d98d9f677d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0851980655a4669b356d632bf906959", + "placeholder": "​", + "style": "IPY_MODEL_2b88ffbcb8f54670b8da513dd1b99f02", + "value": "100%" + } + }, + "74d4bcf2fd1f49efbf1b0393ab9bfb97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b378dc2ab434c8a8b636e4b0f60431d", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dc5d8f1541954a3b83695a4dd55c48eb", + "value": 5 + } + }, + "688974c6acb948d9a503736947cd9d7b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_402e5c1c13bf4b34a73b9bd332edc798", + "placeholder": "​", + "style": "IPY_MODEL_660ab68ad7a64d38aec90fb79de21009", + "value": " 5/5 [01:29<00:00, 17.90s/it]" + } + }, + "ace5b23c36684cc7b767948efa2e5738": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0851980655a4669b356d632bf906959": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b88ffbcb8f54670b8da513dd1b99f02": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b378dc2ab434c8a8b636e4b0f60431d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc5d8f1541954a3b83695a4dd55c48eb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "402e5c1c13bf4b34a73b9bd332edc798": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "660ab68ad7a64d38aec90fb79de21009": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2963dd0080b449d8f7f90573c4da188": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9db0a911e60c4271b78101ea50573155", + "IPY_MODEL_cbdaec3285264cd2a71bab7d8a8216f9", + "IPY_MODEL_0d573b771475435fa51639e5bfb8cb28" + ], + "layout": "IPY_MODEL_c08d9d15e6eb4e818aa97aa31c66ec95" + } + }, + "9db0a911e60c4271b78101ea50573155": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_08da86e0e8404cd1b02654bd24c62732", + "placeholder": "​", + "style": "IPY_MODEL_45397b429d5d47feab451defd8614c0d", + "value": "" + } + }, + "cbdaec3285264cd2a71bab7d8a8216f9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3beb124807bb4957940a8e9638f0fa5c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c49009c851e94e55b2c1f3c4c901e205", + "value": 1 + } + }, + "0d573b771475435fa51639e5bfb8cb28": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ae0360136974b5ba1b7b607de3686c1", + "placeholder": "​", + "style": "IPY_MODEL_2e9c4f7159c545efb4f667c1be12a5b0", + "value": " 313/? [00:03<00:00, 137.66it/s]" + } + }, + "c08d9d15e6eb4e818aa97aa31c66ec95": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08da86e0e8404cd1b02654bd24c62732": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "45397b429d5d47feab451defd8614c0d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3beb124807bb4957940a8e9638f0fa5c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "c49009c851e94e55b2c1f3c4c901e205": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8ae0360136974b5ba1b7b607de3686c1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e9c4f7159c545efb4f667c1be12a5b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d97f28b38c98433896ac99037182b3cd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5171e7d0c89349d1942872a271d098d5", + "IPY_MODEL_73a16e5349d341b5af0b013731ced828", + "IPY_MODEL_7e44d7a46ba4402cb164b2433ffdd3bf" + ], + "layout": "IPY_MODEL_1b5f5ad03c8b4abbbcd9e9ff4c28b149" + } + }, + "5171e7d0c89349d1942872a271d098d5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_062c9c612da0434ba794c973c5857510", + "placeholder": "​", + "style": "IPY_MODEL_04ac343c4b8e419fab2787d7972b4da1", + "value": "100%" + } + }, + "73a16e5349d341b5af0b013731ced828": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_458a4274c8b74a289184eedd1180e26c", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2b92883149594d35a1b72a9bbdd3e41a", + "value": 5 + } + }, + "7e44d7a46ba4402cb164b2433ffdd3bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f9fb380066f4175aceea26385626884", + "placeholder": "​", + "style": "IPY_MODEL_1940c92f2cd1436cb186071674146a15", + "value": " 5/5 [01:14<00:00, 15.47s/it]" + } + }, + "1b5f5ad03c8b4abbbcd9e9ff4c28b149": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "062c9c612da0434ba794c973c5857510": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04ac343c4b8e419fab2787d7972b4da1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "458a4274c8b74a289184eedd1180e26c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b92883149594d35a1b72a9bbdd3e41a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f9fb380066f4175aceea26385626884": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1940c92f2cd1436cb186071674146a15": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4aa82d89f2074e89bb514adf1f407d60": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e8de50e36e644606b76bee73e655e11e", + "IPY_MODEL_2491b725d5cf46b9ad30ba1b46c2c7a8", + "IPY_MODEL_7063a77f761f4402a0dbd434f6475939" + ], + "layout": "IPY_MODEL_6aa262b1d0284761918302feaf86796c" + } + }, + "e8de50e36e644606b76bee73e655e11e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d98b13403cf47858fc9be646fcb151d", + "placeholder": "​", + "style": "IPY_MODEL_c887d4b92fd14828ba47c71ee383932c", + "value": "100%" + } + }, + "2491b725d5cf46b9ad30ba1b46c2c7a8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_104ae0dd35bb440283deb4a98686e985", + "max": 313, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1280745dd25547799bd36c359e1ab41b", + "value": 313 + } + }, + "7063a77f761f4402a0dbd434f6475939": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb1b53c81546478985715a780717505b", + "placeholder": "​", + "style": "IPY_MODEL_5e1911efa81c48ed9c36093c74466df5", + "value": " 313/313 [00:01<00:00, 192.77it/s]" + } + }, + "6aa262b1d0284761918302feaf86796c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d98b13403cf47858fc9be646fcb151d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c887d4b92fd14828ba47c71ee383932c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "104ae0dd35bb440283deb4a98686e985": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1280745dd25547799bd36c359e1ab41b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb1b53c81546478985715a780717505b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e1911efa81c48ed9c36093c74466df5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 03. PyTorch Computer Vision Exercises\n", + "\n", + "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n", + "\n", + "They're a bunch of fun.\n", + "\n", + "You're going to get to write plenty of code!\n", + "\n", + "## Resources\n", + "\n", + "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n", + "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n", + " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n", + "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)." + ], + "metadata": { + "id": "Vex99np2wFVt" + } + }, + { + "cell_type": "code", + "source": [ + "# Check for GPU\n", + "!nvidia-smi" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GaeYzOTLwWh2", + "outputId": "4e093661-df6c-4507-fe47-c979c6544f8d" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Wed Apr 23 14:56:22 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n", + "|-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 66C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Exercises require PyTorch > 1.10.0\n", + "print(torch.__version__)\n", + "\n", + "# TODO: Setup device agnostic code\n", + "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "DNwZLMbCzJLk", + "outputId": "67260ac6-de01-4400-9a6e-3c752e1e325d" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.6.0+cu124\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 2 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. What are 3 areas in industry where computer vision is currently being used?" + ], + "metadata": { + "id": "FSFX7tc1w-en" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "VyWRkvWGbCXj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n", + "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n", + "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n" + ], + "metadata": { + "id": "ZOnG1GHLZKMc" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find." + ], + "metadata": { + "id": "oBK-WI6YxDYa" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "d1rxD6GObCqh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n" + ], + "metadata": { + "id": "xOtfv8elZwOI" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n", + "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those." + ], + "metadata": { + "id": "XeYFEqw8xK26" + } + }, + { + "cell_type": "markdown", + "source": [ + "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n", + "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n", + "3. Randomly turns off neurons during training to prevent dependency on specific features.\n" + ], + "metadata": { + "id": "LswlbpepaAIG" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n", + "\n", + "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it." + ], + "metadata": { + "id": "DKdEEFEqxM-8" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets." + ], + "metadata": { + "id": "lvf-3pODxXYI" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "# Define transform\n", + "transform = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.1307,), (0.3081,))\n", + "])\n", + "\n", + "# Load train and test datasets\n", + "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n", + "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n", + "\n", + "\n" + ], + "metadata": { + "id": "SHjeuN81bHza" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "train_data, test_data" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "R_uWK0KpFFep", + "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(Dataset MNIST\n", + " Number of datapoints: 60000\n", + " Root location: ./data\n", + " Split: Train\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ),\n", + " Dataset MNIST\n", + " Number of datapoints: 10000\n", + " Root location: ./data\n", + " Split: Test\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ))" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_data), len(test_data)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ePSUg0oGEoHF", + "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(60000, 10000)" + ] + }, + "metadata": {}, + "execution_count": 22 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Get the class names from the dataset\n", + "class_names = train_data.classes\n", + "class_names\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TN6d1nUxD_64", + "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['0 - zero',\n", + " '1 - one',\n", + " '2 - two',\n", + " '3 - three',\n", + " '4 - four',\n", + " '5 - five',\n", + " '6 - six',\n", + " '7 - seven',\n", + " '8 - eight',\n", + " '9 - nine']" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Visualize at least 5 different samples of the MNIST training dataset." + ], + "metadata": { + "id": "qxZW-uAbxe_F" + } + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Function to visualize images\n", + "def show_images(dataset, num_images=5):\n", + " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n", + " for i in range(num_images):\n", + " img, label = dataset[i]\n", + " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n", + " axes[i].set_title(f\"Label: {label}\")\n", + " axes[i].axis(\"off\")\n", + "\n", + "show_images(train_data)\n" + ], + "metadata": { + "id": "QVFsYi1PbItE", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "outputId": "ac991564-8773-4a32-b49f-273fd1284fea" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Turn the MNIST train and test datasets into dataloaders using `torch.utils.data.DataLoader`, set the `batch_size=32`." + ], + "metadata": { + "id": "JAPDzW0wxhi3" + } + }, + { + "cell_type": "code", + "source": [ + "from torch.utils.data import DataLoader\n", + "\n", + "# Define batch size\n", + "batch_size = 32\n", + "\n", + "# Create DataLoaders\n", + "train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", + "test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False)\n", + "\n", + "# Print batch details\n", + "for images, labels in train_dataloader:\n", + " print(f\"Batch size: {images.shape}, Labels: {labels.shape}\")\n", + " break # Print one batch\n" + ], + "metadata": { + "id": "ALA6MPcFbJXQ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "95559a37-fe65-4188-a636-bcca4287d28e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Batch size: torch.Size([32, 1, 28, 28]), Labels: torch.Size([32])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "train_dataloader, test_dataloader" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XHFFOphgfGZW", + "outputId": "a0dfbce4-ce4c-49c0-fe69-96cf6a4d4b36" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_dataloader), len(test_dataloader)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j8dnGKN9fqls", + "outputId": "82b4c2d4-f837-4295-8dcd-f4f796e807ef" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 8. Recreate `model_2` used in notebook 03 (the same model from the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/), also known as TinyVGG) capable of fitting on the MNIST dataset." + ], + "metadata": { + "id": "bCCVfXk5xjYS" + } + }, + { + "cell_type": "code", + "source": [ + "from torch import nn\n", + "class MNIST_model(torch.nn.Module):\n", + " \"\"\"Model capable of predicting on MNIST dataset.\n", + " \"\"\"\n", + " def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n", + " super().__init__()\n", + " self.conv_block_1 = nn.Sequential(\n", + " nn.Conv2d(in_channels=input_shape,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.conv_block_2 = nn.Sequential(\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.classifier = nn.Sequential(\n", + " nn.Flatten(),\n", + " nn.Linear(in_features=hidden_units*7*7,\n", + " out_features=output_shape)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x = self.conv_block_1(x)\n", + " # print(f\"Output shape of conv block 1: {x.shape}\")\n", + " x = self.conv_block_2(x)\n", + " # print(f\"Output shape of conv block 2: {x.shape}\")\n", + " x = self.classifier(x)\n", + " # print(f\"Output shape of classifier: {x.shape}\")\n", + " return x" + ], + "metadata": { + "id": "5IKNF22XbKYS" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "device" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "vEOGcDMleA2p", + "outputId": "0fccc8ce-fb26-47e0-e857-325a2a4ec817" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "zFhrF_r2eB8E" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "G2cEdnITd68u" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uNDTL66DeDHD", + "outputId": "aa9720f2-ce7e-4758-a857-95c7ee868e6b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Try a dummy forward pass to see what shapes our data is\n", + "dummy_x = torch.rand(size=(1, 28, 28)).unsqueeze(dim=0).to(device)\n", + "# dummy_x.shape\n", + "model(dummy_x)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "K4q5XDGGeQQk", + "outputId": "fba05e28-fcae-445d-9744-b564058f7a58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[-0.0237, 0.0819, 0.0189, 0.0228, -0.0252, 0.0080, -0.0020, -0.0176,\n", + " 0.0736, 0.0680]], device='cuda:0', grad_fn=)" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dummy_x_2 = torch.rand(size=([1, 10, 7, 7]))\n", + "dummy_x_2.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Lt9JtODAeXNE", + "outputId": "bbea492f-6ad4-49b9-8638-ccfc885dc3fd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 10, 7, 7])" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "flatten_layer = nn.Flatten()\n", + "flatten_layer(dummy_x_2).shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A9OT0ZW-eZ13", + "outputId": "32667c27-984c-4ce9-f951-4df41f3729c2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 490])" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 9. Train the model you built in exercise 8. for 5 epochs on CPU and GPU and see how long it takes on each." + ], + "metadata": { + "id": "sf_3zUr7xlhy" + } + }, + { + "cell_type": "code", + "source": [ + "%%time\n", + "from tqdm.auto import tqdm\n", + "\n", + "# Train on CPU\n", + "model_cpu = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(\"cpu\")\n", + "\n", + "# Create a loss function and optimizer\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_cpu.parameters(), lr=0.1)\n", + "\n", + "### Training loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss = 0\n", + " for batch, (X, y) in enumerate(train_dataloader):\n", + " model_cpu.train()\n", + "\n", + " # Put data on CPU\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Forward pass\n", + " y_pred = model_cpu(X)\n", + "\n", + " # Loss calculation\n", + " loss = loss_fn(y_pred, y)\n", + " train_loss += loss\n", + " # Optimizer zero grad\n", + " optimizer.zero_grad()\n", + "\n", + " # Loss backward\n", + " loss.backward()\n", + "\n", + " # Step the optimizer\n", + " optimizer.step()\n", + "\n", + " # Adjust train loss for number of batches\n", + " train_loss /= len(train_dataloader)\n", + "\n", + " ### Testing loop\n", + " test_loss_total = 0\n", + "\n", + " # Put model in eval mode\n", + " model_cpu.eval()\n", + "\n", + " # Turn on inference mode\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(test_dataloader):\n", + " # Make sure test data on CPU\n", + " X_test, y_test = X_test.to(\"cpu\"), y_test.to(\"cpu\")\n", + " test_pred = model_cpu(X_test)\n", + " test_loss = loss_fn(test_pred, y_test)\n", + "\n", + " test_loss_total += test_loss\n", + "\n", + " test_loss_total /= len(test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Loss: {train_loss:.3f} | Test loss: {test_loss_total:.3f}\")" + ], + "metadata": { + "id": "jSo6vVWFbNLD", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 170, + "referenced_widgets": [ + "13e8e56312674d3386224a2f00fd866f", + "0294fb9eb6fe4aff8d147f1f7cc1d553", + "abfa0e7b82bf486e92f9d90960284d3e", + "47b74eed37a84415a3fc42d1f19c5c4e", + "d7499f26238d4ec8a0d4ae459db82a5a", + "9d3c8abcf41f4fee8069a63c0b7e603c", + "42ac5a11f588411dae6f326c558ff1fd", + "e879e28f80d74fb4a91ba371ef73e0bc", + "c7f9038bdc08459fa2638e92d9090832", + "59125daa8589482a84193b4f52778612", + "47b099254fd7441cbcc3ab185374b22d" + ] + }, + "outputId": "d75a4a87-a629-4fd4-a671-180d8e20e320" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ] + }, + "metadata": {}, + "execution_count": 41 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Logits -> Prediction probabilities -> Prediction labels\n", + "model_pred_logits = model_gpu(test_data[0][0].unsqueeze(dim=0).to(device)) # make sure image is right shape + on right device\n", + "model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + "model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "model_pred_label\n", + "num_to_plot = 5\n", + "for i in range(num_to_plot):\n", + " # Get image and labels from the test data\n", + " img = test_data[i][0]\n", + " label = test_data[i][1]\n", + "\n", + " # Make prediction on image\n", + " model_pred_logits = model_gpu(img.unsqueeze(dim=0).to(device))\n", + " model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + " model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "\n", + " # Plot the image and prediction\n", + " plt.figure()\n", + " plt.imshow(img.squeeze(), cmap=\"gray\")\n", + " plt.title(f\"Truth: {label} | Pred: {model_pred_label.cpu().item()}\")\n", + " plt.axis(False);" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "8qlR_6njh0Kp", + "outputId": "a4e56a0e-25e8-47b7-ea34-9e59abcc9441" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 11. Plot a confusion matrix comparing your model's predictions to the truth labels." + ], + "metadata": { + "id": "qQwzqlBWxrpG" + } + }, + { + "cell_type": "code", + "source": [ + "# See if torchmetrics exists, if not, install it\n", + "try:\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " assert int(mlxtend.__version__.split(\".\")[1]) >= 19, \"mlxtend verison should be 0.19.0 or higher\"\n", + "except:\n", + " !pip install -q torchmetrics -U mlxtend # <- Note: If you're using Google Colab, this may require restarting the runtime\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " # Import mlxtend upgraded version\n", + "import mlxtend\n", + "print(mlxtend.__version__)\n", + "assert int(mlxtend.__version__.split(\".\")[1]) >= 19" + ], + "metadata": { + "id": "vSrXiT_AbQ6e", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "40248d65-99ff-43d7-af57-cabb3e8933bf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m49.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m109.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m84.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m51.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m12.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m86.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hmlxtend version: 0.23.4\n", + "0.23.4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make predictions across all test data\n", + "from tqdm.auto import tqdm\n", + "model_gpu.eval()\n", + "y_preds = []\n", + "with torch.inference_mode():\n", + " for batch, (X, y) in tqdm(enumerate(test_dataloader)):\n", + " # Make sure data on right device\n", + " X, y = X.to(device), y.to(device)\n", + " # Forward pass\n", + " y_pred_logits = model_gpu(X)\n", + " # Logits -> Pred probs -> Pred label\n", + " y_pred_labels = torch.argmax(torch.softmax(y_pred_logits, dim=1), dim=1)\n", + " # Append the labels to the preds list\n", + " y_preds.append(y_pred_labels)\n", + " y_preds=torch.cat(y_preds).cpu()\n", + "len(y_preds)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 66, + "referenced_widgets": [ + "a2963dd0080b449d8f7f90573c4da188", + "9db0a911e60c4271b78101ea50573155", + "cbdaec3285264cd2a71bab7d8a8216f9", + "0d573b771475435fa51639e5bfb8cb28", + "c08d9d15e6eb4e818aa97aa31c66ec95", + "08da86e0e8404cd1b02654bd24c62732", + "45397b429d5d47feab451defd8614c0d", + "3beb124807bb4957940a8e9638f0fa5c", + "c49009c851e94e55b2c1f3c4c901e205", + "8ae0360136974b5ba1b7b607de3686c1", + "2e9c4f7159c545efb4f667c1be12a5b0" + ] + }, + "id": "YmzNi-X_iaN7", + "outputId": "73f9d0e9-0adb-40dd-a91a-2aded6723ef1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "0it [00:00, ?it/s]" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "a2963dd0080b449d8f7f90573c4da188" + } + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "10000" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "source": [ + "test_data.targets[:10], y_preds[:10]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qQC7oh1tig9S", + "outputId": "a80a26d7-182a-4fc3-a1ea-f9edb46e8337" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]),\n", + " tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]))" + ] + }, + "metadata": {}, + "execution_count": 46 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from torchmetrics import ConfusionMatrix\n", + "from mlxtend.plotting import plot_confusion_matrix\n", + "\n", + "# Setup confusion matrix\n", + "confmat = ConfusionMatrix(task=\"multiclass\", num_classes=len(class_names))\n", + "confmat_tensor = confmat(preds=y_preds,\n", + " target=test_data.targets)\n", + "\n", + "# Plot the confusion matrix\n", + "fix, ax = plot_confusion_matrix(\n", + " conf_mat=confmat_tensor.numpy(),\n", + " class_names=class_names,\n", + " figsize=(10, 7)\n", + ")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 638 + }, + "id": "czblDny_in5U", + "outputId": "11864434-840c-4d49-d8c9-4c974f04fb55" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAosAAAKDCAYAAAByuUB6AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAst9JREFUeJzs3XdUFGfbBvBr6b0pRRQERbAi1YIdiTUq0diCihiN3fDajSaWWKJpxtj1tSX62nsssQCisStGo2LsjWahLCoKO98ffm7cyCiwu8zuev3OmXPcmdmZ+/HZmb322dlBJgiCACIiIiKiQhhJXQARERER6S6GRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRJlIXQAVTqFQ4P79+7C1tYVMJpO6HCIiIjIwgiAgJycH7u7uMDISHz9kWNRR9+/fh4eHh9RlEBERkYG7c+cOKlSoILqcYVFH2draAgDMW38LmamlxNVo1q3lPaUugYiI6L2Xk50NH28PZeYQw7Coo1599SwztTS4sGhnZyd1CURERPT/3nW5G3/gQkRERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMOigbKxMMGs3nVxeUEXPFzdCwentUVw5bLK5U829il0im1fU2U7rYIqIGFGOzxc3Qv3VkRh3ejmpd2UElk4fx78fLzgYGOBRmF1cfLECalLUtvhxEPoFNkO3p7usDSVYfu2rVKXpDGG2F8A26Uvvp05Aw3qhcLZ0Rae7i7o3CkSV5KTpS5LbTxn6B9dbZdehcV58+bBy8sLFhYWqFu3Lk7oyH+iLpo/sCHCa7vj0zkJCB2xBQfO3cfOr1rB3ckKAODd938qU/95iVAoBGw9dku5jQ51K2Lp0Cb4Je4K6o7ciuYTfsO6xOtSNanINqxfhzGjhmP8hIk4euIM/P1ro33blkhPT5e6NLXk5uailn9tzJ4zT+pSNMpQ+4vt0h+JhxIwYOBgJBw+hp279yH/xQt82KYFcnNzpS5NLTxn6BddbpdMEARB6iKKYt26dejVqxcWLlyIunXrYvbs2diwYQOSk5Ph4uIidXlKz58/h5mZmdrbyc7Ohr29PSzaz4XM1LJYz7UwM0b6Lz3RZeZ+7DlzVzn/yMz2+P3sXUxee+aN56wb3Rw2lqZoO3kPAMDYSIbLC7pg6rozWHnwb/Ua8y+P1vbR6Pb+rVFYXQSHhGL2nLkAAIVCAR9vDwwcPBSjRo/V6r5Li6WpDOs2bkH7DpFSl6I2Q+0vtkt/ZWRkwNPdBfsOJqBho8ZSl6MRPGfoPinalZ2dDdcy9sjKyoKdnZ3oenozsvjDDz+gX79+iImJQfXq1bFw4UJYWVlh2bJlam23adOmkMlkb0w3b94EAGRmZqJv375wdnaGnZ0dwsPDce7cOeXzJ02ahICAACxduhTe3t6wsLAAANy+fRsdOnSAjY0N7Ozs0KVLF6SlpalVa1GZGMlgYmyEZy8KVOY/fV6A+tVc31jfxd4CrYI8sPLAFeW8wEplUL6MNRQCcPTbDri+pBu2jm+B6h4O2i5fLc+fP8fZM6cR3jxCOc/IyAjh4RE4ceyohJVRYQy1v9gu/ZadlQUAcHR0krgS+jdDfQ3qerv0Iiw+f/4cp0+fRkSE6n9iREQEjh5V7z9x8+bNSElJUU4dO3aEn58fXF1fhqrOnTsjPT0du3fvxunTpxEUFITmzZvj0aNHym1cvXoVmzZtwubNm5GUlASFQoEOHTrg0aNHSEhIwL59+3D9+nV07dpVrVqLSv4sH8eS0zD24wCUc7SEkZEM3RpVRl1fZ7g5WL2xflTTKsh5+gLbjv/zFbSXqy0AYHyXQHyzMQmdZuzDY3ke9kxuA0cb9UdOteXBgwcoKCiAi4tqKHZxdUVqaqpEVZEYQ+0vtkt/KRQKjBoRi/phDVCjZs13P4FKlaG+BnW9XSZSF1AUr/4TXwW4V1xdXXH58mW1tu3k9M8nxx9//BEHDx7E8ePHYWlpicOHD+PEiRNIT0+Hubk5AOC7777D1q1bsXHjRnz22WcAXobZVatWwdnZGQCwb98+nD9/Hjdu3ICHhwcAYNWqVahRowZOnjyJ0NDQN+rIy8tDXl6e8nF2drZa7fp0ziEsHNQQ15Z0R36BAknXH2L9kesIrFT2jXV7hVfBusRryHttJNJIJgMAzNp0Thki+89LxN+LuqJjfW/8d5/+X/xNRPRvsUMH46+/LuBA/GGpSyHSGXoxslgSiYmJsLGxUU6rV69+6/q7d+/G2LFjsW7dOvj6+gIAzp07B7lcjjJlyqhs68aNG7h27ZryuRUrVlQGRQC4dOkSPDw8lEERAKpXrw4HBwdcunSp0P3PmDED9vb2yun155bEjbQctJy4G2WjVsG3/zo0HrcDpsZGuJmWo7JeWDVX+JV3wIrXvoIGgNTHT1625W6mct7zfAVupsvhUdZGrdq0qWzZsjA2NkZ6uupX/ulpaXBzc5OoKhJjqP3Fdumn2GFDsGvXTuzdF4cKFSpIXQ4VwlBfg7reLr0Ii6/+E/99zV/aW/4TQ0JCkJSUpJzat28vuv2LFy+iW7du+Oabb9CiRQvlfLlcjnLlyqlsJykpCcnJyRg1apRyPWtrazVbCIwbNw5ZWVnK6c6dO2pvEwCe5OUjNfMpHKzNEBFQHjtP3lZZHh3uizPXHuD8rUcq889ef4hnz/Ph6/7PBa8mxjJ4OtvgdoZcI7Vpg5mZGQKDghF38IBynkKhQFzcAdSpV1/CyqgwhtpfbJd+EQQBscOGYPu2Ldjz+0F4eXtLXRKJMNTXoK63Sy++hjYzM0NwcDAOHDiAyMhIAC//Ew8cOIAhQ4YU+hxLS0v4+Pi8c9sPHjxAu3bt0KlTJ/znP/9RWRYUFITU1FSYmJjAy8uryPVWq1YNd+7cwZ07d5QjhBcvXkRmZiaqV69e6HPMzc2VX3VrQkTt8pDJgCv3s1DZzQ7Te4biyr0srIr7ZwTR1tIUHet7YdyqN29BlPP0BZb+nowJXYNw92EubmfI8Z/2tQAAm4/e0Fid2jAsdjj69YlGcHAIQkLrYO6c2XiSm4te0TFSl6YWuVyOa1evKh/fvHED55KS4OjkBE9PTwkrU4+h9hfbpT9ihw7GurVrsGHzNtjY2iqvEbO3t4elZfHuRqFLeM7QL7rcLr0IiwAwfPhwREdHIyQkBHXq1MHs2bORm5uLmBj1/hM7deoEKysrTJo0SeUiUmdnZ0RERKB+/fqIjIzErFmz4Ovri/v37+O3337DRx99hJCQkEK3GRERgVq1aiEqKgqzZ89Gfn4+Bg0ahCZNmog+R9PsrMwwJSoY5ctY47E8D1uP3cSk/51GfsE/d0rq3KASZDIZ1h8u/N6JX/xyAvkKBZYObQJLM2Oc/DsDbSbtRmbu81JpQ0l17tIVDzIyMGXyV0hLTYV/7QBs27nnjWte9c2Z06fQMqKZ8vGYUcMBAD16RmPJshUSVaU+Q+0vtkt/LF60AADQonlT1flLl6NndO/SL0hDeM7QL7rcLr25zyIAzJ07F99++y1SU1MREBCAOXPmoG7dumptU/b/P+T4txs3bsDLyws5OTkYP348Nm3ahIyMDLi5uaFx48aYMWMGPDw8MGnSJGzduhVJSUkqz799+zaGDh2KAwcOwMjICK1atcLPP/9c5E5X5z6Luk7b91kkIiKidyvqfRb1Kiy+TxgWiYiISJsM7qbcRERERFT6GBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCTKROoC6O1uLe8JOzs7qcvQKMfQIVKXoBWPT86VugQiIiKN48giEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSy+5xbOnwc/Hy842FigUVhdnDxxQuqSVDQIqoyNs/vj+u/T8PTsXLRr6q+yvEN4beyYPxh342bi6dm58Pctr7Lc0c4KP4zpjHNbvsSjoz/gyq4p+H70x7CzsVBZL7i6J3YtHIqUQ7NwP2EWts8bjFr/2pbUDiceQqfIdvD2dIelqQzbt22VuiSN0fXXYXF9O3MGGtQLhbOjLTzdXdC5UySuJCdLXZbGsL/0g6GeMwy1XYDuHlt6GxYPHTqEdu3awd3dHTKZDFu3bpW6JL2zYf06jBk1HOMnTMTRE2fg718b7du2RHp6utSlKVlbmuP8lXuInbGu0OVWlmb4I+kaJszZWujycs72KOdsj3E/bkFw5+noN/FXfBBWHQsnRr22DzNsmzcYd1Ifo3HP79A85gfInzzD9nmDYWKiO4dIbm4uavnXxuw586QuRaP04XVYXImHEjBg4GAkHD6Gnbv3If/FC3zYpgVyc3OlLk1t7C/9YajnDENtly4fWzJBEASpiyiJ3bt348iRIwgODkbHjh2xZcsWREZGSl2WxmRnZ8Pe3h5pD7NgZ2enlX00CquL4JBQzJ4zFwCgUCjg4+2BgYOHYtTosVrZJwA4hg4p0fOenp2LLv9ZjB3xf76xzLOcE5J3TUHdrjPw55V7b91Ox4hALJvWC2XCRqCgQIGg6p44sno0qrSagLtpmQCAGj7uOLXhC9RoPwnX7zwoUn2PT84tdptKytJUhnUbt6B9h8hS26e2SPU6LE0ZGRnwdHfBvoMJaNiosdTlqIX9pZ8M6ZzxOkNqlxTHVnZ2NlzL2CMr6+1ZQ3eGTYqpdevWmDp1Kj766CONbzshIQF16tSBubk5ypUrh7FjxyI/P1+5vGnTphg2bBhGjx4NJycnuLm5YdKkSSrbyMzMRN++feHs7Aw7OzuEh4fj3LlzGq+1pJ4/f46zZ04jvHmEcp6RkRHCwyNw4thRCSvTPjtbC2TnPkNBgQIAcOVmGh48liM6MgymJsawMDdF78j6uHQ9BbfuP5K4WsP2vrwOs7OyAACOjk4SV6Ie9heRduj6saW3YVFb7t27hzZt2iA0NBTnzp3DggUL8N///hdTp05VWW/lypWwtrbG8ePHMWvWLEyZMgX79u1TLu/cuTPS09Oxe/dunD59GkFBQWjevDkePdKN8PHgwQMUFBTAxcVVZb6LqytSU1Mlqkr7yjhYY1y/1li26Q/lPPmTPLTs9xO6twnF42M/4sGR7/FBWDVEDpmvDJSkHe/D61ChUGDUiFjUD2uAGjVrSl2OWthfRNqh68eWidQF6Jr58+fDw8MDc+fOhUwmQ9WqVXH//n2MGTMGX331FYyMXuZrf39/TJw4EQBQpUoVzJ07FwcOHMAHH3yAw4cP48SJE0hPT4e5uTkA4LvvvsPWrVuxceNGfPbZZ2/sNy8vD3l5ecrH2dnZpdDa94uttQW2zBmIS9dTMHXRb8r5FuamWDgxCkfPXUf0uOUwNjZCbK/m2DxnIBr2+BbP8l5IWDXpu9ihg/HXXxdwIP6w1KVQEbC/iN703ows3r59GzY2Nspp+vTpha536dIl1K9fHzKZTDmvQYMGkMvluHv3rnKev7/qr3LLlSunvAj13LlzkMvlKFOmjMo+b9y4gWvXrhW63xkzZsDe3l45eXh4qNvktypbtiyMjY2Rnp6mMj89LQ1ubm5a3bcUbKzMsX3eIOQ8eYauw5cgP/+fEcOurUPg6e6Ezyb+itMXb+PE+ZuIHrcCXuXLvPHra9IsQ38dxg4bgl27dmLvvjhUqFBB6nLUxv4i0g5dP7bem7Do7u6OpKQk5TRgwAC1tmdqaqryWCaTQaF4GUDkcjnKlSunsr+kpCQkJydj1KhRhW5v3LhxyMrKUk537txRq753MTMzQ2BQMOIOHlDOUygUiIs7gDr16mt136XN1toCOxcMwfMXBfg4dhHynuerLLeyMINCIeD133opBAGCABi99qGBNM9QX4eCICB22BBs37YFe34/CC9vb6lL0gj2F5F26Pqx9d58DW1iYgIfH593rletWjVs2rQJgiAoRxePHDkCW1vbIn/SDAoKQmpqKkxMTODl5VWk55ibmyu/si4tw2KHo1+faAQHhyAktA7mzpmNJ7m56BUdU6p1vI21pRkqezgrH3uVLwN/3/J4nP0Ed1Ifw9HOCh5ujijnYg8A8PV6eb1H2sNspD3MeRkU5w+GpYUZYsavhJ21BeysX95jMeOxHAqFgAPHLmN6bCRmj+uCBWsTYCSTYWRMC+QXFCDh1JXSb7QIuVyOa1evKh/fvHED55KS4OjkBE9PTwkrU48+vA6LK3boYKxbuwYbNm+Dja2t8poje3t7WFpaSlydethf+sNQzxmG2i5dPrb09tY5crkcV///xRIYGIgffvgBzZo1g5OaL5Z79+7B19cXMTExGDJkCJKTk9G3b18MHjxY+Yvnpk2bIiAgALNnz1Y+LzIyEg4ODlixYgUEQUDjxo2Rk5ODWbNmwdfXF/fv38dvv/2Gjz76CCEhIe+sozRunQMAC+bNxY8/fIu01FT41w7A9z/OQZ26dbW2P6B4t85pFFwFvy/9/I35v2w/hs8m/ooe7epiyZSebyyfunAXpi3aJfp8APBr8xVup7z8wVF43aoY3781qvuUg0Ih4Nzlu5g0bwdOnL9Z5Fq1feucQwnxaBnR7I35PXpGY8myFVrdt7ZJ8TrUJkvTwkekFy9djp7RvUu3GC1gf+kHQz1nGGq7gNI/top66xy9DYvx8fFo1uzNF0t0dDRWrFih1rYTEhIwatQonDt3Dk5OToiOjsbUqVNhYvJyIPZdYREAcnJyMH78eGzatAkZGRlwc3ND48aNMWPGjCJdj1haYVEKJb3Poq4rzfssEhERqcvgw6KhY1jUPwyLRESkTwz+ptxEREREpH0Mi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEmUidQH0/nl8cq7UJWiFY9vvpS5BKx7/NkLqEoiISEIcWSQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGxffcwvnz4OfjBQcbCzQKq4uTJ05IXZJG6Hq7GtQsj42TI3F9TX883TsC7er7vLHOl73CcH1NfzzaPgy/ffMxKrs7KJd5utphwX9a4NLKvni0fRj+Wv4pJvQMg6nJP4f0+B718XTviDemB9uGlUYTi0XX+6u4Fi9cgNBAf7g42cHFyQ5NGtbH3j27pS5LYwytv15hu/TDtzNnoEG9UDg72sLT3QWdO0XiSnKy1GVphK72ld6GxRkzZiA0NBS2trZwcXFBZGQkkjXwYlmxYgUcHBzUL1APbFi/DmNGDcf4CRNx9MQZ+PvXRvu2LZGeni51aWrRh3ZZW5ji/PUMxM49UOjyEV1CMahDIIb9vB+NP1+D3GcvsGN6J5ibGgMA/DycYGQkw5Cf9iHos5UYvSgefdv6Y0pMI+U2Zm88Ba9uC1Smi7ceYPMh3Tqp6kN/FVf5ChXw9fRv8Mfx0zhy7BSaNgtH544dcPGvv6QuTW2G2F8A26VPEg8lYMDAwUg4fAw7d+9D/osX+LBNC+Tm5kpdmlp0ua9kgiAIUhdREq1atUK3bt0QGhqK/Px8fPHFF7hw4QIuXrwIa2vrEm93xYoViI2NRWZmpuaKLYHs7GzY29sj7WEW7OzstLKPRmF1ERwSitlz5gIAFAoFfLw9MHDwUIwaPVYr+ywNUrXLse33JXre070j0GXSNuw4elU57/qa/piz+TRmbzwFALCzMsOtdQPx2Xd7sCGh8LD3n49D0O/D2qje+7+FLq9VyRknFvRCxIi1OHLhXpHre/zbiGK0pvgM9XX4b+4uTpj+zbfo3edTqUtRi6H2F9ulvzIyMuDp7oJ9BxPQsFFjqcspMSn6Kjs7G65l7JGV9fasobcji3v27EHv3r1Ro0YN1K5dGytWrMDt27dx+vTpEm8zPj4eMTExyMrKgkwmg0wmw6RJkzB37lzUrFlTud7WrVshk8mwcOFC5byIiAhMmDBB+XjBggWoXLkyzMzM4Ofnh19++aXEdWnD8+fPcfbMaYQ3j1DOMzIyQnh4BE4cOyphZeoxhHZ5udmjXBkbHDxzSzkv+8lznLycgrrV3EWfZ2dtjkc5z0SXx7SqhSt3HhUrKGqbIfTXuxQUFGD9urXIzc1F3Xr1pS5HLYbaX2yXfsvOygIAODo6SVxJyel6X+ltWPy3rP9/sTg5lfzFEhYWhtmzZ8POzg4pKSlISUnByJEj0aRJE1y8eBEZGRkAgISEBJQtWxbx8fEAgBcvXuDo0aNo2rQpAGDLli34/PPPMWLECFy4cAH9+/dHTEwM4uLi1GqjJj148AAFBQVwcXFVme/i6orU1FSJqlKfIbTLzenlyHh65hOV+emZT+DqVPioeSV3BwzsEIj/7vqz0OXmpsboGl4VK/de0GyxajKE/hJz4fx5lHWwgb21OYYNHoB1G7egWvXqUpelFkPtL7ZLfykUCowaEYv6YQ1Q47VBHX2j631lEGFRoVAgNjYWDRo0UBkBLC4zMzPY29tDJpPBzc0Nbm5usLGxQc2aNeHk5ISEhAQAL0cgR4wYoXx84sQJvHjxAmFhYQCA7777Dr1798agQYPg6+uL4cOHo2PHjvjuu+9E952Xl4fs7GyViago3MvYYPu0jth86AqW7z5f6DodGlSBraUZft2n/9fM6QtfPz8cP5WEQ0eOo1//gejXJxqXLl6UuiwigxI7dDD++usCVq1eK3UpBs0gwuLgwYNx4cIFrF0r/mJJTEyEjY2Nclq9enWRty+TydC4cWPEx8cjMzMTFy9exKBBg5CXl4fLly8jISEBoaGhsLKyAgBcunQJDRo0UNlGgwYNcOnSJdF9zJgxA/b29srJw8OjyPWVRNmyZWFsbIz09DSV+elpaXBzc9PqvrXJENqV+ujlRdouDlYq810crJD2SPUC7nJO1tgzqzOOXbyPwT/9LrrN3q1qYvfx62+MVkrNEPpLjJmZGSr7+CAoOBhfT5uBWv61Me/nn6QuSy2G2l9sl36KHTYEu3btxN59cahQoYLU5ahF1/tK78PikCFDsHPnTsTFvf3FEhISgqSkJOXUvn37Yu2nadOmiI+PR2JiIgIDA2FnZ6cMkAkJCWjSpIla7Rg3bhyysrKU0507d9Ta3ruYmZkhMCgYcQf/+TWuQqFAXNwB1NHj66oMoV03U7OQ8lCOZoGeynm2VmYIrVoOxy/dV85zL2ODvd92wdm/0/HZ93sh9lO1iq52aFLbEyt07CtowDD6q6gUCgXy8vKkLkMthtpfbJd+EQQBscOGYPu2Ldjz+0F4eXtLXZLadL2vTKQuoKQEQcDQoUOxZcsWxMfHw/sdLxZLS0v4+Lx5L7t/MzMzQ0FBwRvzmzRpgtjYWGzYsEF5bWLTpk2xf/9+HDlyBCNG/POL0WrVquHIkSOIjo5Wzjty5Aiqv+V6JXNzc5ibm7+zPk0aFjsc/fpEIzg4BCGhdTB3zmw8yc1Fr+iYUq1D0/ShXdYWpir3TfRys4N/JWc8znmGOxk5mLf1DMZ0r4er9zJxMzULE6MbIOWhHNv/ePmL6VdB8XZ6NsYtSYCzvaVyW2mPVUcPo1vWROojOfaevFEqbSsufeiv4vpy/Di0bNUaHh6eyMnJwbq1a3AoIR47du2VujS1GWJ/AWyXPokdOhjr1q7Bhs3bYGNrq7ymz97eHpaWlu94tu7S5b7S27A4ePBgrFmzBtu2bYOtBl8sXl5ekMvlOHDgAGrXrg0rKytYWVnB398fjo6OWLNmDXbu3AngZVgcOXIkZDKZytfOo0aNQpcuXRAYGIiIiAjs2LEDmzdvxv79+9VrtIZ17tIVDzIyMGXyV0hLTYV/7QBs27kHrq6u736yDtOHdgX5uuL3b7sqH88a0AwA8MvvF/DZ93vx/fqTsLIwxdzPP4CDjTn++Ose2o/fjLwXLz/IhAdVhE95R/iUd8S1Nf1Vtm3Z8p9b+MhkQM8WNfHLvr+gUOjmXbL0ob+KKyM9HZ/G9EJqSgrs7e1Rs5Y/duzai+YRH0hdmtoMsb8AtkufLF60AADQonlT1flLl6NndO/SL0hDdLmv9PY+izKZrND5y5cvR+/evdXa9sCBA7FhwwY8fPgQEydOxKRJkwAAkZGR+O233/D48WPY2NhAoVCgbNmy8PPzw9Gjqj9tX7BgAb777jvcuXMH3t7emDBhAnr27FnkGkrjPoukWSW9z6Ku0/Z9FomISBpFvc+i3oZFQ8ewqH8YFomISJ8Y/E25iYiIiEj7GBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCTKROoCiAzFo53DpS5BKxw7L5G6BK14vKGf1CVonEIhSF2CVhgZyaQugei9xpFFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJeq/DopeXF2bPni11GZJaOH8e/Hy84GBjgUZhdXHyxAmpS1Lb4cRD6BTZDt6e7rA0lWH7tq1Sl6S2qVMmwcrMSGUKqFlN6rLeycbCFN/2qYfkRd3waG0M4ma0R7BPWeVyawsT/NgvDFeXdMejtTE4M+dj9G35T7s8nW3wdEu/QqeOYd5SNKlY9P34Opx4CB9/1B6VvcrD2twIO147ll68eIEJX4xBaJA/nB1tUNmrPPr2iUbK/fvSFawmfe+vf/t25gw0qBcKZ0dbeLq7oHOnSFxJTpa6LLUZ4jle1/tKp8LiggUL4O/vDzs7O9jZ2aF+/frYvXu32ttdsWIFHBwc1C/QwGxYvw5jRg3H+AkTcfTEGfj710b7ti2Rnp4udWlqyc3NRS3/2pg9Z57UpWhU9eo1cP32feW0Pz5R6pLeacHgRgivXQF9fopHSOwm7E+6i98mtYW7kxUAYGZMPXwQWAExs+MRMHQD5u64gB/7haFtqCcA4O7DXHjF/KoyTfnfKeQ8fY69Z+5I2bR3MoTj6+Wx5I8ff5r7xrInT54g6exZjP1iAo4cO43/rduEv68ko3OnDhJUqj5D6K9/SzyUgAEDByPh8DHs3L0P+S9e4MM2LZCbmyt1aWoxxHO8rveVidQFvK5ChQr45ptvUKVKFQiCgJUrV6JDhw44e/YsatSoIXV5AF5+mjY1NZW6DI2YM/sHxHzaD716xwAAfp6/ELt3/4aVK5Zh1OixEldXci1btUbLVq2lLkPjjE1M4ObmJnUZRWZhZozI+t7oPON3HLmYCgCYtu4M2oR6ol+r6pi85hTqVXXFr3F/I/GvFADAsn2X8WnLqgip4oLfTt6GQiEgLfOpynbb1/XCpiM3kPssv9TbVByGcHy97Viyt7fHzt2/q8z7YfbPaNygLu7cvg0PT8/SKFFjDKG//m37b3tUHi/+7wp4urvg7JnTaNiosURVqc8Qz/G63lc6NbLYrl07tGnTBlWqVIGvry+mTZsGGxsbHDt2rMTbjI+PR0xMDLKysiCTySCTyTBp0iTl8idPnqBPnz6wtbWFp6cnFi9erFx28+ZNyGQyrFu3Dk2aNIGFhQVWr14NAFi6dCmqVasGCwsLVK1aFfPnz1fZ7507d9ClSxc4ODjAyckJHTp0wM2bN0vcDk17/vw5zp45jfDmEcp5RkZGCA+PwIljRyWsjMRcu/o3KlUsj+p+lRHTqwfu3L4tdUlvZWJkBBNjIzx7XqAy/9nzAoRVcwUAHLuchg9DKypHGhvXLIcq7vbYn3S30G0GViqLgEplsXL/Ze0Wr6b39fh6dZ6117Nvct6X/srOygIAODo6SVwJvYuu9ZVOhcXXFRQUYO3atcjNzUX9+vVLvJ2wsDDMnj0bdnZ2SElJQUpKCkaOHKlc/v333yMkJARnz57FoEGDMHDgQCT/6zqBsWPH4vPPP8elS5fQsmVLrF69Gl999RWmTZuGS5cuYfr06fjyyy+xcuVKAC9HH1u2bAlbW1skJibiyJEjsLGxQatWrfD8+fMSt0WTHjx4gIKCAri4uKrMd3F1RWpqqkRVkZjQOnWxeOlybNuxGz/9PB83b95ARHhj5OTkSF2aKPmzFzh2OQ3jugSinKMVjIxk6NbEB3V9XeDm+DIcDl/yBy7dfYxr/41C9oZPsf2r1ohd/IdyJPLfoiP8cOnOYxxL1u2vBt/H4+vZs2f4cvxYdO7aHXZ2dlKXUyzvQ38pFAqMGhGL+mENUKNmTanLobfQxb7Sqa+hAeD8+fOoX78+nj17BhsbG2zZsgXVq1cv8fbMzMxgb28PmUxW6Fd4bdq0waBBgwAAY8aMwY8//oi4uDj4+fkp14mNjUXHjh2VjydOnIjvv/9eOc/b2xsXL17EokWLEB0djXXr1kGhUGDp0qWQyWQAgOXLl8PBwQHx8fFo0aLFG3Xk5eUhLy9P+Tg7O7vEbSbD8/pXLrX8/RFapy6q+nhh08b16B3zqYSVvV2fn+KwaEgTXF8WhfwCBZKuP8D6w9cQWPnlj1wGta2BOr4u6DRtL25nyNGwuhtmfxaGlEe5iPtT9YcSFmbG6Nq4Mr5Zf1aKptBbvHjxAj0/6QpBEPDTz/Pf/QQqdbFDB+Ovvy7gQPxhqUuhd9DFvtK5sOjn54ekpCRkZWVh48aNiI6ORkJCQqGBMTExEa1b//MmumjRIkRFRRVrf/7+/sp/vwqU/76gOSQkRPnv3NxcXLt2DZ9++in69eunnJ+fnw97e3sAwLlz53D16lXY2tqqbOfZs2e4du1aoXXMmDEDkydPLlbt6ihbtiyMjY2Rnp6mMj89LU2vrot7Xzk4OMCnii+uX70qdSlvdSM1By0m7ISVuQnsrEyR+vgpfhkRjhupObAwM8bkqFB0nbkPe06//LHKhVuP4O9dBrEd/N8Iix/V94aVmQlWx/8tRVOK5X06vl4Fxdu3b2HX3gN6N6oIGH5/xQ4bgl27dmL/wUOoUKGC1OXQW+hqX+lcWDQzM4OPjw8AIDg4GCdPnsRPP/2ERYsWvbFuSEgIkpKSlI9dXV3fWOdd/v1jFZlMBoVCoTLP2tpa+W+5XA4AWLJkCerWrauynrGxsXKd4OBg5fWNr3N2di60jnHjxmH48OHKx9nZ2fDw8ChGS4rHzMwMgUHBiDt4AO07RAJ4OfQdF3cAAwYN0dp+STPkcjluXL8Gt6geUpdSJE/y8vEkLx8O1maICKyA8StPwNTYCGamxlAIgsq6BQoBRkayN7bRO8IPv528hQfZz0qr7BJ7X46vV0Hx6tW/sfv3gyhTpozUJZWIofaXIAj4z+dDsX3bFvy+Px5e3rp/u6n3la73lc6FxX9TKBQqX8++ztLSUhks38bMzAwFBQXvXK8oXF1d4e7ujuvXr4uOYgYFBWHdunVwcXEp8qdsc3NzmJuba6TGohoWOxz9+kQjODgEIaF1MHfObDzJzUWv6JhSrUPT5HI5rr024nbzxg2cS0qCo5MTPPXsF5qvjBszEm3atoOnZ0WkpNzH1CmTYGxsjM5du0td2ltFBFSATAZcuZeFyuXsMD26Lq7czcSqg8nILxBw6MJ9TI+ui6d5BbidIUejGm6IaloFY5ar/qitkpsdGlYvh8ipe0T2pHsM4fiSy+W4du21Y+nmDZw7lwQnRye4lSuHqG6dkZR0Bhu37EBBQYHy+j4nJyeYmZlJVXaJGEJ//Vvs0MFYt3YNNmzeBhtbW2X/2Nvbw9LSUuLqSs4Qz/G63lc6FRbHjRuH1q1bw9PTEzk5OVizZg3i4+Oxd+9etbbr5eUFuVyOAwcOoHbt2rCysoKVlVWJtzd58mQMGzYM9vb2aNWqFfLy8nDq1Ck8fvwYw4cPR1RUFL799lt06NABU6ZMQYUKFXDr1i1s3rwZo0eP1pmh5c5duuJBRgamTP4Kaamp8K8dgG0795RohFaXnDl9Ci0jmikfjxn1csS2R89oLFm2QqKq1HPv7j1E9/wEjx4+RFlnZ4SFNUR84lHRkWpdYW9lhik9Q1G+jDUe5eRh27EbmLj6JPILXo4m9vr+IKb0CMWK/zSDo405bmfIMWnNKSzZe0llO9HNfXHvYa7or6R1kSEcX2dOn0LrFuHKx2NHjwAARPWMxvgJE/Hbzu0AgPqhgSrP2/37QTRu0rTU6tQEQ+ivf1u8aAEAoEXzpqrzly5Hz+jepV+QhhjiOV7X+0omCP/6DkhCn376KQ4cOICUlBTY29vD398fY8aMwQcffKD2tgcOHIgNGzbg4cOHmDhxIiZNmgQvLy/ExsYiNjZWuV5AQAAiIyMxadIk3Lx5E97e3jh79iwCAgJUtrdmzRp8++23uHjxIqytrVGrVi3Exsbio48+AgCkpqZizJgx2LVrF3JyclC+fHk0b94c3333XZFGG7Ozs2Fvb4+0h1l6eQ3Q+0iHDiWNcuqyVOoStOLxhn7vXknPKBSG+Ros7LIEIlJfdnY2XMvYIyvr7VlDp8Ii/YNhUf8Y6qHEsKg/GBaJqDiKGhZ19j6LRERERCQ9hkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIlInUBRAZCplMJnUJWvF4Qz+pS9CKMt2XS12Cxj38X4zUJRAZLEEQpC5B44raJo4sEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWHzN1q1b4ePjA2NjY8TGxkpdTqlYOH8e/Hy84GBjgUZhdXHyxAmpS9IIQ2vXtzNnoEG9UDg72sLT3QWdO0XiSnKy1GVpjL71l42FCWb1roNL8zvjweqeODC1LYIql1Uuz90QU+gU276mch1HGzMsG9YYKSujcG/FJ5g/sAGsLUykaE6x6Vt/Fce3s76BpakMI4fHSl2Kxhhafx1OPIROke3g7ekOS1MZtm/bKnVJGjF1yiRYmRmpTAE1q0ldFgCgSGem7du3F3mD7du3L3ExxfXNN99g3Lhx+PzzzzF79my1t9e/f3/ExMRg2LBhsLW1Vb9AHbdh/TqMGTUcP89biNA6dTF3zmy0b9sS5/5KhouLi9TllZghtivxUAIGDByM4JBQ5OfnY+KXX+DDNi1w9s+LsLa2lro8tehjf80b2BDVPRzQ9+dDSHn8BN0aVcbOr1oi+D9bkPLoCSr1W6uyfouA8pg/sCG2HrupnLdsWBO4OVqi3dd7YWpihIWDGmFu/zDE/HSolFtTPPrYX0V16uRJ/HfJItSq5S91KRpjiP2Vm5uLWv610at3H3Tr3FHqcjSqevUa2Llnn/KxiYlufICUCYIgvGslI6OiDUDKZDIUFBSoXVRRnDx5El26dIGdnR2aNWumdliUy+WwtbXFwYMH0axZM80UKeLFixcwNTV96zrZ2dmwt7dH2sMs2NnZaaWORmF1ERwSitlz5gIAFAoFfLw9MHDwUIwaPVYr+ywNhtqu12VkZMDT3QX7DiagYaPGUpejFqn6q0z35SV6noWZMdJW9UCXWQew98xd5fzDM9vh97P3MGXtmTees3ZUOGwtTdF2yl4AgF95e5yZ3RENx2zH2esPAQAfBJTH5nEfoMqAdUh9/LREtT38X0yJnlcchnp8yeVy1K8ThJ9+no9vpk+Ff+0AfPfDbKnLUpuh9tcrlqYyrNu4Be07RGp9X0WIS2qZOmUSdmzfhuOnzmp1P6/Lzs6GW1kHZGW9PWsUKQUqFIoiTaUVFOVyOaKiorBkyRI4Ojqqvb34+HjlSGJ4eDhkMhni4+MBAJs2bUKNGjVgbm4OLy8vfP/99yrPlclk2Lp1q8o8BwcHrFixAgBw8+ZNyGQyrFu3Dk2aNIGFhQVWr16tds3qev78Oc6eOY3w5hHKeUZGRggPj8CJY0clrEw9htquf8vOygIAODo6SVyJevSxv0yMZDAxNkLec9Xz3dPnBahf9c2RGhd7C7QK8sDKg38r59X1dcFjeZ4yKALAwT/vQyEICK3irL3i1aSP/VVUsUMHo1Xrtipt03eG3F+G6trVv1GpYnlU96uMmF49cOf2balLAqDmNYvPnj3TVB3FMnjwYLRt2xYREZo5qMPCwpD8/9d/bdq0CSkpKQgLC8Pp06fRpUsXdOvWDefPn8ekSZPw5ZdfKoNgcYwdOxaff/45Ll26hJYtW76xPC8vD9nZ2SqTNj148AAFBQVwcXFVme/i6orU1FSt7lubDLVdr1MoFBg1Ihb1wxqgRs2a736CDtPH/pI/y8ex5HSM+bg23BwtYWQkQ7dGlVDX1xlujlZvrB/VxAc5z15g2/FbynkuDpbIyFY9fxYoBDyW58HVwVLrbSgpfeyvoli/bi2Szp7B19NmSF2KRhlqfxmq0Dp1sXjpcmzbsRs//TwfN2/eQER4Y+Tk5EhdWtGuWXxdQUEBpk+fjoULFyItLQ1XrlxBpUqV8OWXX8LLywuffvqpNupUWrt2Lc6cOYOTJ09qbJtmZmbKazecnJzg5uYGAPjhhx/QvHlzfPnllwAAX19fXLx4Ed9++y169+5drH3ExsaiY0fxaytmzJiByZMnl6wB9F6JHToYf/11AQfiD0tdynur78+HsGBQQ1xb3A35BQok3XiIDYdvIKBSmTfW7RleBesSryHvRel880LFc+fOHYwa/jl27t4HCwsLqcuh91jLVq2V/67l74/QOnVR1ccLmzauR+8Y7Wardyn2yOK0adOwYsUKzJo1C2ZmZsr5NWvWxNKlSzVa3L/duXMHn3/+OVavXl3kgzoxMRE2NjbKqThfAV+6dAkNGjRQmdegQQP8/fffxf7KPSQk5K3Lx40bh6ysLOV0586dYm2/uMqWLQtjY2Okp6epzE9PS1OGZX1kqO16JXbYEOzatRN798WhQoUKUpejNn3trxtpOWg1cTece/wCvwHr0WTcTpiYGOFmuuoIQFhVV/iVd8DKA1dU5qdnPoWzneo5zNhIBkcbc6Rllux6xdKgr/31NmfPnEZ6ejrq1wmCjYUJbCxMkHgoAfPnzoGNhUmpXV6lDYbYX+8TBwcH+FTxxfWrV6UupfhhcdWqVVi8eDGioqJgbGysnF+7dm1cvnxZo8X92+nTLw/qoKAgmJiYwMTEBAkJCZgzZw5MTAo/qENCQpCUlKScNP1rbZlM9sZFry9evHhjvXf9YtXc3Bx2dnYqkzaZmZkhMCgYcQcPKOcpFArExR1AnXr1tbpvbTLUdgmCgNhhQ7B92xbs+f0gvLy9pS5JI/S9v57k5SM18ykcrM0QUdsdO0+qXl8U3bwKzlx7gPO3HqvMP34lHY425iojkU1rloORTIaTf2eUSu0loe/9VZhm4c1x6ux5HD+VpJyCgkPQrXsUjp9KUnmf0zeG2F/vE7lcjhvXr8GtXDmpSyn+19D37t2Dj4/PG/MVCkWhIUmTmjdvjvPnz6vMi4mJQdWqVTFmzJhCD2pLS8tC6y2KatWq4ciRIyrzjhw5Al9fX+W+nJ2dkZKSolz+999/48mTJyXaX2kbFjsc/fpEIzg4BCGhdTB3zmw8yc1Fr2jt/6JSmwyxXbFDB2Pd2jXYsHkbbGxtldcb2dvbw9JSd69xKwp97K+I2u6QyWS4cj8Lld3sMK1nCK7cy8Ivcf/8iMXW0hQf1fPCuFVvXjKTfC8Lv5+9i3n9G2DYkj9gamyE7z+th41/XC/xL6FLiz7219vY2tq+ce2vtbU1nMqU0ftrggHD6y/gZYi69tpo280bN3AuKQmOTk7w9PSUsDL1jBszEm3atoOnZ0WkpNzH1CmTYGxsjM5du0tdWvHDYvXq1ZGYmIiKFSuqzN+4cSMCAwM1VlhhbG1tUbOQg7pMmTJvzNeEESNGIDQ0FF9//TW6du2Ko0ePYu7cuZg/f75ynfDwcMydOxf169dHQUEBxowZ887b4uiKzl264kFGBqZM/gppqanwrx2AbTv3wNXV9d1P1mGG2K7FixYAAFo0b6o6f+ly9IzuXfoFaZA+9pedlRkmfxKM8mWs8Vieh63Hb2Hy/04jv+Cfbxk+buANmUyGDUeuF7qNPnMS8MOn9fDbV62gEARsO3YTI5cfL60mlJg+9tf7zBD768zpU2gZ8c8t7saMGg4A6NEzGkuWrZCoKvXdu3sP0T0/waOHD1HW2RlhYQ0Rn3gUzs7S3yGhSPdZfN22bdsQHR2NcePGYcqUKZg8eTKSk5OxatUq7Ny5Ex988IG2ai1U06ZNERAQoPZ9FjMzM+Ho6Ii4uDg0bdpUOX/Tpk346quv8Pfff6NcuXIYOnQoRo4cqVx+//59xMTE4MiRI3B3d8dPP/2E7t27Y/bs2ejduzdu3rwJb29vnD17FgEBAUWupzTus0j0PivpfRZ1WWncZ5HofaXt+yxKoaj3WSx2WARe/mhkypQpOHfuHORyOYKCgvDVV1+hRYsWahVN/2BYJNIuhkUiKo73OSyW6O/INGrUCPv27Xv3ikRERESk10r8RwdPnTqFS5cuAXh5HWNwcLDGiiIiIiIi3VDssHj37l10794dR44cgYODA4CX1/uFhYVh7dq1BnHvNyIiIiJ6qdj3Wezbty9evHiBS5cu4dGjR3j06BEuXboEhUKBvn37aqNGIiIiIpJIsUcWExIS8Mcff8DPz085z8/PDz///DMaNWqk0eKIiIiISFrFHln08PAo9ObbBQUFcHd310hRRERERKQbih0Wv/32WwwdOhSnTp1Szjt16hQ+//xzfPfddxotjoiIiIikVaSvoR0dHSGTyZSPc3NzUbduXZiYvHx6fn4+TExM0KdPH0RGRmqlUCIiIiIqfUUKi+r+dRQiIiIi0k9FCovR0dHaroOIiIiIdFCJb8oNAM+ePcPz589V5vFP0xEREREZjmL/wCU3NxdDhgyBi4sLrK2t4ejoqDIRERERkeEodlgcPXo0Dh48iAULFsDc3BxLly7F5MmT4e7ujlWrVmmjRiIiIiKSSLG/ht6xYwdWrVqFpk2bIiYmBo0aNYKPjw8qVqyI1atXIyoqSht1EhEREZEEij2y+OjRI1SqVAnAy+sTHz16BABo2LAhDh06pNnqiIiIiEhSxQ6LlSpVwo0bNwAAVatWxfr16wG8HHF0cHDQaHFEREREJK1ih8WYmBicO3cOADB27FjMmzcPFhYW+M9//oNRo0ZpvEAiIiIikk6xr1n8z3/+o/x3REQELl++jNOnT8PHxwf+/v4aLY6IiIiIpKXWfRYBoGLFiqhYsaImaiEiIiIiHVOksDhnzpwib3DYsGElLoaIiIiIdItMEAThXSt5e3sXbWMyGa5fv652UQRkZ2fD3t4eaQ+z+FdxiKhIKg/bInUJWnH1p0ipS9AKmUwmdQn0nsvOzoZrGXtkZb09axRpZPHVr5+JiIiI6P1S7F9DExEREdH7g2GRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREokoUFhMTE9GjRw/Ur18f9+7dAwD88ssvOHz4sEaLIyIiIiJpFTssbtq0CS1btoSlpSXOnj2LvLw8AEBWVhamT5+u8QKJiIiISDrFDotTp07FwoULsWTJEpiamirnN2jQAGfOnNFocUREREQkrWKHxeTkZDRu3PiN+fb29sjMzNRETURERESkI4odFt3c3HD16tU35h8+fBiVKlXSSFFEREREpBuKHRb79euHzz//HMePH4dMJsP9+/exevVqjBw5EgMHDtRGjUREREQkkSL9bejXjR07FgqFAs2bN8eTJ0/QuHFjmJubY+TIkRg6dKg2aiQiIiIiiRQ7LMpkMowfPx6jRo3C1atXIZfLUb16ddjY2GijPiIiIiKSULHD4itmZmaoXr26JmshIiIiIh1T7LDYrFkzyGQy0eUHDx5UqyAiIiIi0h3FDosBAQEqj1+8eIGkpCRcuHAB0dHRmqqLiIiIiHRAscPijz/+WOj8SZMmQS6Xq10QEREREemOEv1t6ML06NEDy5Yt09TmiIiIiEgHaCwsHj16FBYWFpraHBERERHpgGKHxY4dO6pMH330EerVq4eYmBj0799fGzWSFnw7cwYa1AuFs6MtPN1d0LlTJK4kJ0tdlsYsnD8Pfj5ecLCxQKOwujh54oTUJWmEIbbrcOIhdIpsB29Pd1iayrB921apS9IYfeovIxkw6sNqODqlBa7Obo8jkz9AbGs/lXWszI0xtYs/Tk1rhauz2yPuy+bo2chLZR1zEyNM61obF2a1xZUf2mFxvzooa2teii0pvqlTJsHKzEhlCqhZTeqy1Gaox5YhtkvX35OLHRbt7e1VJicnJzRt2hS7du3CxIkTtVFjqdu6dSt8fHxgbGyM2NhYrFixAg4ODlKXpVGJhxIwYOBgJBw+hp279yH/xQt82KYFcnNzpS5NbRvWr8OYUcMxfsJEHD1xBv7+tdG+bUukp6dLXZpaDLVdubm5qOVfG7PnzJO6FI3St/4a3MIXvRp7Y8L6c2g6ZT+mb/0LAz+ogj5N//kzrhM71ULT6q4YuuIUmk7Zj6UHr2Fql9r4oJabcp1JH9fCB7Xc0H/pcXT6MRFu9pZY+lldKZpULNWr18D12/eV0/74RKlLUpuhHluG2C5df0+WCYIgFHXlgoICHDlyBLVq1YKjo6M263qnSZMmYfLkySrz/Pz8cPnyZbW37erqipiYGAwbNgy2trYwMTFBTk4OXFxc1N52UWVnZ8Pe3h5pD7NgZ2en9f1lZGTA090F+w4moGGjxlrfnzY1CquL4JBQzJ4zFwCgUCjg4+2BgYOHYtTosRJXV3KG2q7XWZrKsG7jFrTvECl1KWqTor8qD9tS4ueuHFgfGTnPMPLXs8p5i/vVwbMXBRi24jQA4MCE5thx+i5m7/5nxGP32KaI+ysNs3Zcgq2FCf6c1RZDlp/Eb2fvv6zJ1QaHJn6AdrPicebm4xLVdvWnyBK3qyimTpmEHdu34fips+9cV5Pedhs6TTOkY+t1htqu0npPzs7OhmsZe2RlvT1rFGtk0djYGC1atEBmZqa69WlEjRo1kJKSopwOHz6s9jblcjnS09PRsmVLuLu7w9bWFpaWlqUaFKWQnZUFAHB0dJK4EvU8f/4cZ8+cRnjzCOU8IyMjhIdH4MSxoxJWph5DbZeh0sf+OnX9IRr6OaOSy8u/xlW9vB3qVC6DuL/SVNb5wL8c3OxfXp8e5lsWlVxskHDp5Wipv6cDzEyMkHg5Q/mca2ly3H34BMGVdPvccu3q36hUsTyq+1VGTK8euHP7ttQl0XtM196Ti/01dM2aNXH9+nVt1FJsJiYmcHNzU05ly5ZVa3vx8fGwtbUFAISHh0MmkyE+Pl7la+grV65AJpO9MYL5448/onLlysrHFy5cQOvWrWFjYwNXV1f07NkTDx48UKs+bVEoFBg1Ihb1wxqgRs2aUpejlgcPHqCgoAAuLq4q811cXZGamipRVeoz1HYZKn3sr7m/X8G2U/eQ8FUEbv7cAXvHhWNp3DVsOXlXuc6X6//E3yk5OD2jNW7+3AG/Dg7D+HXncPzqQwCAs50F8l4UIPvpC5VtZ+Q8g7Od7v4AMrROXSxeuhzbduzGTz/Px82bNxAR3hg5OTlSl0bvIV18Ty52WJw6dSpGjhyJnTt3IiUlBdnZ2SpTafr777/h7u6OSpUqISoqCrfV/CQYFhaG5P+/oHTTpk1ISUlBWFiYyjq+vr4ICQnB6tWrVeavXr0an3zyCQAgMzMT4eHhCAwMxKlTp7Bnzx6kpaWhS5cuovvOy8uT7P8yduhg/PXXBaxavbbU9klEuqVdUHl0rFMBg5efRKsZcYhddRoDmldB57qeynVimlZCkLcjei84itbfxGHK5guY1rU2Gvk5S1i5+lq2ao2OH3dGLX9/fNCiJbZs/w1ZmZnYtHG91KXRe0gX35OLfVPuNm3aAADat2+vcr2FIAiQyWQoKCjQXHVvUbduXaxYsQJ+fn5ISUnB5MmT0ahRI1y4cEE5OlhcZmZmyq+bnZyc4ObmVuh6UVFRmDt3Lr7++msAL0cbT58+jV9//RUAMHfuXAQGBmL69OnK5yxbtgweHh64cuUKfH1939jmjBkz3rgGszTEDhuCXbt2Yv/BQ6hQoUKp71/TypYtC2NjY6Snp6nMT09LE+1PfWCo7TJU+thfX3asibl7r2D76XsAgMv3s1HByQpDWvpiw/HbsDA1wtj2NdB38TEcuPCyXZfuZaNGBXv0j6iCxOQMZGQ/g7mpMewsTVVGF51tLZCR/UySdpWEg4MDfKr44vrVq1KXQu8ZXX1PLvbIYlxcnHI6ePCgcnr1uLS0bt0anTt3hr+/P1q2bIldu3YhMzMT69cX/kkwMTERNjY2yunfI4PF0a1bN9y8eRPHjh0D8HJUMSgoCFWrVgUAnDt3DnFxcSr7e7Xs2rVrhW5z3LhxyMrKUk537twpcX1FIQgCYocNwfZtW7Dn94Pw8vbW6v5Ki5mZGQKDghF38IBynkKhQFzcAdSpV1/CytRjqO0yVPrYX5amJvj3zx0LBAFG/z8oYGJsBDMTIygUqusoFAKM/v+d5M/bmXier0DD10YaK7vYoEIZK5y+/kib5WuUXC7HjevX4FaunNSl0HtC19+Tiz2y6O3tDQ8Pjzd+xSUIgtYDzts4ODjA19cXV0U+CYaEhCApKUn52NXVtdD1isLNzQ3h4eFYs2YN6tWrhzVr1mDgwIHK5XK5HO3atcPMmTPfeG45kZOPubk5zM1L715ksUMHY93aNdiweRtsbG2V11HZ29vD0tKy1OrQhmGxw9GvTzSCg0MQEloHc+fMxpPcXPSKjpG6NLUYarvkcjmuvXbc3rxxA+eSkuDo5ARPT8+3PFO36Vt/7TufgmGt/HDv8RMk389BTQ97fBbug7VHbwEA5M/y8ceVDEzoWBPPXhTg7qMnqF+lLDrV9cSUTecBADnP8rH2j5uY2KkWMp88R87TfEzt6o9T1x+W+JfQpWHcmJFo07YdPD0rIiXlPqZOmQRjY2N07tpd6tLUYqjHliG2S9ffk0sUFlNSUt74dfCjR4/g7e1dal9D/5tcLse1a9fQs2fPQpdbWlrCx8dHY/uLiorC6NGj0b17d1y/fh3dunVTLgsKCsKmTZvg5eUFE5Ni/xeXisWLFgAAWjRvqjp/6XL0jO5d+gVpUOcuXfEgIwNTJn+FtNRU+NcOwLade9T6gKALDLVdZ06fQsuIZsrHY0YNBwD06BmNJctWSFSV+vStvyas/xOj21XD9K4BKGNrjrSsp/j18A38uOufH/MNWnYS4zrUwM8xIXCwMsO9R08wa/tFrEq8oVxn0sbzUAjA4n51YW5ihPhL6fhibZIELSq6e3fvIbrnJ3j08CHKOjsjLKwh4hOPwtlZv6/FNNRjyxDbpevvycW6zyLw8vYPaWlpbxxEt27dQvXq1UvtBpIjR45Eu3btULFiRdy/fx8TJ05EUlISLl68qNYBnpmZCUdHR8TFxaFp06YAgBUrViA2NlbllkE5OTlwdXWFr68vypYti/379yuX3b9/HwEBAWjSpAlGjx4NJycnXL16FWvXrsXSpUthbGz8zjpK+z6LRKT/1LnPoi7T9n0WpVKa91kkKkxR77NY5GGv4cNfJneZTIYvv/wSVlZWymUFBQU4fvw4AgICSl5xMd29exfdu3fHw4cP4ezsjIYNG+LYsWOl9knQ1tYW7dq1w/r167Fs2TKVZe7u7jhy5AjGjBmDFi1aIC8vDxUrVkSrVq1gZKSxP8dNREREpHVFHlls1uzlkG9CQgLq168PMzMz5TIzMzN4eXlh5MiRqFKlinYqfc9wZJGIiosji/qFI4skNY2PLMbFxQEAYmJi8NNPPzHAEBEREb0Hiv3ri+XLl2ujDiIiIiLSQbyAjoiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKBOpCyAiIs24NucjqUvQCrfoX6UuQStSV/aQugSiIuHIIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEgDg21nfwNJUhpHDY6UuRW2HEw+hU2Q7eHu6w9JUhu3btkpdksYsnD8Pfj5ecLCxQKOwujh54oTUJWmEobbrFUM5vvT12LKxMMGMHsE4/1MkUpZ3w96JLRFYqUyh6/7Qpw4yV/fAwFZVC11uZmKExOltkLm6B2pVdNRm2RpjyMeXoRxbr+hqXzEsasDNmzchk8mQlJQkdSklcurkSfx3ySLUquUvdSkakZubi1r+tTF7zjypS9GoDevXYcyo4Rg/YSKOnjgDf//aaN+2JdLT06UuTS2G2q5XDOn40tdja06/emhaqxz6L/gDYWN3Iu58CraOa45yjpYq630Y4oFQn7K4/+iJ6LamdA9CyuOn2i5ZYwz5+DKkYwvQ7b4yyLB479499OjRA2XKlIGlpSVq1aqFU6dOaW1/Hh4eSElJQc2aNbW2D22Ry+WIiY7C/IVL4OCoH5+S36Vlq9aYNGUqOkR+JHUpGjVn9g+I+bQfevWOQbXq1fHz/IWwtLLCyhXLpC5NLYbaLsDwji99PLYsTI3RPtQTE/93Fn9cTseNNDm+2fwnbqTloE+Er3K9co6WmBkdgn7zjiC/QFHotiJqu6NZrXL4cs2Z0ipfbYZ6fBnasQXodl8ZXFh8/PgxGjRoAFNTU+zevRsXL17E999/D0ctvpiMjY3h5uYGExMTre1DW2KHDkar1m0R3jxC6lLoLZ4/f46zZ06r9JORkRHCwyNw4thRCStTj6G26xUeX9IzMZbBxNgIz14UqMx/+rwA9X1dAAAyGbBoYAP8vPMiLt/LKnQ7znYW+KlvXfRfcARP8/K1XrcmGPLxZWjHlq73lcGFxZkzZ8LDwwPLly9HnTp14O3tjRYtWqBy5cpqbffx48eIioqCs7MzLC0tUaVKFSxfvhzAm19DT5kyBe7u7nj48KHy+W3btkWzZs2gUBT+iVUK69etRdLZM/h62gypS6F3ePDgAQoKCuDi4qoy38XVFampqRJVpT5DbRfA40tXyJ/l4/iVDIyOrAU3B0sYyWTo0sAbdaqUhavDy6+hY9vVQL5CgYV7k0W3M39AfSw/8DeSbjwqrdLVZqjHlyEeW7reVwYXFrdv346QkBB07twZLi4uCAwMxJIlS9Te7pdffomLFy9i9+7duHTpEhYsWICyZcsWuu748ePh5eWFvn37AgDmzZuHP/74AytXroSRUeH/5Xl5ecjOzlaZtOnOnTsYNfxzLF+1GhYWFlrdF9H7hseXbum/4AhkMuDyvE5IX9kd/Vv6YeMft6AQBNT2csKAllUxaKH46E3/ln6wsTDFD9v+KsWqqTA8tqShf9+bvsP169exYMECDB8+HF988QVOnjyJYcOGwczMDNHR0SXe7u3btxEYGIiQkBAAgJeXl+i6xsbG+PXXXxEQEICxY8dizpw5WLp0KTw9PUWfM2PGDEyePLnE9RXX2TOnkZ6ejvp1gpTzCgoKcDjxEBbOn4us3DwYGxuXWj30dmXLloWxsTHS09NU5qenpcHNzU2iqtRnqO3i8aVbbqbL0XbqPliZG8PW0gxpmU+xbGhD3EyXI6yqC5ztLHBhzj/XYZoYG2FqVBAGtqoK/9itaFzdDXWqlEX6yu4q2437ujU2HLmBgYuk/5qwMIZ4fBnqsaXrfWVwYVGhUCAkJATTp08HAAQGBuLChQtYuHBhoWHx9u3bqF69uvLxF198gS+++OKN9QYOHIhOnTrhzJkzaNGiBSIjIxEWFiZaR6VKlfDdd9+hf//+6Nq1Kz755JO31j1u3DgMHz5c+Tg7OxseHh7vbG9JNQtvjlNnz6vM+6xvDPz8qmLEqDF6ebAZMjMzMwQGBSPu4AG07xAJ4OVrPS7uAAYMGiJtcWow1Hbx+NJNT/IK8CTvKeytzNC8lju++t8ZbD95G/EXUlTW2zSmOdYdvo7Vh64DAMasOompG5KUy90crbBlbHP0+TkRp649hK4yxOPLUI8tXe8rgwuL5cqVUwl/AFCtWjVs2rSp0PXd3d1Vbnnj5ORU6HqtW7fGrVu3sGvXLuzbtw/NmzfH4MGD8d1334nWcujQIRgbG+PmzZvIz89/6w9gzM3NYW5u/paWaZatrS1q/OvX29bW1nAqU+aN+fpGLpfj2tWrysc3b9zAuaQkODo5vXV0V9cNix2Ofn2iERwcgpDQOpg7Zzae5OaiV3SM1KWpxRDbZajHl74eW+G1ykEmA66mZMPb1RZffxKEKylZWH3oGvILBDyWP1dZP79AgfSsZ7ia8vJyoLsPVW+lk/vs5Q9cbqTL33qbHV1gaMeXoR5bgG73lcGFxQYNGiA5WfUi5StXrqBixYqFrm9iYgIfH58ibdvZ2RnR0dGIjo5Go0aNMGrUKNGwuG7dOmzevBnx8fHo0qULvv7661L9mvl9dub0KbSMaKZ8PGbUyxHbHj2jsWTZComqUl/nLl3xICMDUyZ/hbTUVPjXDsC2nXvg6ur67ifrMENtlyHS12PLzsoUE7sGwt3JCo/lz7H95G1MXZ+E/AJB6tK0jseX/tDlvpIJgmBQR8vJkycRFhaGyZMno0uXLjhx4gT69euHxYsXIyoqqsTb/eqrrxAcHIwaNWogLy8PY8eORXp6Oo4fP46bN2/C29sbZ8+eRUBAAO7evQt/f39MnjwZQ4cOxd69e/Hhhx8iMTER9erVK9L+srOzYW9vj7SHWbCzsytx3URE+s4t+lepS9CK1JU9pC6B3nPZ2dlwLWOPrKy3Zw2D+zV0aGgotmzZgv/973+oWbMmvv76a8yePVutoAi8vJ5g3Lhx8Pf3R+PGjWFsbIy1a9e+sZ4gCOjduzfq1KmDIUNeXmfQsmVLDBw4ED169IBcLlerDiIiIqLSZHAji4aCI4tERC9xZJFIO97bkUUiIiIi0hyGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEiUidQF0PtHEASpS9AKhWE2C8ZGMqlLoPdc6soeUpegFY6dFkpdglY83jRA6hK0whDfu4raJo4sEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMPie27h/Hnw8/GCg40FGoXVxckTJ6QuSW337t1Dn+ieqOBWFk52VggN9Mfp06ekLqtYDiceQueP2sPHqzxszI2wY9tWleX9+8bAxtxIZYr8sLU0xarh25kz0KBeKJwdbeHp7oLOnSJxJTlZ6rLUtnjhAoQG+sPFyQ4uTnZo0rA+9u7ZLXVZGmOI5w1A/9plY2mKbz8NQ/KSKDxa3xdxMyMR7OOsXO5ib4nFw5rh+vKeeLj+U2yb2AaVy9m/sZ26fq7Y/XU7PFj3KdL+1wf7preHhZlxaTalWA4nHkKnyHbw9nSHpakM2/91ftRXU6dMgpWZkcoUULOa1GUBYFh8r21Yvw5jRg3H+AkTcfTEGfj710b7ti2Rnp4udWkl9vjxYzRv2hAmpqbYsmMXzpz7CzNmfQdHB0epSyuWJ7m5qOnvjx9+miu6zgctWuHarfvKafkva0qxQs1IPJSAAQMHI+HwMezcvQ/5L17gwzYtkJubK3VpailfoQK+nv4N/jh+GkeOnULTZuHo3LEDLv71l9Slqc0QzxuAfrZrwZAmCA+ogD4/HkTIsPXYf/YufpvyIdydrAEA679oCW83W3Setgf1/rMRt9Pl2DXlQ1iZmyi3UdfPFdsmtsGBpDtoNHIzGo7chIW//QWFQpCqWe+Um5uLWv61MXvOPKlL0bjq1Wvg+u37yml/fKLUJQEAZIIgSPaK8PLywq1bt96YP2jQIMybZ3gvguLIzs6Gvb090h5mwc7OTiv7aBRWF8EhoZg952UgUSgU8PH2wMDBQzFq9Fit7BMAtPmS+/KLsTh69A/sjzuktX2I0da51cbcCP9bvxntOkQq5/XvG4OszEys3bhFOzt9jbGRTOv7eCUjIwOe7i7YdzABDRs1LrX9lgZ3FydM/+Zb9O7zqdSlqEWq84a2SdEux04LS/xcCzNjZKz9FJ2n7cGe07eV84983wm/n7mN1XFXcH5BdwQNWYdLdx4DAGQy4OaKaEz89ThW7LsMAEiY9REOJN3FlDUn1WvMax5vGqCxbb2LpakM6zZuQfvXzo/aou24NHXKJOzYvg3HT53V6n5el52dDbeyDsjKenvWkHRk8eTJk0hJSVFO+/btAwB07txZyrLeC8+fP8fZM6cR3jxCOc/IyAjh4RE4ceyohJWp57edOxAUHIyobl1Qsbwr6oUGYdl/l0hdllYkHoqHVwVXBNasis+HDMTDhw+lLklt2VlZAABHRyeJK9GcgoICrF+3Frm5uahbr77U5ajFUM8b+tguE2MjmBgb4dmLApX5z57nI6xaOZibvvwa+fXlggA8zy9AWLVyAABnewvU8XNFRtZTxM2MxM2VvfD7tPYIq+ZWeg0hFdeu/o1KFcujul9lxPTqgTu3b7/7SaVA0rDo7OwMNzc35bRz505UrlwZTZo0UWu7t27dQrt27eDo6Ahra2vUqFEDu3btUi6/cOECWrduDRsbG7i6uqJnz5548OABAGDx4sVwd3eHQqFQ2WaHDh3Qp08f5eNt27YhKCgIFhYWqFSpEiZPnoz8/HzlcplMhqVLl+Kjjz6ClZUVqlSpgu3bt6vVLk168OABCgoK4OLiqjLfxdUVqampElWlvhs3rmPJooWo7OODbTv3oF//ARj5n8/x66qVUpemUREtWmLxf1di5579mDLtGxxOPISO7dugoKDg3U/WUQqFAqNGxKJ+WAPUqFlT6nLUduH8eZR1sIG9tTmGDR6AdRu3oFr16lKXpRZDPW/oY7vkT1/g2OVUjOsSjHJOVjAykqFbkyqo6+cKNycrJN/NxO30HHzdsy4crM1gamKEER0DUKGsDdycrAAA3q4vR5LGdwvBst8vocOk35B0/QF2fd2u0GsbSbtC69TF4qXLsW3Hbvz083zcvHkDEeGNkZOTI3VpunPN4vPnz/Hrr7+iT58+kMnU+9pr8ODByMvLw6FDh3D+/HnMnDkTNjY2AIDMzEyEh4cjMDAQp06dwp49e5CWloYuXboAeDmq+fDhQ8TFxSm39+jRI+zZswdRUVEAgMTERPTq1Quff/45Ll68iEWLFmHFihWYNm2aSh2TJ09Gly5d8Oeff6JNmzaIiorCo0ePCq05Ly8P2dnZKhMVn0KhQEBgEKZMnY6AwEB82vczxHzaF0uXLJK6NI3q3KUb2rZrj5o1a6Fdh0hs3LIDp0+dxKGEeKlLK7HYoYPx118XsGr1WqlL0QhfPz8cP5WEQ0eOo1//gejXJxqXLl6UuiwyIH1+PAiZDLi+vBeyNvbD4A9rYX3iVSgUAvILFOj2zV74uNsjZU0fPFrfF41ruWPPqdvK6xGN/v8Sk//uvYhfDiTj3I2HGP3fP3DlXiaiI/ykbNp7qWWr1uj4cWfU8vfHBy1aYsv235CVmYlNG9dLXRpM3r1K6di6dSsyMzPRu3dvtbd1+/ZtdOrUCbVq1QIAVKpUSbls7ty5CAwMxPTp05Xzli1bBg8PD1y5cgW+vr5o3bo11qxZg+bNmwMANm7ciLJly6JZs2YAXobAsWPHIjo6Wrn9r7/+GqNHj8bEiROV2+3duze6d+8OAJg+fTrmzJmDEydOoFWrVm/UPGPGDEyePFntthdV2bJlYWxsjPT0NJX56WlpcHPT368g3MqVQ9Vqqr8e86taDVu3bJaootLhXakSypQti+vXrqJZeHOpyym22GFDsGvXTuw/eAgVKlSQuhyNMDMzQ2UfHwBAUHAwTp86iXk//4S5C/T3g4uhnjf0tV03UrPRYvx2WJmbwM7KDKmPn+CXURG4kfZysOHstQeo95+NsLMyg5mJER5kP8Ohbz/C6asZAICUR08AQHlN4yvJdx/Dw9m2dBtDb3BwcIBPFV9cv3pV6lJ0Z2Txv//9L1q3bg13d3fRdRITE2FjY6OcVq9eXeh6w4YNw9SpU9GgQQNMnDgRf/75p3LZuXPnEBcXp7KdqlWrAgCuXbsGAIiKisKmTZuQl5cHAFi9ejW6desGIyMj5TamTJmiso1+/fohJSUFT548Ue7L399f+W9ra2vY2dmJ/rJu3LhxyMrKUk537twpyn9biZmZmSEwKBhxBw8o5ykUCsTFHUAdPb6uqn79Bvj7yhWVeVf/vgJPz4oSVVQ67t29i0cPH8LNrZzUpRSLIAiIHTYE27dtwZ7fD8LL21vqkrRGoVAozyn6ylDPG/rerid5+Uh9/AQO1maICPDAzuM3VZZnP3mOB9nPULmcPYIqOyuX30rPwf2HufAt76Cyvo+7A26nS//V5/tOLpfjxvVrcCsn/XldJ0YWb926hf3792Pz5reP/oSEhCApKUn52NXVtdD1+vbti5YtW+K3337D77//jhkzZuD777/H0KFDIZfL0a5dO8ycOfON55X7/w5p164dBEHAb7/9htDQUCQmJuLHH39UrieXyzF58mR07NjxjW1YWFgo/21qaqqyTCaTvXEt5Cvm5uYwNzcXb7wWDIsdjn59ohEcHIKQ0DqYO2c2nuTmold0TKnWoUlDPo9FeOMGmPXNdHT6uAtOnTyBZUuXYO58/RrNkcvluH7tn0+Tt27ewJ/nkuDo6ARHJyfMmDoZHT7qBFdXN1y/fg1ffjEGlSv7IKJFSwmrLr7YoYOxbu0abNi8DTa2tsrrw+zt7WFpaSlxdSX35fhxaNmqNTw8PJGTk4N1a9fgUEI8duzaK3VpajPE8wagn+2KCKwAGWS4ci8TlcvZY3rverhyLxOrDry8V2nHsErIyH6GOxk5qFmxDL7r2wA7jt/EgaS7ym38uCUJE7qH4PzNhzh3/QF6hPvBr7wDPpn5u1TNeie5XI5rr4223bxxA+eSkuDo5ARPT08JK1PPuDEj0aZtO3h6VkRKyn1MnTIJxsbG6Ny1u9Sl6UZYXL58OVxcXNC2bdu3rmdpaQmf//9a5108PDwwYMAADBgwAOPGjcOSJUswdOhQBAUFYdOmTfDy8oKJSeHNt7CwQMeOHbF69WpcvXoVfn5+CAoKUi4PCgpCcnJykWvRVZ27dMWDjAxMmfwV0lJT4V87ANt27hEN4fogJCQUazdsxsQJX2DGtK/h5eWNWd//iG6fREldWrGcOX0KbVqEKx+PHT0CABDVMxqzf56PC+fPY/Wvq5CVmYly7u4Ib/4Bvpz0dal/4FDX4kULAAAtmjdVnb90OXpG9y79gjQkIz0dn8b0QmpKCuzt7VGzlj927NqL5hEfSF2a2gzxvAHoZ7vsrcwxpWcdlC9rg0c5z7Dt6A1M/PUE8gteDkq4OVlh5qdhcLG3ROrjJ1gddwUz1p9W2cbcHedhYWaMWZ+GwdHGHOdvPsSHE3fiRqruXjd/5vQptIxopnw8ZtRwAECPntFYsmyFRFWp797de4ju+QkePXyIss7OCAtriPjEo3B2dn73k7VM0vssAi+H+r29vdG9e3d88803GtlmbGwsWrduDV9fXzx+/BiDBg1CxYoVsW7dOty/fx8BAQFo0qQJRo8eDScnJ1y9ehVr167F0qVLYWz88nYD+/fvx4cffggvLy/06NEDEyZMUG5/7969+PDDDzFhwgR8/PHHMDIywrlz53DhwgVMnToVwMtRxC1btiAyMlL5PAcHB8yePbtI12WWxn0WpSLxS05rdPgetmopzfssEr1P1LnPoi4rzfssliZDfO/Si/ssAi9D2e3bt1VuS6OugoICDB48GNWqVUOrVq3g6+uL+fPnAwDc3d1x5MgRFBQUoEWLFqhVqxZiY2Ph4OCgvCYRAMLDw+Hk5ITk5GR88sknKttv2bIldu7cid9//x2hoaGoV68efvzxR1SsaNjXxREREdH7R/KRRSocRxb1D0cWiag4OLKoXwzxvUtvRhaJiIiISHcxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiTKQugN4/MplM6hK0wtgwm0VEWvJ40wCpS9AK56iVUpegFRmro6UuQeOK+n7MkUUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWHxPfTtzBhrUC4Wzoy083V3QuVMkriQnS12WxiycPw9+Pl5wsLFAo7C6OHnihNQladS3s76BpakMI4fHSl2KRhhafxnq8XU48RA6RbaDt6c7LE1l2L5tq9QlaQTbpVtsLEzwTXQo/prbCem/RGH/lNYIqlxGZR2/8vZYNyocd5d3R+rKTxA/vS0qlLFWLv+pXz2c+6kj0n+Jwo0lXbF2ZDP4utuVdlOKTVfPhQyLr2natCliY2OL9RyZTIatW7dqpR5tSjyUgAEDByPh8DHs3L0P+S9e4MM2LZCbmyt1aWrbsH4dxowajvETJuLoiTPw96+N9m1bIj09XerSNOLUyZP475JFqFXLX+pSNMIQ+8tQj6/c3FzU8q+N2XPmSV2KRrFdumVu/zCE13LHZ/MOo97I7Tjw531sn9AC5RytAADerrb4fXIrXLmfhTaT96L+6B2YtelPPHtRoNxG0vWHGLTwCEKGb0Xk9H0v36vHfwAjmUyqZr2TLp8LZYIgCFIX8bqCggJMmjQJv/76K1JTU+Hu7o7evXtjwoQJkGm5kx89egRTU1PY2toW+TkymQxbtmxBZGRkocvj4+PRrFkzPH78GA4ODkXebnZ2Nuzt7ZH2MAt2dtr/NJSRkQFPdxfsO5iAho0aa31/2tQorC6CQ0Ixe85cAIBCoYCPtwcGDh6KUaPHSlydeuRyOerXCcJPP8/HN9Onwr92AL77YbbUZanFkPvrFUM6vl6xNJVh3cYtaN8hUupSNIrtUp9z1MoSP9fC1BgpKz9Bt28PYu/Ze8r5h2Z8iH1J9/D1urNY/nljvMhX4LN5h4u83Rqejjj2bXv4D9uMG2k5JaotY3V0iZ5XVFKcC7Ozs+Faxh5ZWW/PGjo3sjhz5kwsWLAAc+fOxaVLlzBz5kzMmjULP//8s9b37eTkVKygaEiys7IAAI6OThJXop7nz5/j7JnTCG8eoZxnZGSE8PAInDh2VMLKNCN26GC0at1WpX36zND76xVDOb6ItM3EWAYTYyOVUUIAePY8H/X9XCCTAS0DK+BqSja2fBGB64u74ODUNvgwxEN0m1bmJujR1Ac30nJw94Fuju7r+rlQ58LiH3/8gQ4dOqBt27bw8vLCxx9/jBYtWuCEBr63v3DhAlq3bg0bGxu4urqiZ8+eePDggXL5v7+GTklJQdu2bWFpaQlvb2+sWbMGXl5emD17tsp2Hzx4gI8++ghWVlaoUqUKtm/fDgC4efMmmjVrBgBwdHSETCZD79691W6HpikUCowaEYv6YQ1Qo2ZNqctRy4MHD1BQUAAXF1eV+S6urkhNTZWoKs1Yv24tks6ewdfTZkhdisYYcn+9YkjHF5G2yZ/l43hyOsZ0rA03R0sYyWTo2rAS6vg6w83REs52FrC1NMXwDjWxP+k+Okzbh50nb2P1iGZoUE31PNK3hR9SVn6CtFVRaBFQHh2m7cOLAoVELXs7XT8X6lxYDAsLw4EDB3DlyhUAwLlz53D48GG0bt1are1mZmYiPDwcgYGBOHXqFPbs2YO0tDR06dJF9Dm9evXC/fv3ER8fj02bNmHx4sWFXjswefJkdOnSBX/++SfatGmDqKgoPHr0CB4eHti0aRMAIDk5GSkpKfjpp58K3VdeXh6ys7NVptISO3Qw/vrrAlatXltq+6TiuXPnDkYN/xzLV62GhYWF1OVQMfD4IiqefvMOQyYD/l7YBQ9X98CA1tWw4cgNKAQBRkYvL0f77dQdzNt1EedvPcYP2y5gz5m7+PQDP5XtrE+8joZjdqDVpD24mpKNlbFNYG6qc7FHL5hIXcC/jR07FtnZ2ahatSqMjY1RUFCAadOmISoqSq3tzp07F4GBgZg+fbpy3rJly+Dh4YErV67A19dXZf3Lly9j//79OHnyJEJCQgAAS5cuRZUqVd7Ydu/evdG9e3cAwPTp0zFnzhycOHECrVq1gpPTy6+dXFxc3nrN4owZMzB58mS12lgSscOGYNeundh/8BAqVKhQ6vvXtLJly8LY2Bjp6Wkq89PT0uDm5iZRVeo7e+Y00tPTUb9OkHJeQUEBDicewsL5c5GVmwdjY2MJKywZQ+2vVwzt+CIqDTfSctB68l5YmZvA1tIUaZlPseLzxriZJsfD7Dy8yFfg8r0sleck38tE/aqqo3LZT18g++kLXEvNwYkrGbizrBvahVbExj9ulGZzikTXz4U6F7HXr1+P1atXY82aNThz5gxWrlyJ7777DitXFn7B7O3bt2FjY6OcXg+Drzt37hzi4uJU1q1atSoA4Nq1a2+sn5ycDBMTEwQF/fPm7OPjA0dHxzfW9ff/51ep1tbWsLOzK/avl8aNG4esrCzldOfOnWI9v7gEQUDssCHYvm0L9vx+EF7e3lrdX2kxMzNDYFAw4g4eUM5TKBSIizuAOvXqS1iZepqFN8eps+dx/FSScgoKDkG37lE4fipJL4MiYLj9ZajHF1FpepKXj7TMp3CwNkPz2uXx26nbeFGgwJlrD1ClnOqPMXzK2eN2hlx0WzLZyx+k6urIoq6fC3VuZHHUqFEYO3YsunXrBgCoVasWbt26hRkzZiA6+s1fIrm7uyMpKUn5+NVI3r/J5XK0a9cOM2fOfGNZuXLl1KrZ1NRU5bFMJoNCUbzrIszNzWFubq5WHcURO3Qw1q1dgw2bt8HG1lZ5TYS9vT0sLS1LrQ5tGBY7HP36RCM4OAQhoXUwd85sPMnNRa/oGKlLKzFbW9s3rneztraGU5kyen8dnCH2l6EeX3K5HNeuXlU+vnnjBs4lJcHRyQmenp4SVqYetku3NK/tDhmAv+9no5KbLab2CMHf97PwS/zLtvy04y+siG2MPy6l4dBfqYgIKI/WwRXQZvJeAICXiw06hXnhwLn7eJCdh/JlrDC8Qy08e56v8gtrXaPL50KdC4tPnjyBkZFq8jc2NhYNXyYmJvDx8XnndoOCgrBp0yZ4eXnBxOTdzfbz80N+fj7Onj2L4OBgAMDVq1fx+PHjIrTiH2ZmZgBefmWoSxYvWgAAaNG8qer8pcvRM7p36RekQZ27dMWDjAxMmfwV0lJT4V87ANt27oGrq+u7n0ylzhD7y1CPrzOnT6FlRDPl4zGjhgMAevSMxpJlKySqSn1sl26xszTFpO7BKF/GCo/ledh2/DamrD2D/IKXd/rbcfI2Ypccw/DIWpgVUwd/389Gjx/icTT55Td6z14UoH5VVwxqXR0ONmZIz3yGI5fTEPHlbjzIfiZl095Kl8+FOnefxd69e2P//v1YtGgRatSogbNnz+Kzzz5Dnz59Ch0VLKr79+8jICAATZo0wejRo+Hk5ISrV69i7dq1WLp0KYyNjdG0aVMEBAQof+38wQcf4NGjR1iwYAFMTU0xYsQIHDt2DDNmzMDnn38OoPD7LDo4OGD27Nno3bs37t27Bw8PDyxfvhxt2rSBpaUlbGxs3llvad9nkYiISBPUuc+iLtP2fRaloLf3Wfz555/x8ccfY9CgQahWrRpGjhyJ/v374+uvv1Zru+7u7jhy5AgKCgrQokUL1KpVC7GxsXBwcHhjJPOVVatWwdXVFY0bN8ZHH32Efv36wdbWtli/Ri1fvjwmT56MsWPHwtXVFUOGDFGrHURERESlSedGFnXZ3bt34eHhgf3796N58+Za3RdHFomISB9xZFF/FHVkUeeuWdQlBw8ehFwuR61atZCSkoLRo0fDy8sLjRsbxp/rIiIiInoXhsW3ePHiBb744gtcv34dtra2CAsLw+rVq9/49TMRERGRoWJYfIuWLVuiZcuWUpdBREREJBmd+4ELEREREekOhkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSgTqQsgIpKCQiFIXYLGyWRSV6AdMgNtmCAY3msQADJWR0tdglY4dVsmdQkaJ7x4WqT1OLJIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISBTDIhERERGJYlgkIiIiIlEMi0REREQkimGRiIiIiEQxLBIRERGRKIZFIiIiIhLFsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDIvvqcULFyA00B8uTnZwcbJDk4b1sXfPbqnLUpuhtuvbmTPQoF4onB1t4enugs6dInElOVnqsjRm4fx58PPxgoONBRqF1cXJEyekLkltOTk5GDUiFlWreKGMvRXCmzTA6VMnpS5LLVOnTIKVmZHKFFCzmtRlqe1w4iF0imwHb093WJrKsH3bVqlL0ghD7S99PM/bWJhgVu+6uLygCx6u7oWD09oiuHJZ5fInG/sUOsW2r6lcx6ecHdaPaY7byz5B6qoe2P91WzSu4VYq9TMsFsGkSZMQEBAgdRkaVb5CBXw9/Rv8cfw0jhw7habNwtG5Ywdc/OsvqUtTi6G2K/FQAgYMHIyEw8ewc/c+5L94gQ/btEBubq7Upaltw/p1GDNqOMZPmIijJ87A37822rdtifT0dKlLU8vgAf0Qd2A/li5bhROn/0TziA/wYesPcP/ePalLU0v16jVw/fZ95bQ/PlHqktSWm5uLWv61MXvOPKlL0ThD7C99PM/PH9gQ4bXd8emcBISO2IID5+5j51et4O5kBQDw7vs/lan/vEQoFAK2Hrul3MamcR/AxMgIbSbvRoPR23H+1iNsGvcBXB0stV6/TBAEQet70YCcnBx8+eWX2LJlC9LT0xEYGIiffvoJoaGhWt+3XC5HXl4eypQpo/V9vZKdnQ17e3ukPcyCnZ1dqezT3cUJ07/5Fr37fFoq+ysthtiujIwMeLq7YN/BBDRs1FjqctTSKKwugkNCMXvOXACAQqGAj7cHBg4eilGjx2ptvwqF9k59T58+hWsZO6zfuBWt2rRVzm9QLwQtWrbCxMlTtbJfmUwrm1WaOmUSdmzfhuOnzmp3R/8i03bDXmNpKsO6jVvQvkOk1vel7bff96G/XimN87xTt2Ulep6FmTHSf+mJLjP3Y8+Zu8r5R2a2x+9n72Ly2jNvPGfd6OawsTRF28l7AABlbM1xZ3kUIr78DX9cSgPwcrQy/ddeaDt5D+LO3y9RbcKLp3i2fQiyst6eNfRmZLFv377Yt28ffvnlF5w/fx4tWrRAREQE7pXCp3QbG5tSDYqlraCgAOvXrUVubi7q1qsvdTkaY6jtAoDsrCwAgKOjk8SVqOf58+c4e+Y0wptHKOcZGRkhPDwCJ44dlbAy9eTn56OgoADmFhYq8y0tLXH0jyMSVaUZ167+jUoVy6O6X2XE9OqBO7dvS10SvYWh95c+nOdNjGQwMTbCsxcFKvOfPi9A/Wqub6zvYm+BVkEeWHnginLew5w8JN/LRFQTH1iZm8DYSIZPW1RFWuZTnL3+QOtt0Iuw+PTpU2zatAmzZs1C48aN4ePjg0mTJsHHxwcLFixQa9vx8fGQyWQ4cOAAQkJCYGVlhbCwMCS/dj3Yv7+G7t27NyIjI/Hdd9+hXLlyKFOmDAYPHowXL14o18nLy8PIkSNRvnx5WFtbo27duoiPj1erVk27cP48yjrYwN7aHMMGD8C6jVtQrXp1qctSm6G26xWFQoFRI2JRP6wBatSs+e4n6LAHDx6goKAALi6qJ0wXV1ekpqZKVJX6bG1tUbdefcycMRUp9++joKAA/1vzK44fO4rUlBSpyyux0Dp1sXjpcmzbsRs//TwfN2/eQER4Y+Tk5EhdGhXCkPtLn87z8mf5OJachrEfB6CcoyWMjGTo1qgy6vo6w83B6o31o5pWQc7TF9h2/JbK/A8n70Ft7zJI/6UnHv8vGsM+rInIaXuRmftc623Qi7D46lO6RSGf0g8fPqyRfYwfPx7ff/89Tp06BRMTE/Tp0+et68fFxeHatWuIi4vDypUrsWLFCqxYsUK5fMiQITh69CjWrl2LP//8E507d0arVq3w999/F7q9vLw8ZGdnq0za5uvnh+OnknDoyHH06z8Q/fpE49LFi1rfr7YZarteiR06GH/9dQGrVq+VuhR6i6XLVkEQBPh4V4CjrQUWzPsZnbt2h5GRXpx2C9WyVWt0/Lgzavn744MWLbFl+2/IyszEpo3rpS6NCmHI/aVv5/lP5xyCDMC1Jd2R+b9oDGpTHeuPXIeikEsReoVXwbrEa8j710jkj/3qIyPrKSK+/A2Nx+7AjhO3sHHsB3ArhWsW9eKsZWtri/r16+Prr7/G/f//lP7rr7/i6NGjSNHQp/Rp06ahSZMmqF69OsaOHYs//vgDz549E13f0dERc+fORdWqVfHhhx+ibdu2OHDgAADg9u3bWL58OTZs2IBGjRqhcuXKGDlyJBo2bIjly5cXur0ZM2bA3t5eOXl4eGikXW9jZmaGyj4+CAoOxtfTZqCWf23M+/knre9X2wy1XQAQO2wIdu3aib374lChQgWpy1Fb2bJlYWxsjPT0NJX56WlpcHMrnV/5aUulypWxd3880h/lIPnabRw6chz5L17Ay7uS1KVpjIODA3yq+OL61atSl0JFYEj9pW/n+RtpOWg5cTfKRq2Cb/91aDxuB0yNjXAzTXWUN6yaK/zKO2DFa19BA0DTWuXQOsgDvX6Mx7HkdCTdeIjYpUfx9Hk+oppW0Xr9ehEWAeCXX36BIAgoX748zM3NMWfOHHTvLv4p/fbt27CxsVFO06dPf+v2/f39lf8uV64cALz115g1atSAsbGxynNerX/+/HkUFBTA19dXpYaEhARcu3at0O2NGzcOWVlZyunOnTtvrVcbFAoF8vLySn2/2mYI7RIEAbHDhmD7ti3Y8/tBeHl7S12SRpiZmSEwKBhxBw8o5ykUCsTFHUAdHb3+qLisra1Rrlw5PH78GPv37cWH7dpLXZLGyOVy3Lh+DW7/f84k3WbI/aUv5/kneflIzXwKB2szRASUx86TqteQRof74sy1Bzh/65HKfCszEwB4YyRSoQBK48sKE+3vQjMqV66MhIQE5ObmIjs7G+XKlUPXrl1RqVLhn9Ld3d2RlJSkfOzk9PYfApiamir//eqXXAqFokjrv3rOq/XlcjmMjY1x+vRplUAJvPyxTGHMzc1hbm7+1ho16cvx49CyVWt4eHgiJycH69auwaGEeOzYtbfUatAGQ21X7NDBWLd2DTZs3gYbW1vl9Xz29vawtNT+VxDaNCx2OPr1iUZwcAhCQutg7pzZeJKbi17RMVKXppZ9v++FIAjw9fXDtWtXMX7caPj6VUVPPW7XuDEj0aZtO3h6VkRKyn1MnTIJxsbG6Ny1u9SlqUUul+Paa6NtN2/cwLmkJDg6OcHT01PCytRjqP2lj+f5iNrlIZMBV+5nobKbHab3DMWVe1lYFffPCKKtpSk61vfCuFVv3mf2+JV0PM59jiVDGmPGhiQ8fZ6PmAg/eLnYYM/pu2+sr2l6ExZfsba2hrW1NR4/foy9e/di1qxZha5nYmICHx+fUq7upcDAQBQUFCA9PR2NGjWSpIZ3yUhPx6cxvZCakgJ7e3vUrOWPHbv2onnEB1KXphZDbdfiRS9/yNWieVPV+UuXo2d079IvSIM6d+mKBxkZmDL5K6SlpsK/dgC27dwDV9c3fyWoT7KzszBxwhe4d+8uHJ2cEBnZEROnTHvjg6Y+uXf3HqJ7foJHDx+irLMzwsIaIj7xKJydnaUuTS1nTp9Cy4hmysdjRg0HAPToGY0ly1ZIVJX6DLW/9PE8b2dlhilRwShfxhqP5XnYeuwmJv3vNPIL/hkp7NygEmQyGdYfvv7G8x/m5CFy2l5M7B6MXZNawdTYCJfuZKLLrANvjEJqg97cZ3Hv3pef0v38/HD16lWMGjUKFhYWSExMVOvkGx8fj2bNmuHx48dwcHAAACQlJSEwMBA3btyAl5cXJk2ahK1btypHKnv37o3MzExs3bpVuZ3Y2FgkJSUpf/Hco0cPHDlyBN9//z0CAwORkZGBAwcOwN/fH23btsW7SHGfRaL3iTbvsygVCW5vVyqkuG9fadCTt99iM9T+Kul9FnWZwd1nMSsrC4MHD0bVqlXRq1cvNGzYEHv37tXZT+nLly9Hr169MGLECPj5+SEyMhInT57U6680iIiI6P2jNyOL7xuOLBJpF0cW9YehjlQZ6tuvofYXRxaJiIiIiArBsEhEREREohgWiYiIiEgUwyIRERERiWJYJCIiIiJRDItEREREJIphkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomIiIhIFMMiEREREYliWCQiIiIiUQyLRERERCSKYZGIiIiIRDEsEhEREZEohkUiIiIiEsWwSERERESiGBaJiIiISJSJ1AVQ4QRBAADkZGdLXAmRYVIoBKlL0DiZTOoKtENmoA17dZ43NAbbXy+eSl2Cxr1q07teiwyLOionJwcA4OPtIXElREREZMhycnJgb28vulwmGOpHGz2nUChw//592Nraav1TWnZ2Njw8PHDnzh3Y2dlpdV+lie3SH4bYJoDt0jdsl35hu9QnCAJycnLg7u4OIyPxKxM5sqijjIyMUKFChVLdp52dnUEdcK+wXfrDENsEsF36hu3SL2yXet42ovgKf+BCRERERKIYFomIiIhIFMMiwdzcHBMnToS5ubnUpWgU26U/DLFNANulb9gu/cJ2lR7+wIWIiIiIRHFkkYiIiIhEMSwSERERkSiGRSIiIiISxbBIRERERKIYFomItOTV7wez+Tfe9QZ/86k/FAqF1CW8NxgWiYi0RCaTYdOmTZgwYQLS0tKkLkdrDOFN+1VIvH37tsSVaJchheFXf57u8uXLEldi+BgW32OvThoXL15EYmIidu3aZRAnEkNoQ2FetSslJQXJycnIzMzE8+fPJa5KPa/adOHCBSQmJmLz5s0GFTxu3bqFYcOGoVatWnB1dZW4KvW9atepU6ewatUqfP/997h+/fpb/6asvpDJZDh79izatm2Lhw8fGtTr8M8//8TOnTtx/PhxyGQyiatS3/r16zFv3jwAwPDhwzFy5EjI5XKJq9IMnX3/Eui9pFAoBEEQhA0bNgjlypUTfHx8BHt7eyEoKEjYt2+fkJeXJ3GFJfOqXXFxccKUKVOErl27Crt27RJu3rwpcWXqedWuzZs3C9WrVxdcXV2FWrVqCVFRUUJ6errE1ZXMqzZt2rRJ8PDwEOrUqSO4ubkJ9erVE7Zv365crq8OHDggLFiwQBg0aJDw4sULqcvRmI0bNwrlypUTGjduLDRv3lwwNTUVli9fLjx79kzq0tR28OBBwcrKSkhJSZG6FI3ZvHmzYGFhIVStWlWQyWTCyJEj9fp8+OLFC2Hq1KmCTCYTWrZsKdjY2AhJSUlSl6URr855iYmJwvz584Xhw4cLR48eFR4/fixtYYIgMCy+x44fPy7Y29sLK1asEK5duybcv39faNq0qVCjRg3h4MGDUpdXYps2bRLs7e2FXr16Cb179xbc3d2Fnj17CqmpqVKXppa4uDjBwsJC+PHHH4UjR44I33//vdCwYUOhTp06QkZGhtTllcgff/whODo6CitWrBAEQRAuX74syGQyYdGiRRJXpr4+ffoIMplMqFmzpk6c7DXh7Nmzgqurq/Df//5XEARBePTokSCTyYSpU6dKXFnJ/PsDSU5OjlClShXhxIkTgiAIehvyX7UrJSVFaNiwobB06VLhwYMHwsaNGwVbW1thwIABwvXr1yWuUj1BQUGCTCYTxo8fLwiCIBQUFEhckWa8ev/q0aOH0LBhQyEoKEjo27evkJubK2ldDIvvkX+fGBcvXiwEBwcLcrlc5UBr1KiRULdu3dIuTyOuXr0q+Pr6CkuWLBEEQRDy8/MFMzMzYcKECRJXVnIKhUIoKCgQxowZI0RFRaksO3jwoNCgQQOhb9++evnGtmjRIqFjx46CILwMipUrVxb69u2rXP7kyROpSiu2V8dXTk6Oct7o0aMFY2NjYe3atVKVpVG7du0SPvzwQ0EQBOHKlSuCh4eH8NlnnymXZ2dnC4Lw5rlGl/z7Q+P+/fuFmTNnCtu3bxfOnTsnlC9fXliwYIFE1WnO3r17hdGjRws9e/YUMjMzlfO3b98u2NvbC/3799fbwJifny8MHjxYGDRokCCTyYS5c+cql+lzaLx48aLg7e0tLF26VBCEl2Hf1NRUmDhxorSFCQyL75VXJ/CEhARBEAThxx9/FLy8vJTLX31yuXLlimBvby8kJiaWfpFqunjxohAcHCwoFArh8uXLQoUKFVTCx59//ik8ffpUwgpLrm/fvkKdOnXemD9lyhQhMDBQL4PV559/LvTo0UMoKCgQKlSoIHz22WfKZb/88oswZ84cKcsstri4OCEyMlLla7G+ffsK1tbWwq5duySsrGT+HfrmzZsnBAQECDdv3hQqVqwofPbZZ8o35y1btgi9e/eWfATkbWbPni3Url1beZlNVlaW8NlnnwlVqlQRKleuLHh7ewv29vaCu7u7MGjQIGHevHnC8ePHhaNHj0pcefEtXbpUkMlkQtmyZYXk5GRBEP7pz507dwply5YVPvnkE+HGjRsSVlk0r38Q/veH4ldfSc+bN09l/qlTp0qlNk1KSEgQAgMDBUF4+T5csWJFoV+/fsrlSUlJkl0ixrD4ntm3b58gk8mEAwcOCFevXhUcHR3fGHU7d+6cULlyZeHcuXMSVVlyCQkJgo+Pj5CcnCxUqlRJ6Nevn/LN7OjRo0JMTIzw999/S1xl0Z05c0YZMhYtWiQEBgYKCQkJKifMXbt2CZUqVRLu3LkjVZkllpCQIHh7ews2NjbC4MGDVZYNGjRI+OSTTwS5XC5RdcV3+vRpwcrKSujSpYvw559/Kuf36dNHsLGxEXbv3i1hdSUTHx8vDBkyRBAEQbh165bQpEkTwdraWujdu7cgCP+M5IwaNUpo27atTn/lnpmZqQxO/35dFRQUCCdPnhS6desmBAQECO3atRPq1asnODg4CJUrV9bLy1jWrFkjyGQyYfTo0cLDhw9Vlm3evFmoWLGiTl+fee3aNSE/P1/5eM6cOcKAAQOEAQMGCLdv3xYUCoWQn58vTJs27f/au/O4nNL/f+DvUxElkbTRYmlFqyRLZTI01oQh1BhMimyJpgz5MExjyzJjvh5jbCNlK4wwY8uSiEZZSmUrJUK0adF9v35/9LvPdKts07jvk+v5j0f3fcr73Pc513mf67yv64KioiLWrFmD/Px8DB8+vNZTGHlWM4l3dnbGkydPYGBgIHX9OnPmDAIDA2XWzrNk8RNy9+5drF+/nu+tKS8vx+rVq9G5c2eEhIQAAJ4+fYrQ0FB07txZrhsRoP5HXf369QPHcfzFTCIoKAi9e/fG48ePP0Z4/4pYLEZJSQn69++PCRMmAKiuD7OysoKzszNOnTrFN6KzZ8+Gg4MDCgsLZRnyG0m+q1u3buGvv/7C2bNncf/+fYhEIkyZMgUdOnTAzp07AVQ/JgwJCUHbtm2Rmpoqy7Dfi2Qfr169Ch0dHXh4eOD69ev8+z4+PuA4Dn/99ZesQnxvIpEIa9euha2tLXJyclBWVobg4GAYGxtjwYIFKC0tRUZGBoKDg6GhoYEbN27IOuR3cuHCBXTo0IGPt2Zb8uOPP8LW1pa/IcvMzJT7QWSS+G/fvo3ExEQkJCSgsrISQHW5Ecdx+O6771BQUCD1e/J8IzZjxgzo6enh77//BlDdg9iiRQt89dVX0NbWhqmpKY4ePYqqqipUVVVh9erV4DgOFhYW6NKlC7//8qqu69fz58+hpaUFjuMQEBAg9V5AQABcXV1rJf0fC0sWPxG3bt2ChYUF9PT0pOqnHj58iPDwcGhoaEBXVxddunSBjo4OkpKSZBjt20lOtLNnzyIkJAQbNmzge3JOnTqFHj16oHfv3khLS8Px48cxb948qKmpyX1v6esNyMmTJ6GkpITIyEgAQH5+PmxtbWFtbQ0zMzMMHjwY6urquHr1qgyifTc1Rz0bGhrC0tISDg4O6Nq1K65cuYJbt27By8sLrVu3hrGxMezt7WFoaMhfJOTdzZs38fDhQwD/7GtSUhK0tLQwfPhwqYRxxowZSEtLk0mcH+rWrVvQ0tLC2rVrAVTXJc6YMQOWlpZo1qwZbG1tYWZmJpjvC6juYbS0tISFhQV/QyL57uLj42FiYlIrsZJXNc8vc3NzdO7cGQ4ODrCxscHTp08BAFu2bAHHcQgNDeVfq/m78qi0tBTm5uawtrZGQkICxo0bJ1UO8Nlnn8HMzAxHjhzhE/urV6/i0KFD/I20vNZxSz73CxcuYOXKldi3bx9u3boFoLqmVEdHBxMnTsSDBw9w+fJlzJ8/H+rq6lJtycfGksVPRFpaGvz8/NCyZctaj50rKyuRm5uLzZs348CBA4KZViE2NhZKSkoYMGAA1NTUMGDAAOzduxdA9aPZPn36oEWLFjA3N0fv3r0FM71CfHw8Dhw4wBelBwcHw9ramr8Yv3jxAlFRUQgKCsKPP/7IP1aTZwkJCVBXV8fGjRsBVDeIHMfhf//7H4Dqm5YLFy4gLCwMBw8eRFZWlizDfSdisRjPnj0Dx3Hw8vLie+JrJozKysr46quvBFE/9erVq3qTh9WrV8PExIRPrMrLy/HgwQPs3bsXV69eFcxTiMzMTP58efHiBXr37g1jY2OpHuxHjx6hefPmiIuLk0msHyIuLg6qqqrYtGkTysrKcPDgQXAcxyf4wD8J47Jly+R+EIikV/Dly5cwNjaGqakpHBwcapUQffbZZzA3N8eRI0dq1aLXfHwtjw4cOAAVFRVYW1tDT08PgwYN4scJ7Nq1Czo6OtDV1YWZmRns7Oxk3iHAksVGqq5G/969e5g+fTq0tbWlioHl9e6rLpL9ysnJgZ+fHz/Fyo0bNzBixAg4OTlhz549/PaXL1/Go0ePBNNL8PTpU7Rt2xatWrWCh4cHsrOzkZaWhuHDhyMsLEyuHxu9yfr16zF27FgAQHZ2NgwMDDBt2jT+fSGUBtRU8/yKjY1Fs2bN4OPjw/cwSjg7O/MlEfI6d2lYWJhUneGRI0ewceNGvqcDqK6dtbOzQ0REBAD57pF6Xc05Srt27Yr169fz9YfPnz9Hr169pBLGnJwc9OzZUxA3LBJhYWGYMWMGgH/Or5o1wJI2fseOHbh586ZMYnxXkkRW8r29fPkS3bt3B8dxOHLkSK1j7/PPP4eGhgYuXLjw0WN9HzWT19zcXPj6+vKjng8fPowRI0bA0dERZ8+eBVA9+OrUqVNITU2Vi6nRWLLYCNWc2HP9+vXw8/NDYmIiSktL8fjxY8yaNQumpqZS00PI+51mTYmJiRg1ahQcHR2legtTU1MxcuRIODk5YceOHTKM8MMVFRXhu+++g6urK8aNGwdtbW3s2rULY8eORbdu3fjiZnlP8CXHYHp6OkpKSrBq1Sp8/fXXuHfvHj/qWXLMHTt2DD/88IPUlDPySrJfks9f8u+RI0egqKhYK2EMDAzEvn37kJGR8fGDfQfXrl3D0KFDpR6NL1myBK1bt0afPn0we/ZsPpEMCgqCkZERv89CShj/+OMPqKioYO3atbUuvEVFRXBwcICFhQX/mE+eB+nUZdKkSZg6dSpyc3NrzSqwZ88erF69WlBtPFD9hOXOnTsAgLKyMpibm8PS0hJJSUm1jr2ZM2fKbU/i8ePHpX5OSkrCkCFD4OzsLPVU6NSpU3zCeOLEiY8d5luxZLGR2r9/P1q3bo0vv/wSbm5u0NfXx8yZM/Hq1StkZGRg9uzZ6NKlC8LDw2Ud6ns7f/48bGxs0Lx5c2zfvl3qvbS0NIwZMwbW1taCmtvu6tWr/GPn5ORkmJmZIS4uDrGxsZgwYQImTpwIjuMwePBgwVyko6Oj0b59e1y+fBlbtmyBiYkJdHV1MXXqVH4bkUgEX19f+Pj4yPWUK2KxmP/cjx8/Dl9fX3z55ZdYvHgxsrOzAVT3MCorK2PcuHEIDw9HUFAQdHV1ZVaQ/jZLlizBkiVL+OPu3LlzfA/89evXsWnTJhgZGcHW1hYBAQGIj49Hz549+VICoSgoKEDfvn2xfPlyANU9VTk5Odi2bRv2798PoHqgh7m5OWxsbFBZWSmIc+zSpUuIiYkBAPz2229wc3ODnp4eP1WYWCxGZWUl/Pz8MGfOHLmfWqtmMhsXF4dWrVph6dKl/A3yy5cvYWJiAmtr63pr6uUtYYyNjYWtrS0eP37M79+OHTtgZ2cHdXV1XLx4UWr7U6dOYfTo0bCwsOB7GOUFSxYbodTUVBgZGWHLli0Aqu/KJMXNEnfv3sXkyZNhb28vuLtooLp3sU+fPujfvz+OHTsm9d6NGzfg7e0t97WXkrqc7OxsfPHFF9DR0eFXztm9ezf09fVx//593L9/HxEREVBVVYWGhoZcj8ysOTG1t7e31M3IqFGjwHEczp49i8LCQhQWFuLbb7+FlpaW3I56fj2BjYmJQbNmzeDr64tBgwahZ8+e0NPT43sITp06hT59+qBbt26wtLSUeZ1RfTZs2AAFBQW+5+bZs2dwcHCAkZGRVHJbVlaGH374AQMHDoSSkhI4jsP48ePlfqRpTZWVlejfvz8WLVqEnJwcBAYGwtnZGXp6elBTU8OSJUsAVNcwCmHOQbFYjOLiYgwcOJCfg+/+/fuwtLSElpYWPwikpKQEISEh0NXVlSopkEc1k/Pw8HCEhYVBVVUV6urqWLJkCX9DVlpaytfwvZ5oyaOcnBz+ScPt27f516Ojo9GjRw/079+/1sCwP//8E15eXnJ3LLJksRFKSEjgJ29OS0uDgYGB1MTUkobjzp07cj93WM0pV+Li4nD+/Hn+Ah4fH4++fftiyJAhtRJGeb6YZWVl8cXYhw8fxooVK3Djxg34+PhAV1cXvr6+OHbsGMLCwhASEsL3CDx8+FAQKy6cO3cOlpaWcHZ2lmrQS0tL4ezsjHbt2sHQ0BAuLi5o37693I6iDQ0NxbJly/jeiqdPn8LW1hZhYWH8NqmpqRgyZAjat2+PnJwcANWJ14sXL+S2TvbVq1eYPXs2Jk+eDKB6IvHExEScPHmST3Rfj10sFmPr1q0YOnSoYKbHkSgvL8eUKVPg6OgIJSUleHh4YMuWLcjLy8OUKVPg5eUl6xA/SEREBJo1a8YPnsrMzISBgQHs7OxgamqKQYMGQUdHR27PL4maieKSJUugrq6OQ4cOITY2FjNnzqyzh7FVq1a1pkaTZxkZGfx0UxKRkZFwdXXFsGHDag2+lMenLCxZFLiaj8ckF7Xo6GhYWloiPz8fRkZGUhN7nj59GtOmTUNubq7MYn5Xkv3at28f9PX1oa+vD0NDQ3To0IGfAuf8+fPo27cvRowYgUOHDsky3HdSUlICJycnWFlZISIiAhzHYd++ffz7O3fuxPjx42FgYABra2sMGDBA7nsFXpeTkwNLS0twHIc//vgDgPQFYf/+/fjpp58QExMjt4MINmzYACUlJanegJycHGhra+Pw4cP8ayKRCNevX0ePHj0QHh7OL80o70JDQ6GiooLQ0FBwHIfTp08DqJ6KqmfPnrC0tOSfONSsjy0vL5dBtB9OctxJBgvExMRIHYvjxo3D1KlT5f47qxmz5PuoqKiAu7s7pk+fztf75uTkICIiAkFBQfj999/l+uby9Z7BoqIi2NvbS92MAcDChQvRrFkzLF26lG8vysvL5b5uu6bs7GzMnTsXXbt2xdKlS/nXd+3aBVdXV3h4eMj9jAksWRSwmonioUOH+NFvlZWVsLKyAsdxUvVhQPUqC/369ZOaa0ueXbx4ES1atMCvv/6KzMxMJCYmYujQoWjTpg3fw3H+/Hl069YNnp6ecj9a+NWrV7h06RIMDAygrKzMj4arWU+UnZ2NiIgI6OrqguM4jB49WlbhvlV9F9mcnBxYWVnB0tKSf5wi7xdkidd73k6ePIm///4blZWVcHR0xLx582rtS+/evWuda/KoZtLRo0cPKCsrY+7cufxrIpGozoRRnnvq36au4+7x48eYP38+NDQ05H50sER8fHytWMPCwmBsbCy42QT8/PwwY8YMqeOxsLAQNjY2WLFiBQBITYUzbNgw6OrqIiwsTGpf5a1GUaK+2UgWLFgAU1NTqYQxKioKdnZ2GDdunFzfjLFkUaBqJor79u0Dx3HgOA7nzp2DSCTC7t270a1bN4wcORJPnjzBxYsXERQUhJYtW0otQybvNm/ejH79+kndRZaWlmLQoEEwNzfnk6zExES5r1GUuHfvHnR0dKCjo4O+ffvyDcTrU6vcv38fM2fOlMt6PklPhuQYTElJwb59+5CcnMw38jk5OTA3N4e9vb3c9iDW5/WeN0mZQ0BAABwcHLB7926p7UeOHIng4GCp81JeicViPHz4EDo6OrCxsYGGhgaOHj3Kn2OShLFPnz7Q19fnB8A0FjExMRg7diyMjY3ltqb0dU+ePMHgwYPBcRwCAwP5gS0AYG9vL6hHskB1eyG5AZHUzQLAhAkT0KlTJ/5YlGzj7+8POzs7aGtr84OS5PXmU3L+x8XFISwsDMuWLePrgLOysupMGPft2yf3bSRLFgVKckDu3r0bioqKWLlyJWxtbfmJZAsLC7Ft2zaYm5ujZcuWMDMzQ/fu3QXTOEqEhYWhTZs2/M+SRuTkyZMwMjKS+xVZ6lJWVobbt28jPj4eVlZWcHR05BMsSeMoScbk8c55/fr1mDdvHl9DFB0dDVVVVRgbG0NRURFBQUFSc9aZmZnB0dFR7gq26/K2nrfi4mIMHToU9vb2mDZtGnbu3Inp06dDTU1NUCuzlJWV8d/fmDFj0Lp1axw7dow/3kQiEU6ePInPP/9c6mIuBG9LIoqKivD7778L5uayph07dmDEiBHQ1tbG6NGjceLECaxbtw7u7u6CK1cBgO3bt8PJyYkvV8nJyYGFhQV69OiB4uJivr0fNWoUEhMT4eXlBRMTE7lNFCUkE247ODjAwMAAOjo6fF1idnY2FixYgK5du+Lbb7+VcaTvjiWLArZ//35wHMePenZwcJCqfxOLxXj16hVOnz6NzMxMuZjY831dv34dXbp0wbJly6QeS6SkpAhqSbi6vHr1CsePH4eVlRV69+7NJ4obNmzA2rVrIRKJ5LKXKjQ0FNra2li8eDGSkpLg6uqKTZs2obCwEJs2bYKxsTH8/Pz4MoHc3Fxoa2vjs88+E0SdUX09b5Ke3+LiYoSEhMDZ2RkmJiZwcXERzOpANdU8tjw9PWsljGKxWO6nW3mdJPaHDx8iKiqq1s2WvCcZEjXXGY+JicFvv/3Gr/1eUFCACxcuoFevXnB1dUW7du3AcRx+/fVXWYb8QeLi4uDo6Ijhw4fjzz//BFBdemRlZQVtbW24urqia9eu6NSpEwDg559/ho2NjVzeREu+s7KyMgQEBGDr1q2oqqpCVlYWhg8fDk1NTb4uMTs7G7Nnz4a9vT2ePHkil+3861iyKFCVlZXw8vLCzp07+dfs7e2xaNEiAMJpFN+mtLQUM2bMgIuLC5YsWYKqqioUFhZiwYIFMDMzE1ytzuuqqqpw4sQJ2NjYQF9fH5MmTQLHcTJdA/RdrFixAgYGBliwYAE8PT2lHlVu27YNpqam8PPz42usHj58KDVYRN7V1/MmSegljfuTJ0/kcuTiu3o9YdTS0pJaW1dIJG3e/fv30bZtW3z//fcyjujf2bdvH9q3b48ePXrA1tYWmpqaOHToEH8MlpaW4vjx45gyZQqaN28u921GfdckyawWgwcPxsmTJwFUD2BZvnw5vv32W4SGhvL7PGnSJAwePBhlZWVymWAlJCRAX18frq6uUutYFxQUwN3dHZqamvwckTk5OXI9DdrrWLIoYJITSHISjhgxAnPmzOHfDwwMxOzZs+XypHoXkrifP3/OTyKuqqoKBwcHtG3btt6JWYVGJBLh2rVr8PX1xbhx4+Su0a/ZyNfsaVq3bh1UVVWhra1d6xHY9u3b0bVrV3h5eQnq8WxNb+t5ayxq7ueQIUPQoUMHuR8oVp/Hjx+jefPm8PX1FWy7B1TXYLdp04Z/avTw4UNwHIfVq1cDqJ14yXtdac14IyMjsWLFCgQEBPArGyUmJtY7DRoA5OXlYcaMGdDQ0JDrqZvS09Ph7OwMBQUFxMfHA/hn358/f87PNSu0cjCAJYuNSmBgIL788ksAQEhICJSUlAQxcembSE60ly9f4t69e9i0aROio6MFUf9W07v29Mrr+sE154aMjo7GunXrAAA//fQT2rRpg2+//ZbviZPYtGkT7O3tkZeX99HjbSj19bwJMRF50zFYc38k80XKE0nsbzuPnj17hg0bNgj+yUpUVBRGjRoFoHqOPkNDQ/j4+PDvS25YXu/plneBgYEwMDCAu7s7hg0bBo7jEBkZCaC6V87JyQnDhw+XGsDz8OFD/PTTT3BwcBBEkpWeno6+ffuiY8eO/DzGku/n2bNnGD9+vNQyf0LBksVGZOHChXBzc8OyZcvQtGlTwfW81dfAC6UhrI+kYX/8+DHOnTtX5/7I8z7WNTfkrl27+PdXrFiB9u3bY/HixbXm75T3Ho930Rh63oR8DErahVu3biE8PFxq7e3GavHixXBxccHTp09hYGAgtZZ6REQEAgIC5Pb7qs+ePXugq6vLJ3xxcXHgOA579+7lt4mPj4e5uTnmz58v9buPHj2S22Uz65KZmQlHR0d06tSJTxgl35/QvjcJliw2Ir/88gs4joOGhgYuX74s63Dey9sK04WqZh1V69atBbkWd31zQ9YccPTjjz+iXbt2WLp0Kb80FyCshlHIPW9vIuRjUBL7tWvXoKGhgW+++abWFCNCOsbqIok/Ozub74W/fv06evfujRYtWvCrb0k+i4CAAIwcORJFRUWyCfgDrVu3jt+XqKgoqKmp4ZdffgFQ/YhWMoAnJSVFalS+UEkSRjMzs0Zxg8OSRQF524nz6NEjWFtbC246mcZWmP66R48eQU1NTdB1VPXNDVkzYVy5ciWaNWuGsLAwwSX7Qu55exdCPgbz8vJgZmaGwMBA/rXy8nKpY09ox5uE5Ls4cOAA7OzssHPnThQWFuLZs2fw9fVF586d+eT+wYMHCAkJgaampmAmEq8pODgYQ4YMwdGjR6GmpoaNGzfy761btw5+fn5SZThC/U5run37NszNzWFrayv4/WHJokC87WImmZJEqAdkYylMr0tycjJWrlwp6LvkN80NWfOi/euvv/JF60LRGHre3kbIx2BSUhKcnJxQWlqKiooK+Pn5wdnZGS4uLpg3bx6/nVDbvoMHD0JFRQUrV66UKuPIzc2Ft7c3OnbsCA0NDdjb26NTp06CnS4sISEB9vb2UFJSwvr16/nXJXOXTp8+XXBt/7ucT3fu3BFcjX1dOAAgRq6JxWJSUFCgrKwssrGxoUWLFtHs2bPr3BYAcRz3cQNsAAUFBbRr1y6aNm0aKSgoyDocph5VVVUUFxdH8+bNIxUVFTp9+jQ1bdqU1q5dS0pKSuTv7y/rED/I48ePydjYmMaPH08bN24UxDkkaRdu3rxJ6enp5OHhIeuQ/hO///47hYaG0t27d2n48OFUVlZGQ4cOpTt37tDp06dJX1+fDh8+LOswP0h+fj65ubnR+PHjae7cuVRRUUEvX76kM2fOkImJCVlYWFBmZiadPHmSLCwsqFOnTtSuXTtZh/1BSktLaeHChfTnn3/SqFGjyMfHh7Kysuj777+nvLw8unz5MikpKQnmGiYSiUhRUZHy8vLo7NmzNGrUKFJUVJR1WP8d2eaqzLsS8mOkxiozMxOBgYEYNWoUFi1aJKg5s/6N+uaGlMdlJF+/86/v3BFaz5skzuTkZCgrKze60o2a7ty5Azs7O6xYsQL9+/dHZmYmgOrPIDo6GtbW1vwScEJTUFCA3r17Y9u2bcjLy8OiRYvg7OyM1q1bo2PHjvjtt99kHWKDqDkN2qxZs2BpaYkmTZrAzs4OAwYM4Ed1C6V3uLGXTtWF9SwKREpKCh0/fpwCAgIE1fOWm5tLjx49IhsbG0HF/TY3btygzz//nBwdHUlVVZUOHjxIQ4cOpYiICFmH9lGIxWK6efMmbdy4kYqKiig4OJi6du0q67CkSHre8vLy6Pnz52RhYSHrkBqEZL9SUlKoV69e5OfnR6tWrapzWwikl+ZNnj17RmPGjKH79++TiooKJSYmUrNmzYiIqKSkhOzs7Oirr76ikJAQGUf6/kpLS2no0KFUXl5OycnJ9MUXX1D//v2pX79+FBAQQF27dqUVK1bIOswGITluKysrqaysjFJSUsjQ0JD09fVJQUGBqqqqSElJSdZhvrP8/HwyMjKir776SjBPI/4VGSerDKrvUoS6LNWbpKWloVmzZujWrRuuXLnSaHpEc3Jy0K1bN6k1g1NSUqCqqsqvzd0YCH1uSKD6u2rTpg1GjBghuBkC3uTu3bto0qQJv7ZsRUUFNm/ejIULF2LlypVSExc3hvPu5s2b0NbWllreVGLEiBHYtGmTjCL7cDVXAdqxYwe2b9+Oly9f8q97eHggKChIliF+MMk+vH7s1XcsCvF611jm9HxXjaerR6BSU1PJ29ubBg4cSH5+fhQbG0tERAoKCiQSiWQc3Yd7+vQp+fv7k7u7O1VVVdGkSZMoKSmJ0Ag6sk+cOEFaWlo0Z84cIqqu4zM0NCQDAwMqLy+XcXQNQyQSkYKCAuXn59P58+fr/N4krzVt2vRjh/fOMjMzqbCwkAoLC2nDhg30999/8++JxWISi8UyjO7DAKBjx46RhoYG3xMzbNgw+vnnn+nPP/+ksLAw8vX1pcjISCKiRtHjYWFhQSdPniR9fX0KDw+nRYsWUVxcHM2dO5fOnTtHrq6usg7xvXEcRyKRiDQ1NcnLy4u8vb2pefPmVFxcTMHBwXTmzBn6+uuvZR3me0H1oFniOI5OnTpFO3fulDrH6jsW5eWpkyTWutqG13/W0NAgf39/uYn9v/Zp7KWcSk9Pp169epFIJCJ7e3tKSEigxYsX80mIoqKiYBPG3Nxc6tSpE82ePZuSk5NJJBLR5MmTG0XC6OTkRL169eILzRUVFUldXZ1UVFTo8ePHMo7u3xOLxaSoqEhZWVlkZmZGV65cqbORF0ISYmlpSYMGDaIxY8bQjRs3aM2aNXTz5k3+fSE29BzH0dixYyk4OJgOHDhA6urq1KRJEzpw4ABdunSJbt26RSoqKvTLL7/Qy5cvZR1ug+nSpQudOHGCHBwcKDIykqZNm0Znz56l48ePU6dOnWQd3gd5fUBEZGQkeXl50e7du+n48eNkamoqo8g+DMdxxHEcxcTEkJubG6moqAjmHJM8Jk9NTaWJEydS//79ycfHh6KioohI+B04/5oMezU/aWKxGCEhIfzyfABQVFSE77//HtbW1vjmm2+kthWaly9fSk2uWlZWBgsLC1haWko9DhRKQXN9an43dnZ2UnOHRUVFITExURZh/WuNYUBVVVUV8vPzYWJigpycHERHR8Pe3h7ffPMNevXqhZEjRwIQ5vkFVA8WWLFiBUaPHs2v1iTZl7S0NHAch9OnT8swwv9GZWUliouLkZeXJ7iJqd/2yPL58+cIDw/HnTt3PlJEDS8+Ph4cxwmyNCAtLQ2tW7fG5MmTsXr1agwcOBCdO3eGv78/v43Qr1kfiiWLMjRx4kQ4OTlJvVZUVIRVq1ahe/fuCAsLk1FkDUtS01ZRUSGVMJaVlWHZsmX4+eefZRzhvyOZ47JPnz6IiIgAACxYsAAcxwm20Rfa6OC6SBKn8ePH49ixYwCA2NhYaGpqQk1NDVu3bpVhdA3jxYsXSEhIkKobFYlESEhIgLm5OW7fvi3D6Jia3jZXrhDPtbpifvLkCY4cOSKDaD6cWCxGeXk5xo8fj5kzZ/Kvl5WVwcbGBhzHwdPTU2r7T40w+ocbGfz/x7C2trYkEokoPT2df09NTY0mTZpENjY2dOjQISouLpZVmA2madOmVFVVRU2bNqWrV69SVVUV+fj4kKenJy1evJhcXFxkHeK/InkcKxaLSVlZmZYvX07h4eGUmJhIHTt2lHF0/5DU3FRWVlJpaekbt7WysqLAwEDBPEKqi+R7UVRUpLi4OCIiio6OJpFIRPr6+nTu3DlKTEyUYYT/nrq6OvXs2VOqblRBQYH++OMPUldXp1atWskuOIb3LqUdQjjXMjIy6MqVK3Tjxg0iqo4Zr5UVaWpq0hdffCGL8D4Yx3GkrKxMjx49Ig0NDSIiKi8vp2bNmtHnn39OHh4elJ6ezs86IIQSnAYn62z1U3b79m1oampi0qRJKC4uBiC9TijHcTh69KgsQ2xQkh64oqIiKCgoQENDg19UvjFwdXWFnp4elJWV5W7kraQHIDU1FWPHjoW9vT08PT1x6dIlGUf235GcS9u2bUNoaCj8/Pygq6uLu3fvIjo6Gp06dYKvr6/UCjRCl5CQgKCgILRs2VJwy342FvX1Ogm9tGPr1q0wNzeHtrY2rK2tsWbNGlmH1GDEYjFKS0vRt29feHl58deqnJwcGBoaYsuWLZgwYQL69esn40hlhyWLMnbq1CkoKytj+vTpePLkCf96Xl4erKyscOHCBRlG1/BevnyJ6dOnQ0VFRZDrm9ZFLBZLPa6oOW2JPJAkitevX0ebNm0wadIkrFmzBp06dcLo0aOlthXiRextzpw5A47joKOjgytXrvCvx8TE4O7duzKMrGE9e/YMY8aMgbW1NZKTk2UdzienoKDgje8LubRj9+7dUFVVRUREBJKSkjBx4kS4ublJtReNoZbv/PnzUFBQgJOTE7y8vKCqqoopU6YAqG4/1dTUcOvWrUbZTr4NSxblwKFDh6CsrAwPDw9ERUUhNTUV3377LXR1dfHgwQNZh9egsrOzMWDAgEbZo5Wamiq3CXB2djZMTEyk5m2LiYnBqFGjal3khHgxe5PKykr89ttvfE9bY27oHz16hLy8PFmH8clJS0uDk5MTTp48CaDxHGNisRhFRUUYOnQoVq1axb9+5swZeHp64ty5c7h48SL/emNIGBMTEzFhwgRMmTJFqp7+4MGDMDc3x4sXL2QYneywFVzkxN9//00BAQF0//59UlJSIkVFRYqKiiIbGxtZh9agAFB5eTk1b95c1qF8MgDQ3r176eLFixQUFETa2tpERDR37lw6cOAAcRxHpqam1KdPHwoODpZxtP8NybQYDNPQUlJSyNHRkcrLy2nu3Lm0cuVKWYfUoABQr169yMHBgdauXUtERG5ubnTjxg0Si8XUpk0bateuHR07dky2gTYg1LHy0bx58+jKlSt08OBBatmypYwikx2WLMqRoqIiKigooOLiYtLV1SVNTU1Zh8Q0EoWFhZSVlUWWlpZERLR8+XJatGgRrVmzhjp06ECxsbF0+fJl+umnn8jR0VHG0TKMMEgSxaCgIOrYsSMFBwfToUOHyNbWVtahNZjy8nKaM2cOXb16lQwNDSk/P5+ysrLo0KFDpK6uTjdv3qS5c+eSv78/+fn5yTrcBnf9+nX6v//7P9q5cyedPXuWrKysZB2STAhnIcZPQMuWLT/JOxbmv6eurs4nilVVVdSqVSuKjY2lgQMHEhFRr169SF9fn5KTk1myyDDv4OrVq9SnTx+aM2cOhYaG0uXLlwkAXblyhWxtbRtNb3azZs0oJCSEdu3aRYqKihQdHU1r167l14Jv0aIFERG9ePFChlH+NyoqKuj27dtUUFBA586d49vQTxFLFhnmE6OkpER+fn5SU/5UVlaSvb09de7cWcbRMYz8q6yspKlTp5K/vz8tW7aMiIjs7e3J3d2dvv/+exo5ciS1adNGxlE2HH19fQoKCiIiov3790slhk2aNCENDQ1+ypnGRFlZmQYNGkQDBgwgVVVVWYcjU8K/7WEY5l9RUFCgjRs3UkFBAVlYWMg6HIaRe02bNqWjR4/Sjz/+SETELwM3fvx4UlVVpcOHDxNR7fWEhQwAVVRUUMuWLeno0aN04sQJunbtGnl6elJZWRlNmTJF1iH+J5SVlT/5RJGI1SwyzCft0qVLdODAAdq4ceMnXY/DMA1BLBZT//79iYjo1KlTMo7mv3H16lUaPXo0FRcXk6amJunp6dGRI0eoSZMmJBKJaq13zTQOLFlkmE/U8+fPKSAggG7dukWbNm36pOtxGObfktQoXrhwgYYNG0YbN26kL7/8UtZh/Sdyc3Pp/v371KRJE+revTspKChQVVUVKSmxyrbGiiWLDPMJe/LkCQEgLS0tWYfCMI3Cw4cPadSoUWRlZUW//PKLrMP5KBrLYB6mfuzbZZhPWNu2bVmiyDANSE9Pjzw8PGjv3r1UUlIi63A+CpYoNn6sZ5FhGIZhGoBkMuenT59SZWUl6enpyTokhmkQLFlkGIZhGIZh6sX6jhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYT4iIyMjWrt2Lf8zx3F04MCBjx7H4sWLydraut734+LiiOM4evHixTv/TRcXF5o9e/a/imvbtm3UqlWrf/U3GIZpWCxZZBiGkaG8vDz64osv3mnbtyV4DMMw/wUlWQfAMAwjNJWVldS0adMG+Vs6OjoN8ncYhmH+K6xnkWGYT5qLiwv5+/uTv78/qaurk6amJi1cuJAA8NsYGRnR0qVLydvbm1q2bEk+Pj5ERHT+/Hnq27cvNW/enPT19WnmzJlUWlrK/15+fj4NHTqUmjdvTh06dKCIiIha///rj6FzcnLI09OTNDQ0SFVVlbp3706XLl2ibdu20f/+9z9KSUkhjuOI4zjatm0bERG9ePGCpkyZQm3btqWWLVvSZ599RikpKVL/T1hYGGlra5OamhpNnjyZysvL3+tzevbsGXl6elK7du1IRUWFunXrRpGRkbW2q6qqeuNnWVFRQYGBgdSuXTtSVVUlBwcHiouLe69YGIb5uFiyyDDMJ2/79u2kpKREiYmJtG7dOlqzZg1t3rxZaptVq1aRlZUVXb16lRYuXEh37twhNzc3GjlyJF27do12795N58+fJ39/f/53Jk6cSA8ePKDTp0/Tvn37aOPGjZSfn19vHCUlJeTs7Ey5ubl06NAhSklJofnz55NYLKYxY8bQ3LlzqUuXLpSXl0d5eXk0ZswYIiIaPXo05efn09GjRykpKYlsbW3J1dWVCgoKiIhoz549tHjxYlq+fDlduXKFdHV1aePGje/1GZWXl5OdnR3FxsbSjRs3yMfHh7y8vCgxMfG9Pkt/f39KSEigqKgounbtGo0ePZrc3NwoMzPzveJhGOYjAsMwzCfM2dkZ5ubmEIvF/GtBQUEwNzfnfzY0NIS7u7vU702ePBk+Pj5Sr507dw4KCgooKytDeno6iAiJiYn8+2lpaSAihIeH868REWJiYgAAmzZtgpqaGp49e1ZnrKGhobCysqr1f7Zs2RLl5eVSr3fq1AmbNm0CADg6OmLatGlS7zs4ONT6WzWdPn0aRITnz5/Xu83gwYMxd+5c/ue3fZZZWVlQVFREbm6u1N9xdXVFcHAwAGDr1q1QV1ev9/9kGObjYzWLDMN88nr27Ekcx/E/Ozo60urVq0kkEpGioiIREXXv3l3qd1JSUujatWtSj5YBkFgspnv37lFGRgYpKSmRnZ0d/76ZmdkbR/omJyeTjY0NaWhovHPsKSkpVFJSQm3atJF6vaysjO7cuUNERGlpaeTr6yv1vqOjI50+ffqd/x+RSETLly+nPXv2UG5uLlVWVlJFRQWpqKhIbfemz/L69eskEonIxMRE6ncqKipqxc8wjPxgySLDMMw7UFVVlfq5pKSEpk6dSjNnzqy1rYGBAWVkZLz3/9G8efP3/p2SkhLS1dWts+6vIaegWblyJa1bt47Wrl1L3bp1I1VVVZo9ezZVVla+V6yKioqUlJTEJ+ESLVq0aLBYGYZpWCxZZBjmk3fp0iWpny9evEjGxsa1EpqabG1tKTU1lTp37lzn+2ZmZlRVVUVJSUlkb29PRETp6elvnLfQ0tKSNm/eTAUFBXX2LjZt2pREIlGtOB49ekRKSkpkZGRU5981NzenS5cukbe3t9Q+vo/4+HgaPnw4TZgwgYiIxGIxZWRkkIWFhdR2b/osbWxsSCQSUX5+PvXt2/e9/n+GYWSHDXBhGOaTl52dTQEBAZSenk6RkZG0YcMGmjVr1ht/JygoiC5cuED+/v6UnJxMmZmZdPDgQX6Ai6mpKbm5udHUqVPp0qVLlJSURFOmTHlj76Gnpyfp6OiQu7s7xcfH0927d2n//v2UkJBARNWjsu/du0fJycn09OlTqqiooP79+5OjoyO5u7vTX3/9Rffv36cLFy7QggUL6MqVK0RENGvWLNqyZQtt3bqVMjIyKDQ0lG7evPlen5GxsTEdP36cLly4QGlpaTR16lR6/Pjxe32WJiYmNH78ePL29qbo6Gi6d+8eJSYm0g8//ECxsbHvFQ/DMB8PSxYZhvnkeXt7U1lZGfXo0YOmT59Os2bN4qfHqY+lpSWdOXOGMjIyqG/fvmRjY0OLFi0iPT09fputW7eSnp4eOTs7k4eHB/n4+JCWlla9f7Np06b0119/kZaWFg0aNIi6detGYWFhfA/nyJEjyc3Njfr160dt27alyMhI4jiOjhw5Qk5OTvT111+TiYkJjR07lrKyskhbW5uIiMaMGUMLFy6k+fPnk52dHWVlZZGfn997fUbfffcd2dra0sCBA8nFxYVPat/3s9y6dSt5e3vT3LlzydTUlNzd3eny5ctkYGDwXvEwDPPxcECNCbAYhmE+MS4uLmRtbS21BB/DMAzzD9azyDAMwzAMw9SLJYsMwzAMwzBMvdhjaIZhGIZhGKZerGeRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqRdLFhmGYRiGYZh6sWSRYRiGYRiGqdf/A8Ft00FyTuAKAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 12. Create a random tensor of shape `[1, 3, 64, 64]` and pass it through a `nn.Conv2d()` layer with various hyperparameter settings (these can be any settings you choose), what do you notice if the `kernel_size` parameter goes up and down?" + ], + "metadata": { + "id": "lj6bDhoWxt2y" + } + }, + { + "cell_type": "code", + "source": [ + "random_tensor = torch.rand([1, 3, 64, 64])\n", + "random_tensor.shape\n", + "conv_layer = nn.Conv2d(in_channels=3,\n", + " out_channels=64,\n", + " kernel_size=3,\n", + " stride=2,\n", + " padding=1)\n", + "\n", + "print(f\"Random tensor original shape: {random_tensor.shape}\")\n", + "random_tensor_through_conv_layer = conv_layer(random_tensor)\n", + "print(f\"Random tensor through conv layer shape: {random_tensor_through_conv_layer.shape}\")\n" + ], + "metadata": { + "id": "leCTsqtSbR5P", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "18c91e86-d1d6-4db9-9f04-9b3c8146dd02" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Random tensor original shape: torch.Size([1, 3, 64, 64])\n", + "Random tensor through conv layer shape: torch.Size([1, 64, 32, 32])\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 13. Use a model similar to the trained `model_2` from notebook 03 to make predictions on the test [`torchvision.datasets.FashionMNIST`](https://pytorch.org/vision/main/generated/torchvision.datasets.FashionMNIST.html) dataset.\n", + "* Then plot some predictions where the model was wrong alongside what the label of the image should've been.\n", + "* After visualing these predictions do you think it's more of a modelling error or a data error?\n", + "* As in, could the model do better or are the labels of the data too close to each other (e.g. a \"Shirt\" label is too close to \"T-shirt/top\")?" + ], + "metadata": { + "id": "VHS20cNTxwSi" + } + }, + { + "cell_type": "code", + "source": [ + "# Download FashionMNIST train & test\n", + "from torchvision import datasets\n", + "from torchvision import transforms\n", + "\n", + "fashion_mnist_train = datasets.FashionMNIST(root=\".\",\n", + " download=True,\n", + " train=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "fashion_mnist_test = datasets.FashionMNIST(root=\".\",\n", + " train=False,\n", + " download=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "len(fashion_mnist_train), len(fashion_mnist_test)\n", + "# Get the class names of the Fashion MNIST dataset\n", + "fashion_mnist_class_names = fashion_mnist_train.classes\n", + "fashion_mnist_class_names" + ], + "metadata": { + "id": "78a8LjtdbSZj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3dae493e-8c24-4559-8ed8-ec6de4145e58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to ./FashionMNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 26.4M/26.4M [00:02<00:00, 9.29MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 29.5k/29.5k [00:00<00:00, 150kB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 4.42M/4.42M [00:01<00:00, 2.79MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 5.15k/5.15k [00:00<00:00, 11.5MB/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['T-shirt/top',\n", + " 'Trouser',\n", + " 'Pullover',\n", + " 'Dress',\n", + " 'Coat',\n", + " 'Sandal',\n", + " 'Shirt',\n", + " 'Sneaker',\n", + " 'Bag',\n", + " 'Ankle boot']" + ] + }, + "metadata": {}, + "execution_count": 49 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn FashionMNIST datasets into dataloaders\n", + "from torch.utils.data import DataLoader\n", + "\n", + "fashion_mnist_train_dataloader = DataLoader(fashion_mnist_train,\n", + " batch_size=32,\n", + " shuffle=True)\n", + "\n", + "fashion_mnist_test_dataloader = DataLoader(fashion_mnist_test,\n", + " batch_size=32,\n", + " shuffle=False)\n", + "\n", + "len(fashion_mnist_train_dataloader), len(fashion_mnist_test_dataloader)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CLoagbwVKEAL", + "outputId": "c52b3925-b510-47f4-f339-e659dd02e465" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 50 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# model_2 is the same architecture as MNIST_model\n", + "model_2 = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model_2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jDkmCa2tKLZy", + "outputId": "fdaaa05e-de01-44bb-ffa0-b59d1a2ca089" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 51 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss and optimizer\n", + "from torch import nn\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_2.parameters(), lr=0.01)" + ], + "metadata": { + "id": "3k_32qrnKQnY" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup metrics\n", + "from tqdm.auto import tqdm\n", + "from torchmetrics import Accuracy\n", + "\n", + "acc_fn = Accuracy(task = 'multiclass', num_classes=len(fashion_mnist_class_names)).to(device)\n", + "\n", + "# Setup training/testing loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss, test_loss_total = 0, 0\n", + " train_acc, test_acc = 0, 0\n", + "\n", + " ### Training\n", + " model_2.train()\n", + " for batch, (X_train, y_train) in enumerate(fashion_mnist_train_dataloader):\n", + " X_train, y_train = X_train.to(device), y_train.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred = model_2(X_train)\n", + " loss = loss_fn(y_pred, y_train)\n", + " train_loss += loss\n", + " train_acc += acc_fn(y_pred, y_train)\n", + "\n", + " # Backprop and gradient descent\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " train_loss /= len(fashion_mnist_train_dataloader)\n", + " train_acc /= len(fashion_mnist_train_dataloader)\n", + "\n", + " ### Testing\n", + " model_2.eval()\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(fashion_mnist_test_dataloader):\n", + " X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred_test = model_2(X_test)\n", + " test_loss = loss_fn(y_pred_test, y_test)\n", + " test_loss_total += test_loss\n", + "\n", + " test_acc += acc_fn(y_pred_test, y_test)\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " test_loss /= len(fashion_mnist_test_dataloader)\n", + " test_acc /= len(fashion_mnist_test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Train loss: {train_loss:.3f} | Train acc: {train_acc:.2f} | Test loss: {test_loss_total:.3f} | Test acc: {test_acc:.2f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 156, + "referenced_widgets": [ + "d97f28b38c98433896ac99037182b3cd", + "5171e7d0c89349d1942872a271d098d5", + "73a16e5349d341b5af0b013731ced828", + "7e44d7a46ba4402cb164b2433ffdd3bf", + "1b5f5ad03c8b4abbbcd9e9ff4c28b149", + "062c9c612da0434ba794c973c5857510", + "04ac343c4b8e419fab2787d7972b4da1", + "458a4274c8b74a289184eedd1180e26c", + "2b92883149594d35a1b72a9bbdd3e41a", + "9f9fb380066f4175aceea26385626884", + "1940c92f2cd1436cb186071674146a15" + ] + }, + "id": "71Lk8G9-KXh2", + "outputId": "a0d0ca1f-3dfa-4f1f-ad51-a163a34cda43" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 611726a72b70dcc5754c61e66903ec570af6346b Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Wed, 23 Apr 2025 16:03:12 +0100 Subject: [PATCH 16/17] Created using Colab --- .../week4/week4solution.ipynb | 3546 +++++++++++++++++ 1 file changed, 3546 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb b/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb new file mode 100644 index 0000000..b8353c7 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week4/week4solution.ipynb @@ -0,0 +1,3546 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "03_pytorch_computer_vision_exercises.ipynb", + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "13e8e56312674d3386224a2f00fd866f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0294fb9eb6fe4aff8d147f1f7cc1d553", + "IPY_MODEL_abfa0e7b82bf486e92f9d90960284d3e", + "IPY_MODEL_47b74eed37a84415a3fc42d1f19c5c4e" + ], + "layout": "IPY_MODEL_d7499f26238d4ec8a0d4ae459db82a5a" + } + }, + "0294fb9eb6fe4aff8d147f1f7cc1d553": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d3c8abcf41f4fee8069a63c0b7e603c", + "placeholder": "​", + "style": "IPY_MODEL_42ac5a11f588411dae6f326c558ff1fd", + "value": "100%" + } + }, + "abfa0e7b82bf486e92f9d90960284d3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e879e28f80d74fb4a91ba371ef73e0bc", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7f9038bdc08459fa2638e92d9090832", + "value": 5 + } + }, + "47b74eed37a84415a3fc42d1f19c5c4e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_59125daa8589482a84193b4f52778612", + "placeholder": "​", + "style": "IPY_MODEL_47b099254fd7441cbcc3ab185374b22d", + "value": " 5/5 [04:17<00:00, 50.76s/it]" + } + }, + "d7499f26238d4ec8a0d4ae459db82a5a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d3c8abcf41f4fee8069a63c0b7e603c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42ac5a11f588411dae6f326c558ff1fd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e879e28f80d74fb4a91ba371ef73e0bc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7f9038bdc08459fa2638e92d9090832": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "59125daa8589482a84193b4f52778612": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47b099254fd7441cbcc3ab185374b22d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63e8ded88a124e61be96e5ecb60bfa8f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bb7d551f066841259a0881d98d9f677d", + "IPY_MODEL_74d4bcf2fd1f49efbf1b0393ab9bfb97", + "IPY_MODEL_688974c6acb948d9a503736947cd9d7b" + ], + "layout": "IPY_MODEL_ace5b23c36684cc7b767948efa2e5738" + } + }, + "bb7d551f066841259a0881d98d9f677d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0851980655a4669b356d632bf906959", + "placeholder": "​", + "style": "IPY_MODEL_2b88ffbcb8f54670b8da513dd1b99f02", + "value": "100%" + } + }, + "74d4bcf2fd1f49efbf1b0393ab9bfb97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b378dc2ab434c8a8b636e4b0f60431d", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dc5d8f1541954a3b83695a4dd55c48eb", + "value": 5 + } + }, + "688974c6acb948d9a503736947cd9d7b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_402e5c1c13bf4b34a73b9bd332edc798", + "placeholder": "​", + "style": "IPY_MODEL_660ab68ad7a64d38aec90fb79de21009", + "value": " 5/5 [01:29<00:00, 17.90s/it]" + } + }, + "ace5b23c36684cc7b767948efa2e5738": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0851980655a4669b356d632bf906959": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b88ffbcb8f54670b8da513dd1b99f02": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b378dc2ab434c8a8b636e4b0f60431d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc5d8f1541954a3b83695a4dd55c48eb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "402e5c1c13bf4b34a73b9bd332edc798": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "660ab68ad7a64d38aec90fb79de21009": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2963dd0080b449d8f7f90573c4da188": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9db0a911e60c4271b78101ea50573155", + "IPY_MODEL_cbdaec3285264cd2a71bab7d8a8216f9", + "IPY_MODEL_0d573b771475435fa51639e5bfb8cb28" + ], + "layout": "IPY_MODEL_c08d9d15e6eb4e818aa97aa31c66ec95" + } + }, + "9db0a911e60c4271b78101ea50573155": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_08da86e0e8404cd1b02654bd24c62732", + "placeholder": "​", + "style": "IPY_MODEL_45397b429d5d47feab451defd8614c0d", + "value": "" + } + }, + "cbdaec3285264cd2a71bab7d8a8216f9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3beb124807bb4957940a8e9638f0fa5c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c49009c851e94e55b2c1f3c4c901e205", + "value": 1 + } + }, + "0d573b771475435fa51639e5bfb8cb28": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ae0360136974b5ba1b7b607de3686c1", + "placeholder": "​", + "style": "IPY_MODEL_2e9c4f7159c545efb4f667c1be12a5b0", + "value": " 313/? [00:03<00:00, 137.66it/s]" + } + }, + "c08d9d15e6eb4e818aa97aa31c66ec95": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08da86e0e8404cd1b02654bd24c62732": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "45397b429d5d47feab451defd8614c0d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3beb124807bb4957940a8e9638f0fa5c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "c49009c851e94e55b2c1f3c4c901e205": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8ae0360136974b5ba1b7b607de3686c1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e9c4f7159c545efb4f667c1be12a5b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d97f28b38c98433896ac99037182b3cd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5171e7d0c89349d1942872a271d098d5", + "IPY_MODEL_73a16e5349d341b5af0b013731ced828", + "IPY_MODEL_7e44d7a46ba4402cb164b2433ffdd3bf" + ], + "layout": "IPY_MODEL_1b5f5ad03c8b4abbbcd9e9ff4c28b149" + } + }, + "5171e7d0c89349d1942872a271d098d5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_062c9c612da0434ba794c973c5857510", + "placeholder": "​", + "style": "IPY_MODEL_04ac343c4b8e419fab2787d7972b4da1", + "value": "100%" + } + }, + "73a16e5349d341b5af0b013731ced828": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_458a4274c8b74a289184eedd1180e26c", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2b92883149594d35a1b72a9bbdd3e41a", + "value": 5 + } + }, + "7e44d7a46ba4402cb164b2433ffdd3bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f9fb380066f4175aceea26385626884", + "placeholder": "​", + "style": "IPY_MODEL_1940c92f2cd1436cb186071674146a15", + "value": " 5/5 [01:14<00:00, 15.47s/it]" + } + }, + "1b5f5ad03c8b4abbbcd9e9ff4c28b149": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "062c9c612da0434ba794c973c5857510": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04ac343c4b8e419fab2787d7972b4da1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "458a4274c8b74a289184eedd1180e26c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b92883149594d35a1b72a9bbdd3e41a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f9fb380066f4175aceea26385626884": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1940c92f2cd1436cb186071674146a15": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4aa82d89f2074e89bb514adf1f407d60": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e8de50e36e644606b76bee73e655e11e", + "IPY_MODEL_2491b725d5cf46b9ad30ba1b46c2c7a8", + "IPY_MODEL_7063a77f761f4402a0dbd434f6475939" + ], + "layout": "IPY_MODEL_6aa262b1d0284761918302feaf86796c" + } + }, + "e8de50e36e644606b76bee73e655e11e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d98b13403cf47858fc9be646fcb151d", + "placeholder": "​", + "style": "IPY_MODEL_c887d4b92fd14828ba47c71ee383932c", + "value": "100%" + } + }, + "2491b725d5cf46b9ad30ba1b46c2c7a8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_104ae0dd35bb440283deb4a98686e985", + "max": 313, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1280745dd25547799bd36c359e1ab41b", + "value": 313 + } + }, + "7063a77f761f4402a0dbd434f6475939": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb1b53c81546478985715a780717505b", + "placeholder": "​", + "style": "IPY_MODEL_5e1911efa81c48ed9c36093c74466df5", + "value": " 313/313 [00:01<00:00, 192.77it/s]" + } + }, + "6aa262b1d0284761918302feaf86796c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d98b13403cf47858fc9be646fcb151d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c887d4b92fd14828ba47c71ee383932c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "104ae0dd35bb440283deb4a98686e985": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1280745dd25547799bd36c359e1ab41b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb1b53c81546478985715a780717505b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e1911efa81c48ed9c36093c74466df5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 03. PyTorch Computer Vision Exercises\n", + "\n", + "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n", + "\n", + "They're a bunch of fun.\n", + "\n", + "You're going to get to write plenty of code!\n", + "\n", + "## Resources\n", + "\n", + "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n", + "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n", + " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n", + "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)." + ], + "metadata": { + "id": "Vex99np2wFVt" + } + }, + { + "cell_type": "code", + "source": [ + "# Check for GPU\n", + "!nvidia-smi" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GaeYzOTLwWh2", + "outputId": "4e093661-df6c-4507-fe47-c979c6544f8d" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Wed Apr 23 14:56:22 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n", + "|-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 66C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Exercises require PyTorch > 1.10.0\n", + "print(torch.__version__)\n", + "\n", + "# TODO: Setup device agnostic code\n", + "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "DNwZLMbCzJLk", + "outputId": "67260ac6-de01-4400-9a6e-3c752e1e325d" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.6.0+cu124\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 2 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. What are 3 areas in industry where computer vision is currently being used?" + ], + "metadata": { + "id": "FSFX7tc1w-en" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "VyWRkvWGbCXj" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n", + "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n", + "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n" + ], + "metadata": { + "id": "ZOnG1GHLZKMc" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find." + ], + "metadata": { + "id": "oBK-WI6YxDYa" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "d1rxD6GObCqh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n" + ], + "metadata": { + "id": "xOtfv8elZwOI" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n", + "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those." + ], + "metadata": { + "id": "XeYFEqw8xK26" + } + }, + { + "cell_type": "markdown", + "source": [ + "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n", + "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n", + "3. Randomly turns off neurons during training to prevent dependency on specific features.\n" + ], + "metadata": { + "id": "LswlbpepaAIG" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n", + "\n", + "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it." + ], + "metadata": { + "id": "DKdEEFEqxM-8" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets." + ], + "metadata": { + "id": "lvf-3pODxXYI" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "# Define transform\n", + "transform = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.1307,), (0.3081,))\n", + "])\n", + "\n", + "# Load train and test datasets\n", + "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n", + "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n", + "\n", + "\n" + ], + "metadata": { + "id": "SHjeuN81bHza" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "train_data, test_data" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "R_uWK0KpFFep", + "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(Dataset MNIST\n", + " Number of datapoints: 60000\n", + " Root location: ./data\n", + " Split: Train\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ),\n", + " Dataset MNIST\n", + " Number of datapoints: 10000\n", + " Root location: ./data\n", + " Split: Test\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ))" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_data), len(test_data)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ePSUg0oGEoHF", + "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(60000, 10000)" + ] + }, + "metadata": {}, + "execution_count": 22 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Get the class names from the dataset\n", + "class_names = train_data.classes\n", + "class_names\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TN6d1nUxD_64", + "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['0 - zero',\n", + " '1 - one',\n", + " '2 - two',\n", + " '3 - three',\n", + " '4 - four',\n", + " '5 - five',\n", + " '6 - six',\n", + " '7 - seven',\n", + " '8 - eight',\n", + " '9 - nine']" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Visualize at least 5 different samples of the MNIST training dataset." + ], + "metadata": { + "id": "qxZW-uAbxe_F" + } + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Function to visualize images\n", + "def show_images(dataset, num_images=5):\n", + " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n", + " for i in range(num_images):\n", + " img, label = dataset[i]\n", + " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n", + " axes[i].set_title(f\"Label: {label}\")\n", + " axes[i].axis(\"off\")\n", + "\n", + "show_images(train_data)\n" + ], + "metadata": { + "id": "QVFsYi1PbItE", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "outputId": "ac991564-8773-4a32-b49f-273fd1284fea" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Turn the MNIST train and test datasets into dataloaders using `torch.utils.data.DataLoader`, set the `batch_size=32`." + ], + "metadata": { + "id": "JAPDzW0wxhi3" + } + }, + { + "cell_type": "code", + "source": [ + "from torch.utils.data import DataLoader\n", + "\n", + "# Define batch size\n", + "batch_size = 32\n", + "\n", + "# Create DataLoaders\n", + "train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", + "test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False)\n", + "\n", + "# Print batch details\n", + "for images, labels in train_dataloader:\n", + " print(f\"Batch size: {images.shape}, Labels: {labels.shape}\")\n", + " break # Print one batch\n" + ], + "metadata": { + "id": "ALA6MPcFbJXQ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "95559a37-fe65-4188-a636-bcca4287d28e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Batch size: torch.Size([32, 1, 28, 28]), Labels: torch.Size([32])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "train_dataloader, test_dataloader" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XHFFOphgfGZW", + "outputId": "a0dfbce4-ce4c-49c0-fe69-96cf6a4d4b36" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_dataloader), len(test_dataloader)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j8dnGKN9fqls", + "outputId": "82b4c2d4-f837-4295-8dcd-f4f796e807ef" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 8. Recreate `model_2` used in notebook 03 (the same model from the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/), also known as TinyVGG) capable of fitting on the MNIST dataset." + ], + "metadata": { + "id": "bCCVfXk5xjYS" + } + }, + { + "cell_type": "code", + "source": [ + "from torch import nn\n", + "class MNIST_model(torch.nn.Module):\n", + " \"\"\"Model capable of predicting on MNIST dataset.\n", + " \"\"\"\n", + " def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n", + " super().__init__()\n", + " self.conv_block_1 = nn.Sequential(\n", + " nn.Conv2d(in_channels=input_shape,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.conv_block_2 = nn.Sequential(\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.classifier = nn.Sequential(\n", + " nn.Flatten(),\n", + " nn.Linear(in_features=hidden_units*7*7,\n", + " out_features=output_shape)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x = self.conv_block_1(x)\n", + " # print(f\"Output shape of conv block 1: {x.shape}\")\n", + " x = self.conv_block_2(x)\n", + " # print(f\"Output shape of conv block 2: {x.shape}\")\n", + " x = self.classifier(x)\n", + " # print(f\"Output shape of classifier: {x.shape}\")\n", + " return x" + ], + "metadata": { + "id": "5IKNF22XbKYS" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "device" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "vEOGcDMleA2p", + "outputId": "0fccc8ce-fb26-47e0-e857-325a2a4ec817" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "zFhrF_r2eB8E" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "G2cEdnITd68u" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uNDTL66DeDHD", + "outputId": "aa9720f2-ce7e-4758-a857-95c7ee868e6b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Try a dummy forward pass to see what shapes our data is\n", + "dummy_x = torch.rand(size=(1, 28, 28)).unsqueeze(dim=0).to(device)\n", + "# dummy_x.shape\n", + "model(dummy_x)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "K4q5XDGGeQQk", + "outputId": "fba05e28-fcae-445d-9744-b564058f7a58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[-0.0237, 0.0819, 0.0189, 0.0228, -0.0252, 0.0080, -0.0020, -0.0176,\n", + " 0.0736, 0.0680]], device='cuda:0', grad_fn=)" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dummy_x_2 = torch.rand(size=([1, 10, 7, 7]))\n", + "dummy_x_2.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Lt9JtODAeXNE", + "outputId": "bbea492f-6ad4-49b9-8638-ccfc885dc3fd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 10, 7, 7])" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "flatten_layer = nn.Flatten()\n", + "flatten_layer(dummy_x_2).shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A9OT0ZW-eZ13", + "outputId": "32667c27-984c-4ce9-f951-4df41f3729c2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 490])" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 9. Train the model you built in exercise 8. for 5 epochs on CPU and GPU and see how long it takes on each." + ], + "metadata": { + "id": "sf_3zUr7xlhy" + } + }, + { + "cell_type": "code", + "source": [ + "%%time\n", + "from tqdm.auto import tqdm\n", + "\n", + "# Train on CPU\n", + "model_cpu = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(\"cpu\")\n", + "\n", + "# Create a loss function and optimizer\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_cpu.parameters(), lr=0.1)\n", + "\n", + "### Training loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss = 0\n", + " for batch, (X, y) in enumerate(train_dataloader):\n", + " model_cpu.train()\n", + "\n", + " # Put data on CPU\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Forward pass\n", + " y_pred = model_cpu(X)\n", + "\n", + " # Loss calculation\n", + " loss = loss_fn(y_pred, y)\n", + " train_loss += loss\n", + " # Optimizer zero grad\n", + " optimizer.zero_grad()\n", + "\n", + " # Loss backward\n", + " loss.backward()\n", + "\n", + " # Step the optimizer\n", + " optimizer.step()\n", + "\n", + " # Adjust train loss for number of batches\n", + " train_loss /= len(train_dataloader)\n", + "\n", + " ### Testing loop\n", + " test_loss_total = 0\n", + "\n", + " # Put model in eval mode\n", + " model_cpu.eval()\n", + "\n", + " # Turn on inference mode\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(test_dataloader):\n", + " # Make sure test data on CPU\n", + " X_test, y_test = X_test.to(\"cpu\"), y_test.to(\"cpu\")\n", + " test_pred = model_cpu(X_test)\n", + " test_loss = loss_fn(test_pred, y_test)\n", + "\n", + " test_loss_total += test_loss\n", + "\n", + " test_loss_total /= len(test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Loss: {train_loss:.3f} | Test loss: {test_loss_total:.3f}\")" + ], + "metadata": { + "id": "jSo6vVWFbNLD", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 170, + "referenced_widgets": [ + "13e8e56312674d3386224a2f00fd866f", + "0294fb9eb6fe4aff8d147f1f7cc1d553", + "abfa0e7b82bf486e92f9d90960284d3e", + "47b74eed37a84415a3fc42d1f19c5c4e", + "d7499f26238d4ec8a0d4ae459db82a5a", + "9d3c8abcf41f4fee8069a63c0b7e603c", + "42ac5a11f588411dae6f326c558ff1fd", + "e879e28f80d74fb4a91ba371ef73e0bc", + "c7f9038bdc08459fa2638e92d9090832", + "59125daa8589482a84193b4f52778612", + "47b099254fd7441cbcc3ab185374b22d" + ] + }, + "outputId": "d75a4a87-a629-4fd4-a671-180d8e20e320" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ] + }, + "metadata": {}, + "execution_count": 41 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Logits -> Prediction probabilities -> Prediction labels\n", + "model_pred_logits = model_gpu(test_data[0][0].unsqueeze(dim=0).to(device)) # make sure image is right shape + on right device\n", + "model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + "model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "model_pred_label\n", + "num_to_plot = 5\n", + "for i in range(num_to_plot):\n", + " # Get image and labels from the test data\n", + " img = test_data[i][0]\n", + " label = test_data[i][1]\n", + "\n", + " # Make prediction on image\n", + " model_pred_logits = model_gpu(img.unsqueeze(dim=0).to(device))\n", + " model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + " model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "\n", + " # Plot the image and prediction\n", + " plt.figure()\n", + " plt.imshow(img.squeeze(), cmap=\"gray\")\n", + " plt.title(f\"Truth: {label} | Pred: {model_pred_label.cpu().item()}\")\n", + " plt.axis(False);" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "8qlR_6njh0Kp", + "outputId": "a4e56a0e-25e8-47b7-ea34-9e59abcc9441" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 11. Plot a confusion matrix comparing your model's predictions to the truth labels." + ], + "metadata": { + "id": "qQwzqlBWxrpG" + } + }, + { + "cell_type": "code", + "source": [ + "# See if torchmetrics exists, if not, install it\n", + "try:\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " assert int(mlxtend.__version__.split(\".\")[1]) >= 19, \"mlxtend verison should be 0.19.0 or higher\"\n", + "except:\n", + " !pip install -q torchmetrics -U mlxtend # <- Note: If you're using Google Colab, this may require restarting the runtime\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " # Import mlxtend upgraded version\n", + "import mlxtend\n", + "print(mlxtend.__version__)\n", + "assert int(mlxtend.__version__.split(\".\")[1]) >= 19" + ], + "metadata": { + "id": "vSrXiT_AbQ6e", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "40248d65-99ff-43d7-af57-cabb3e8933bf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m49.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m109.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m84.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m51.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m12.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m86.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hmlxtend version: 0.23.4\n", + "0.23.4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make predictions across all test data\n", + "from tqdm.auto import tqdm\n", + "model_gpu.eval()\n", + "y_preds = []\n", + "with torch.inference_mode():\n", + " for batch, (X, y) in tqdm(enumerate(test_dataloader)):\n", + " # Make sure data on right device\n", + " X, y = X.to(device), y.to(device)\n", + " # Forward pass\n", + " y_pred_logits = model_gpu(X)\n", + " # Logits -> Pred probs -> Pred label\n", + " y_pred_labels = torch.argmax(torch.softmax(y_pred_logits, dim=1), dim=1)\n", + " # Append the labels to the preds list\n", + " y_preds.append(y_pred_labels)\n", + " y_preds=torch.cat(y_preds).cpu()\n", + "len(y_preds)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 66, + "referenced_widgets": [ + "a2963dd0080b449d8f7f90573c4da188", + "9db0a911e60c4271b78101ea50573155", + "cbdaec3285264cd2a71bab7d8a8216f9", + "0d573b771475435fa51639e5bfb8cb28", + "c08d9d15e6eb4e818aa97aa31c66ec95", + "08da86e0e8404cd1b02654bd24c62732", + "45397b429d5d47feab451defd8614c0d", + "3beb124807bb4957940a8e9638f0fa5c", + "c49009c851e94e55b2c1f3c4c901e205", + "8ae0360136974b5ba1b7b607de3686c1", + "2e9c4f7159c545efb4f667c1be12a5b0" + ] + }, + "id": "YmzNi-X_iaN7", + "outputId": "73f9d0e9-0adb-40dd-a91a-2aded6723ef1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "0it [00:00, ?it/s]" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "a2963dd0080b449d8f7f90573c4da188" + } + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "10000" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "source": [ + "test_data.targets[:10], y_preds[:10]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qQC7oh1tig9S", + "outputId": "a80a26d7-182a-4fc3-a1ea-f9edb46e8337" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]),\n", + " tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]))" + ] + }, + "metadata": {}, + "execution_count": 46 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from torchmetrics import ConfusionMatrix\n", + "from mlxtend.plotting import plot_confusion_matrix\n", + "\n", + "# Setup confusion matrix\n", + "confmat = ConfusionMatrix(task=\"multiclass\", num_classes=len(class_names))\n", + "confmat_tensor = confmat(preds=y_preds,\n", + " target=test_data.targets)\n", + "\n", + "# Plot the confusion matrix\n", + "fix, ax = plot_confusion_matrix(\n", + " conf_mat=confmat_tensor.numpy(),\n", + " class_names=class_names,\n", + " figsize=(10, 7)\n", + ")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 638 + }, + "id": "czblDny_in5U", + "outputId": "11864434-840c-4d49-d8c9-4c974f04fb55" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 12. Create a random tensor of shape `[1, 3, 64, 64]` and pass it through a `nn.Conv2d()` layer with various hyperparameter settings (these can be any settings you choose), what do you notice if the `kernel_size` parameter goes up and down?" + ], + "metadata": { + "id": "lj6bDhoWxt2y" + } + }, + { + "cell_type": "code", + "source": [ + "random_tensor = torch.rand([1, 3, 64, 64])\n", + "random_tensor.shape\n", + "conv_layer = nn.Conv2d(in_channels=3,\n", + " out_channels=64,\n", + " kernel_size=3,\n", + " stride=2,\n", + " padding=1)\n", + "\n", + "print(f\"Random tensor original shape: {random_tensor.shape}\")\n", + "random_tensor_through_conv_layer = conv_layer(random_tensor)\n", + "print(f\"Random tensor through conv layer shape: {random_tensor_through_conv_layer.shape}\")\n" + ], + "metadata": { + "id": "leCTsqtSbR5P", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "18c91e86-d1d6-4db9-9f04-9b3c8146dd02" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Random tensor original shape: torch.Size([1, 3, 64, 64])\n", + "Random tensor through conv layer shape: torch.Size([1, 64, 32, 32])\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 13. Use a model similar to the trained `model_2` from notebook 03 to make predictions on the test [`torchvision.datasets.FashionMNIST`](https://pytorch.org/vision/main/generated/torchvision.datasets.FashionMNIST.html) dataset.\n", + "* Then plot some predictions where the model was wrong alongside what the label of the image should've been.\n", + "* After visualing these predictions do you think it's more of a modelling error or a data error?\n", + "* As in, could the model do better or are the labels of the data too close to each other (e.g. a \"Shirt\" label is too close to \"T-shirt/top\")?" + ], + "metadata": { + "id": "VHS20cNTxwSi" + } + }, + { + "cell_type": "code", + "source": [ + "# Download FashionMNIST train & test\n", + "from torchvision import datasets\n", + "from torchvision import transforms\n", + "\n", + "fashion_mnist_train = datasets.FashionMNIST(root=\".\",\n", + " download=True,\n", + " train=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "fashion_mnist_test = datasets.FashionMNIST(root=\".\",\n", + " train=False,\n", + " download=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "len(fashion_mnist_train), len(fashion_mnist_test)\n", + "# Get the class names of the Fashion MNIST dataset\n", + "fashion_mnist_class_names = fashion_mnist_train.classes\n", + "fashion_mnist_class_names" + ], + "metadata": { + "id": "78a8LjtdbSZj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3dae493e-8c24-4559-8ed8-ec6de4145e58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to ./FashionMNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 26.4M/26.4M [00:02<00:00, 9.29MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 29.5k/29.5k [00:00<00:00, 150kB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 4.42M/4.42M [00:01<00:00, 2.79MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 5.15k/5.15k [00:00<00:00, 11.5MB/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['T-shirt/top',\n", + " 'Trouser',\n", + " 'Pullover',\n", + " 'Dress',\n", + " 'Coat',\n", + " 'Sandal',\n", + " 'Shirt',\n", + " 'Sneaker',\n", + " 'Bag',\n", + " 'Ankle boot']" + ] + }, + "metadata": {}, + "execution_count": 49 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn FashionMNIST datasets into dataloaders\n", + "from torch.utils.data import DataLoader\n", + "\n", + "fashion_mnist_train_dataloader = DataLoader(fashion_mnist_train,\n", + " batch_size=32,\n", + " shuffle=True)\n", + "\n", + "fashion_mnist_test_dataloader = DataLoader(fashion_mnist_test,\n", + " batch_size=32,\n", + " shuffle=False)\n", + "\n", + "len(fashion_mnist_train_dataloader), len(fashion_mnist_test_dataloader)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CLoagbwVKEAL", + "outputId": "c52b3925-b510-47f4-f339-e659dd02e465" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 50 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# model_2 is the same architecture as MNIST_model\n", + "model_2 = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model_2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jDkmCa2tKLZy", + "outputId": "fdaaa05e-de01-44bb-ffa0-b59d1a2ca089" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 51 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss and optimizer\n", + "from torch import nn\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_2.parameters(), lr=0.01)" + ], + "metadata": { + "id": "3k_32qrnKQnY" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup metrics\n", + "from tqdm.auto import tqdm\n", + "from torchmetrics import Accuracy\n", + "\n", + "acc_fn = Accuracy(task = 'multiclass', num_classes=len(fashion_mnist_class_names)).to(device)\n", + "\n", + "# Setup training/testing loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss, test_loss_total = 0, 0\n", + " train_acc, test_acc = 0, 0\n", + "\n", + " ### Training\n", + " model_2.train()\n", + " for batch, (X_train, y_train) in enumerate(fashion_mnist_train_dataloader):\n", + " X_train, y_train = X_train.to(device), y_train.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred = model_2(X_train)\n", + " loss = loss_fn(y_pred, y_train)\n", + " train_loss += loss\n", + " train_acc += acc_fn(y_pred, y_train)\n", + "\n", + " # Backprop and gradient descent\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " train_loss /= len(fashion_mnist_train_dataloader)\n", + " train_acc /= len(fashion_mnist_train_dataloader)\n", + "\n", + " ### Testing\n", + " model_2.eval()\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(fashion_mnist_test_dataloader):\n", + " X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred_test = model_2(X_test)\n", + " test_loss = loss_fn(y_pred_test, y_test)\n", + " test_loss_total += test_loss\n", + "\n", + " test_acc += acc_fn(y_pred_test, y_test)\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " test_loss /= len(fashion_mnist_test_dataloader)\n", + " test_acc /= len(fashion_mnist_test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Train loss: {train_loss:.3f} | Train acc: {train_acc:.2f} | Test loss: {test_loss_total:.3f} | Test acc: {test_acc:.2f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 156, + "referenced_widgets": [ + "d97f28b38c98433896ac99037182b3cd", + "5171e7d0c89349d1942872a271d098d5", + "73a16e5349d341b5af0b013731ced828", + "7e44d7a46ba4402cb164b2433ffdd3bf", + "1b5f5ad03c8b4abbbcd9e9ff4c28b149", + "062c9c612da0434ba794c973c5857510", + "04ac343c4b8e419fab2787d7972b4da1", + "458a4274c8b74a289184eedd1180e26c", + "2b92883149594d35a1b72a9bbdd3e41a", + "9f9fb380066f4175aceea26385626884", + "1940c92f2cd1436cb186071674146a15" + ] + }, + "id": "71Lk8G9-KXh2", + "outputId": "a0d0ca1f-3dfa-4f1f-ad51-a163a34cda43" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 0cc8802a2d7d4af11aad0571373c8a1c545a85f5 Mon Sep 17 00:00:00 2001 From: maryamalka85 <159553440+maryamalka85@users.noreply.github.com> Date: Wed, 23 Apr 2025 16:47:20 +0100 Subject: [PATCH 17/17] Created using Colab --- ...03_pytorch_computer_vision_exercises.ipynb | 3527 +++++++++++++++++ 1 file changed, 3527 insertions(+) create mode 100644 Part_1_Deep_Learning_with_Pytorch/week4/Copy_of_03_pytorch_computer_vision_exercises.ipynb diff --git a/Part_1_Deep_Learning_with_Pytorch/week4/Copy_of_03_pytorch_computer_vision_exercises.ipynb b/Part_1_Deep_Learning_with_Pytorch/week4/Copy_of_03_pytorch_computer_vision_exercises.ipynb new file mode 100644 index 0000000..9143248 --- /dev/null +++ b/Part_1_Deep_Learning_with_Pytorch/week4/Copy_of_03_pytorch_computer_vision_exercises.ipynb @@ -0,0 +1,3527 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "13e8e56312674d3386224a2f00fd866f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0294fb9eb6fe4aff8d147f1f7cc1d553", + "IPY_MODEL_abfa0e7b82bf486e92f9d90960284d3e", + "IPY_MODEL_47b74eed37a84415a3fc42d1f19c5c4e" + ], + "layout": "IPY_MODEL_d7499f26238d4ec8a0d4ae459db82a5a" + } + }, + "0294fb9eb6fe4aff8d147f1f7cc1d553": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9d3c8abcf41f4fee8069a63c0b7e603c", + "placeholder": "​", + "style": "IPY_MODEL_42ac5a11f588411dae6f326c558ff1fd", + "value": "100%" + } + }, + "abfa0e7b82bf486e92f9d90960284d3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e879e28f80d74fb4a91ba371ef73e0bc", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7f9038bdc08459fa2638e92d9090832", + "value": 5 + } + }, + "47b74eed37a84415a3fc42d1f19c5c4e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_59125daa8589482a84193b4f52778612", + "placeholder": "​", + "style": "IPY_MODEL_47b099254fd7441cbcc3ab185374b22d", + "value": " 5/5 [04:17<00:00, 50.76s/it]" + } + }, + "d7499f26238d4ec8a0d4ae459db82a5a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9d3c8abcf41f4fee8069a63c0b7e603c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "42ac5a11f588411dae6f326c558ff1fd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "e879e28f80d74fb4a91ba371ef73e0bc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7f9038bdc08459fa2638e92d9090832": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "59125daa8589482a84193b4f52778612": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "47b099254fd7441cbcc3ab185374b22d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "63e8ded88a124e61be96e5ecb60bfa8f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_bb7d551f066841259a0881d98d9f677d", + "IPY_MODEL_74d4bcf2fd1f49efbf1b0393ab9bfb97", + "IPY_MODEL_688974c6acb948d9a503736947cd9d7b" + ], + "layout": "IPY_MODEL_ace5b23c36684cc7b767948efa2e5738" + } + }, + "bb7d551f066841259a0881d98d9f677d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e0851980655a4669b356d632bf906959", + "placeholder": "​", + "style": "IPY_MODEL_2b88ffbcb8f54670b8da513dd1b99f02", + "value": "100%" + } + }, + "74d4bcf2fd1f49efbf1b0393ab9bfb97": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7b378dc2ab434c8a8b636e4b0f60431d", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_dc5d8f1541954a3b83695a4dd55c48eb", + "value": 5 + } + }, + "688974c6acb948d9a503736947cd9d7b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_402e5c1c13bf4b34a73b9bd332edc798", + "placeholder": "​", + "style": "IPY_MODEL_660ab68ad7a64d38aec90fb79de21009", + "value": " 5/5 [01:29<00:00, 17.90s/it]" + } + }, + "ace5b23c36684cc7b767948efa2e5738": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e0851980655a4669b356d632bf906959": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b88ffbcb8f54670b8da513dd1b99f02": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "7b378dc2ab434c8a8b636e4b0f60431d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "dc5d8f1541954a3b83695a4dd55c48eb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "402e5c1c13bf4b34a73b9bd332edc798": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "660ab68ad7a64d38aec90fb79de21009": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "a2963dd0080b449d8f7f90573c4da188": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_9db0a911e60c4271b78101ea50573155", + "IPY_MODEL_cbdaec3285264cd2a71bab7d8a8216f9", + "IPY_MODEL_0d573b771475435fa51639e5bfb8cb28" + ], + "layout": "IPY_MODEL_c08d9d15e6eb4e818aa97aa31c66ec95" + } + }, + "9db0a911e60c4271b78101ea50573155": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_08da86e0e8404cd1b02654bd24c62732", + "placeholder": "​", + "style": "IPY_MODEL_45397b429d5d47feab451defd8614c0d", + "value": "" + } + }, + "cbdaec3285264cd2a71bab7d8a8216f9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_3beb124807bb4957940a8e9638f0fa5c", + "max": 1, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c49009c851e94e55b2c1f3c4c901e205", + "value": 1 + } + }, + "0d573b771475435fa51639e5bfb8cb28": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_8ae0360136974b5ba1b7b607de3686c1", + "placeholder": "​", + "style": "IPY_MODEL_2e9c4f7159c545efb4f667c1be12a5b0", + "value": " 313/? [00:03<00:00, 137.66it/s]" + } + }, + "c08d9d15e6eb4e818aa97aa31c66ec95": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "08da86e0e8404cd1b02654bd24c62732": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "45397b429d5d47feab451defd8614c0d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "3beb124807bb4957940a8e9638f0fa5c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "c49009c851e94e55b2c1f3c4c901e205": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "8ae0360136974b5ba1b7b607de3686c1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2e9c4f7159c545efb4f667c1be12a5b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "d97f28b38c98433896ac99037182b3cd": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5171e7d0c89349d1942872a271d098d5", + "IPY_MODEL_73a16e5349d341b5af0b013731ced828", + "IPY_MODEL_7e44d7a46ba4402cb164b2433ffdd3bf" + ], + "layout": "IPY_MODEL_1b5f5ad03c8b4abbbcd9e9ff4c28b149" + } + }, + "5171e7d0c89349d1942872a271d098d5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_062c9c612da0434ba794c973c5857510", + "placeholder": "​", + "style": "IPY_MODEL_04ac343c4b8e419fab2787d7972b4da1", + "value": "100%" + } + }, + "73a16e5349d341b5af0b013731ced828": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_458a4274c8b74a289184eedd1180e26c", + "max": 5, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_2b92883149594d35a1b72a9bbdd3e41a", + "value": 5 + } + }, + "7e44d7a46ba4402cb164b2433ffdd3bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_9f9fb380066f4175aceea26385626884", + "placeholder": "​", + "style": "IPY_MODEL_1940c92f2cd1436cb186071674146a15", + "value": " 5/5 [01:14<00:00, 15.47s/it]" + } + }, + "1b5f5ad03c8b4abbbcd9e9ff4c28b149": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "062c9c612da0434ba794c973c5857510": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "04ac343c4b8e419fab2787d7972b4da1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "458a4274c8b74a289184eedd1180e26c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2b92883149594d35a1b72a9bbdd3e41a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "9f9fb380066f4175aceea26385626884": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1940c92f2cd1436cb186071674146a15": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "4aa82d89f2074e89bb514adf1f407d60": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e8de50e36e644606b76bee73e655e11e", + "IPY_MODEL_2491b725d5cf46b9ad30ba1b46c2c7a8", + "IPY_MODEL_7063a77f761f4402a0dbd434f6475939" + ], + "layout": "IPY_MODEL_6aa262b1d0284761918302feaf86796c" + } + }, + "e8de50e36e644606b76bee73e655e11e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_0d98b13403cf47858fc9be646fcb151d", + "placeholder": "​", + "style": "IPY_MODEL_c887d4b92fd14828ba47c71ee383932c", + "value": "100%" + } + }, + "2491b725d5cf46b9ad30ba1b46c2c7a8": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_104ae0dd35bb440283deb4a98686e985", + "max": 313, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1280745dd25547799bd36c359e1ab41b", + "value": 313 + } + }, + "7063a77f761f4402a0dbd434f6475939": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_eb1b53c81546478985715a780717505b", + "placeholder": "​", + "style": "IPY_MODEL_5e1911efa81c48ed9c36093c74466df5", + "value": " 313/313 [00:01<00:00, 192.77it/s]" + } + }, + "6aa262b1d0284761918302feaf86796c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0d98b13403cf47858fc9be646fcb151d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c887d4b92fd14828ba47c71ee383932c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "104ae0dd35bb440283deb4a98686e985": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1280745dd25547799bd36c359e1ab41b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "eb1b53c81546478985715a780717505b": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5e1911efa81c48ed9c36093c74466df5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 03. PyTorch Computer Vision Exercises\n", + "\n", + "The following is a collection of exercises based on computer vision fundamentals in PyTorch.\n", + "\n", + "They're a bunch of fun.\n", + "\n", + "You're going to get to write plenty of code!\n", + "\n", + "## Resources\n", + "\n", + "1. These exercises are based on [notebook 03 of the Learn PyTorch for Deep Learning course](https://www.learnpytorch.io/03_pytorch_computer_vision/).\n", + "2. See a live [walkthrough of the solutions (errors and all) on YouTube](https://youtu.be/_PibmqpEyhA).\n", + " * **Note:** Going through these exercises took me just over 3 hours of solid coding, so you should expect around the same.\n", + "3. See [other solutions on the course GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions)." + ], + "metadata": { + "id": "Vex99np2wFVt" + } + }, + { + "cell_type": "code", + "source": [ + "# Check for GPU\n", + "!nvidia-smi" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GaeYzOTLwWh2", + "outputId": "4e093661-df6c-4507-fe47-c979c6544f8d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Wed Apr 23 14:56:22 2025 \n", + "+-----------------------------------------------------------------------------------------+\n", + "| NVIDIA-SMI 550.54.15 Driver Version: 550.54.15 CUDA Version: 12.4 |\n", + "|-----------------------------------------+------------------------+----------------------+\n", + "| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |\n", + "| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |\n", + "| | | MIG M. |\n", + "|=========================================+========================+======================|\n", + "| 0 Tesla T4 Off | 00000000:00:04.0 Off | 0 |\n", + "| N/A 66C P8 11W / 70W | 0MiB / 15360MiB | 0% Default |\n", + "| | | N/A |\n", + "+-----------------------------------------+------------------------+----------------------+\n", + " \n", + "+-----------------------------------------------------------------------------------------+\n", + "| Processes: |\n", + "| GPU GI CI PID Type Process name GPU Memory |\n", + "| ID ID Usage |\n", + "|=========================================================================================|\n", + "| No running processes found |\n", + "+-----------------------------------------------------------------------------------------+\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Import torch\n", + "import torch\n", + "\n", + "# Exercises require PyTorch > 1.10.0\n", + "print(torch.__version__)\n", + "\n", + "# TODO: Setup device agnostic code\n", + "device =\"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "device\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 52 + }, + "id": "DNwZLMbCzJLk", + "outputId": "67260ac6-de01-4400-9a6e-3c752e1e325d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2.6.0+cu124\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 2 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1. What are 3 areas in industry where computer vision is currently being used?" + ], + "metadata": { + "id": "FSFX7tc1w-en" + } + }, + { + "cell_type": "markdown", + "source": [ + "\t1.\tHealthcare: Used in medical imaging (e.g., MRI, X-rays) to assist in diagnosis.\n", + "\t2.\tAutonomous Vehicles: Helps self-driving cars detect objects, lanes, and obstacles.\n", + "\t3.\tRetail: Facial recognition and automated checkout systems improve customer experience.\n" + ], + "metadata": { + "id": "ZOnG1GHLZKMc" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Search \"what is overfitting in machine learning\" and write down a sentence about what you find." + ], + "metadata": { + "id": "oBK-WI6YxDYa" + } + }, + { + "cell_type": "markdown", + "source": [ + "Overfitting occurs when a model learns patterns specific to the training data, including noise, making it perform well on training data but poorly on unseen test data.\n" + ], + "metadata": { + "id": "xOtfv8elZwOI" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Search \"ways to prevent overfitting in machine learning\", write down 3 of the things you find and a sentence about each.\n", + "> **Note:** there are lots of these, so don't worry too much about all of them, just pick 3 and start with those." + ], + "metadata": { + "id": "XeYFEqw8xK26" + } + }, + { + "cell_type": "markdown", + "source": [ + "1. Data Augmentation: Modifies training images (rotation, flipping) to improve generalization.\n", + "2. Regularization (L1/L2): Adds a penalty to large weights, making the model simpler.\n", + "3. Randomly turns off neurons during training to prevent dependency on specific features.\n" + ], + "metadata": { + "id": "LswlbpepaAIG" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Spend 20-minutes reading and clicking through the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/).\n", + "\n", + "* Upload your own example image using the \"upload\" button on the website and see what happens in each layer of a CNN as your image passes through it." + ], + "metadata": { + "id": "DKdEEFEqxM-8" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Load the [`torchvision.datasets.MNIST()`](https://pytorch.org/vision/stable/generated/torchvision.datasets.MNIST.html#torchvision.datasets.MNIST) train and test datasets." + ], + "metadata": { + "id": "lvf-3pODxXYI" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torchvision\n", + "from torchvision import datasets, transforms\n", + "\n", + "# Define transform\n", + "transform = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.1307,), (0.3081,))\n", + "])\n", + "\n", + "# Load train and test datasets\n", + "train_data = datasets.MNIST(root=\"./data\", train=True, download=True, transform=transform)\n", + "test_data = datasets.MNIST(root=\"./data\", train=False, download=True, transform=transform)\n", + "\n", + "\n" + ], + "metadata": { + "id": "SHjeuN81bHza" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "train_data, test_data" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "R_uWK0KpFFep", + "outputId": "c95ddb37-938f-40a6-aa15-7df93bbe507b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(Dataset MNIST\n", + " Number of datapoints: 60000\n", + " Root location: ./data\n", + " Split: Train\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ),\n", + " Dataset MNIST\n", + " Number of datapoints: 10000\n", + " Root location: ./data\n", + " Split: Test\n", + " StandardTransform\n", + " Transform: Compose(\n", + " ToTensor()\n", + " Normalize(mean=(0.1307,), std=(0.3081,))\n", + " ))" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_data), len(test_data)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ePSUg0oGEoHF", + "outputId": "94822cc0-d4b5-40cc-c8f1-ccafe5d23683" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(60000, 10000)" + ] + }, + "metadata": {}, + "execution_count": 22 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Get the class names from the dataset\n", + "class_names = train_data.classes\n", + "class_names\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TN6d1nUxD_64", + "outputId": "ab8316b4-6e6a-4d61-c608-490a83a9e68e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['0 - zero',\n", + " '1 - one',\n", + " '2 - two',\n", + " '3 - three',\n", + " '4 - four',\n", + " '5 - five',\n", + " '6 - six',\n", + " '7 - seven',\n", + " '8 - eight',\n", + " '9 - nine']" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Visualize at least 5 different samples of the MNIST training dataset." + ], + "metadata": { + "id": "qxZW-uAbxe_F" + } + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Function to visualize images\n", + "def show_images(dataset, num_images=5):\n", + " fig, axes = plt.subplots(1, num_images, figsize=(10, 2))\n", + " for i in range(num_images):\n", + " img, label = dataset[i]\n", + " axes[i].imshow(img.squeeze(), cmap=\"gray\")\n", + " axes[i].set_title(f\"Label: {label}\")\n", + " axes[i].axis(\"off\")\n", + "\n", + "show_images(train_data)\n" + ], + "metadata": { + "id": "QVFsYi1PbItE", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "outputId": "ac991564-8773-4a32-b49f-273fd1284fea" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 7. Turn the MNIST train and test datasets into dataloaders using `torch.utils.data.DataLoader`, set the `batch_size=32`." + ], + "metadata": { + "id": "JAPDzW0wxhi3" + } + }, + { + "cell_type": "code", + "source": [ + "from torch.utils.data import DataLoader\n", + "\n", + "# Define batch size\n", + "batch_size = 32\n", + "\n", + "# Create DataLoaders\n", + "train_dataloader = DataLoader(train_data, batch_size=batch_size, shuffle=True)\n", + "test_dataloader = DataLoader(test_data, batch_size=batch_size, shuffle=False)\n", + "\n", + "# Print batch details\n", + "for images, labels in train_dataloader:\n", + " print(f\"Batch size: {images.shape}, Labels: {labels.shape}\")\n", + " break # Print one batch\n" + ], + "metadata": { + "id": "ALA6MPcFbJXQ", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "95559a37-fe65-4188-a636-bcca4287d28e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Batch size: torch.Size([32, 1, 28, 28]), Labels: torch.Size([32])\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "train_dataloader, test_dataloader" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XHFFOphgfGZW", + "outputId": "a0dfbce4-ce4c-49c0-fe69-96cf6a4d4b36" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(,\n", + " )" + ] + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "source": [ + "len(train_dataloader), len(test_dataloader)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "j8dnGKN9fqls", + "outputId": "82b4c2d4-f837-4295-8dcd-f4f796e807ef" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 8. Recreate `model_2` used in notebook 03 (the same model from the [CNN Explainer website](https://poloclub.github.io/cnn-explainer/), also known as TinyVGG) capable of fitting on the MNIST dataset." + ], + "metadata": { + "id": "bCCVfXk5xjYS" + } + }, + { + "cell_type": "code", + "source": [ + "from torch import nn\n", + "class MNIST_model(torch.nn.Module):\n", + " \"\"\"Model capable of predicting on MNIST dataset.\n", + " \"\"\"\n", + " def __init__(self, input_shape: int, hidden_units: int, output_shape: int):\n", + " super().__init__()\n", + " self.conv_block_1 = nn.Sequential(\n", + " nn.Conv2d(in_channels=input_shape,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.conv_block_2 = nn.Sequential(\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.Conv2d(in_channels=hidden_units,\n", + " out_channels=hidden_units,\n", + " kernel_size=3,\n", + " stride=1,\n", + " padding=1),\n", + " nn.ReLU(),\n", + " nn.MaxPool2d(kernel_size=2)\n", + " )\n", + " self.classifier = nn.Sequential(\n", + " nn.Flatten(),\n", + " nn.Linear(in_features=hidden_units*7*7,\n", + " out_features=output_shape)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x = self.conv_block_1(x)\n", + " # print(f\"Output shape of conv block 1: {x.shape}\")\n", + " x = self.conv_block_2(x)\n", + " # print(f\"Output shape of conv block 2: {x.shape}\")\n", + " x = self.classifier(x)\n", + " # print(f\"Output shape of classifier: {x.shape}\")\n", + " return x" + ], + "metadata": { + "id": "5IKNF22XbKYS" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "device" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "vEOGcDMleA2p", + "outputId": "0fccc8ce-fb26-47e0-e857-325a2a4ec817" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'cuda'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "zFhrF_r2eB8E" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "G2cEdnITd68u" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "uNDTL66DeDHD", + "outputId": "aa9720f2-ce7e-4758-a857-95c7ee868e6b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Try a dummy forward pass to see what shapes our data is\n", + "dummy_x = torch.rand(size=(1, 28, 28)).unsqueeze(dim=0).to(device)\n", + "# dummy_x.shape\n", + "model(dummy_x)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "K4q5XDGGeQQk", + "outputId": "fba05e28-fcae-445d-9744-b564058f7a58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tensor([[-0.0237, 0.0819, 0.0189, 0.0228, -0.0252, 0.0080, -0.0020, -0.0176,\n", + " 0.0736, 0.0680]], device='cuda:0', grad_fn=)" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "source": [ + "dummy_x_2 = torch.rand(size=([1, 10, 7, 7]))\n", + "dummy_x_2.shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Lt9JtODAeXNE", + "outputId": "bbea492f-6ad4-49b9-8638-ccfc885dc3fd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 10, 7, 7])" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "flatten_layer = nn.Flatten()\n", + "flatten_layer(dummy_x_2).shape" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A9OT0ZW-eZ13", + "outputId": "32667c27-984c-4ce9-f951-4df41f3729c2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "torch.Size([1, 490])" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 9. Train the model you built in exercise 8. for 5 epochs on CPU and GPU and see how long it takes on each." + ], + "metadata": { + "id": "sf_3zUr7xlhy" + } + }, + { + "cell_type": "code", + "source": [ + "%%time\n", + "from tqdm.auto import tqdm\n", + "\n", + "# Train on CPU\n", + "model_cpu = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(\"cpu\")\n", + "\n", + "# Create a loss function and optimizer\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_cpu.parameters(), lr=0.1)\n", + "\n", + "### Training loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss = 0\n", + " for batch, (X, y) in enumerate(train_dataloader):\n", + " model_cpu.train()\n", + "\n", + " # Put data on CPU\n", + " X, y = X.to(\"cpu\"), y.to(\"cpu\")\n", + "\n", + " # Forward pass\n", + " y_pred = model_cpu(X)\n", + "\n", + " # Loss calculation\n", + " loss = loss_fn(y_pred, y)\n", + " train_loss += loss\n", + " # Optimizer zero grad\n", + " optimizer.zero_grad()\n", + "\n", + " # Loss backward\n", + " loss.backward()\n", + "\n", + " # Step the optimizer\n", + " optimizer.step()\n", + "\n", + " # Adjust train loss for number of batches\n", + " train_loss /= len(train_dataloader)\n", + "\n", + " ### Testing loop\n", + " test_loss_total = 0\n", + "\n", + " # Put model in eval mode\n", + " model_cpu.eval()\n", + "\n", + " # Turn on inference mode\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(test_dataloader):\n", + " # Make sure test data on CPU\n", + " X_test, y_test = X_test.to(\"cpu\"), y_test.to(\"cpu\")\n", + " test_pred = model_cpu(X_test)\n", + " test_loss = loss_fn(test_pred, y_test)\n", + "\n", + " test_loss_total += test_loss\n", + "\n", + " test_loss_total /= len(test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Loss: {train_loss:.3f} | Test loss: {test_loss_total:.3f}\")" + ], + "metadata": { + "id": "jSo6vVWFbNLD", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 170, + "referenced_widgets": [ + "13e8e56312674d3386224a2f00fd866f", + "0294fb9eb6fe4aff8d147f1f7cc1d553", + "abfa0e7b82bf486e92f9d90960284d3e", + "47b74eed37a84415a3fc42d1f19c5c4e", + "d7499f26238d4ec8a0d4ae459db82a5a", + "9d3c8abcf41f4fee8069a63c0b7e603c", + "42ac5a11f588411dae6f326c558ff1fd", + "e879e28f80d74fb4a91ba371ef73e0bc", + "c7f9038bdc08459fa2638e92d9090832", + "59125daa8589482a84193b4f52778612", + "47b099254fd7441cbcc3ab185374b22d" + ] + }, + "outputId": "d75a4a87-a629-4fd4-a671-180d8e20e320" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ] + }, + "metadata": {}, + "execution_count": 41 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Logits -> Prediction probabilities -> Prediction labels\n", + "model_pred_logits = model_gpu(test_data[0][0].unsqueeze(dim=0).to(device)) # make sure image is right shape + on right device\n", + "model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + "model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "model_pred_label\n", + "num_to_plot = 5\n", + "for i in range(num_to_plot):\n", + " # Get image and labels from the test data\n", + " img = test_data[i][0]\n", + " label = test_data[i][1]\n", + "\n", + " # Make prediction on image\n", + " model_pred_logits = model_gpu(img.unsqueeze(dim=0).to(device))\n", + " model_pred_probs = torch.softmax(model_pred_logits, dim=1)\n", + " model_pred_label = torch.argmax(model_pred_probs, dim=1)\n", + "\n", + " # Plot the image and prediction\n", + " plt.figure()\n", + " plt.imshow(img.squeeze(), cmap=\"gray\")\n", + " plt.title(f\"Truth: {label} | Pred: {model_pred_label.cpu().item()}\")\n", + " plt.axis(False);" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "8qlR_6njh0Kp", + "outputId": "a4e56a0e-25e8-47b7-ea34-9e59abcc9441" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAGbCAYAAAAr/4yjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAEWRJREFUeJzt3X+M13UdwPHXKQd5ambXRZQIgWlwZEypxRlIqDXGjyYqkFjatGJS9oOijbEdtTnn1tKxQvshFZ5tcFE3mU3yByrg0aJNaOlJXqjLQUTkBZRYd9/+8rWuO+I+X77H8ePx2PzDz31en8/7PnPfp5/v98uHqlKpVAoAiIjTBnoBABw/RAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRIEBMXLkyJgxY8ZAL6OHkSNHxrJlywZ6GX1SVVV1wqyVE4conIKqqqr69M8TTzxxVOd59tlnY9myZfHiiy9WZN1H0tbWFosXL47x48fH2WefHcOGDYvp06fH1q1bK36uZcuWdbtWNTU1MXbs2Fi6dGn8/e9/r/j5Ku03v/lNfP7zn4/6+vo488wz4/zzz485c+bEjh07BnppDLBBA70Ajr3777+/27+vWrUqHnnkkR7bx4wZc1TnefbZZ+Mb3/hGTJkyJUaOHHlUx+qLH/7wh3HffffFNddcE7feemt0dHTE9773vfjQhz4UDz/8cFx55ZUVP+c999wTZ511Vhw4cCB+9atfxe233x6PP/54bN68Oaqqqip+vkq58847Y/PmzXHdddfFxRdfHLt3747vfOc7cckll8SWLVti3LhxA71EBkqJU97ChQtLfflP4eDBg4WO29zcXIqI0oYNG3r8bMSIEaXp06cXOt6RbN26tbR///5u2/bu3Vuqq6srXXbZZX06xogRI0qNjY1H3K+xsbEUEaW//OUv3bbPnj27FBGlp59++rCzRa/j4UREn9bam82bN5cOHTrUbduOHTtKQ4YMKc2fP78Cq+NE5e0jejVlypQYN25c/Pa3v43JkydHTU1NLFmyJCIO/172yJEj46abboqIiB//+Mdx3XXXRUTERz7ykcO+JbVp06b44Ac/GG9605ti1KhRsWrVqh7HbW9vj/b29iOu+dJLL42zzjqr27ba2tqYNGlSPPfcc334rY/e1KlTIyJi586dEfH/r+OhQ4eisbExLrjgghgyZEgMHz48Fi9eHIcOHep2zEOHDsWXv/zlqKuri7PPPjtmzZoVf/rTn3o9f1tbW7z88stHXGdDQ0MMHjy427b3vOc9UV9ff8yuFccnbx9xWH/9619j2rRpMW/evLjhhhti6NChfZ6dPHly3HbbbbF8+fJYsmRJvhX1329JvfDCC3HttdfGzTffHDfeeGOsXLkybrrpprj00kujvr4+97viiisiIsr+bGL37t3xtre9razZot6IV21tbW7r7Tp2dXXFrFmzYtOmTfHZz342xowZE7/73e/irrvuih07dkRLS0vO33LLLdHU1BTXX399NDQ0xOOPPx7Tp0/v9fxjxoyJyy+/vKzPg0qlUvz5z3/udu059YgCh7V79+64995743Of+1zh2VGjRsWkSZNi+fLlcdVVV8WUKVN67PP888/HU089FZMmTYqIiDlz5sTw4cPjRz/6UXzrW9862uVHRMTGjRujtbU1li5dWpHj/a99+/ZFRORnCitWrIihQ4fm7xTR+3VsamqKRx99NJ588sn48Ic/nNvHjRsXCxYsiKeffjoaGhpi27Zt0dTUFLfeemt897vfjYiIhQsXxvz582P79u0V/V0eeOCBeOWVV+Kb3/xmRY/LiUUUOKwhQ4bEpz/96X47/tixY7u9eNbV1cVFF10Uf/zjH7vtV+4dwp49e+L666+Pd7/73bF48eKjWephXXTRRd3+vb6+Pn7yk59ETU1NbuvtOjY3N8eYMWPive99b+zduze3v/H204YNG6KhoSF++ctfRkTEbbfd1m3+S1/6Uvz0pz/tsZ5SmX9nVltbWyxcuDAmTpwYN954Y1nH4OQgChzWu971rh7vO1fS+eef32PbueeeG3/729+O+tgHDx6MGTNmxP79+2PTpk09PmuolLVr18ab3/zmqK6ujvPOOy9Gjx7dY5/eruMf/vCHeO6556Kurq7X4+7ZsyciIl566aU47bTTehz3f2N0NHbv3h3Tp0+Pc845J372s5/F6aefXrFjc+IRBQ7rjDPOKLR/Z2dnof0P9+JT7v/tvuH111+P2bNnx/bt22P9+vX9+vXKyZMnH/Hzit6uY1dXV7zvfe+Lb3/7273ODB8+vCLrO5KOjo6YNm1avPrqq7Fx48Z45zvfeUzOy/FLFCjs3HPPjVdffbXbttdffz127drVbdtAfE+/q6srPvWpT8Vjjz0Wa9asicsvv/yYr6EvRo8eHdu2bYsrrrji/16nESNGRFdXV7S3t3e7O3j++eePeg2vvfZazJw5M3bs2BGPPvpojB079qiPyYnPV1IpbPTo0fHUU0912/b973+/x53CmWeeGRHRIyBF9fUrqRERX/jCF2L16tWxYsWKmD179lGdtz/NmTMnXnnllfjBD37Q42f//Oc/4+DBgxERMW3atIiIWL58ebd97r777l6P29evpHZ2dsbcuXOjtbU1mpubY+LEiQV/A05W7hQo7JZbbokFCxbENddcE1dddVVs27Yt1q9f3+NtlPHjx8fpp58ed955Z3R0dMSQIUNi6tSp8fa3v73Q+fr6ldS77747VqxYERMnToyamppoamrq9vOrr746QzXQPvnJT8aaNWtiwYIFsWHDhrjsssuis7Mz2traYs2aNbF+/fqYMGFCjB8/Pj7xiU/EihUroqOjIxoaGuKxxx6LF154odfj9vUrqYsWLYoHH3wwZs6cGfv27etxrW644YZK/aqcYESBwj7zmc/Ezp0747777ouHH344Jk2aFI888ki+eL/hHe94R9x7771xxx13xM033xydnZ2xYcOGwlHoq2eeeSYiIlpbW6O1tbXHz3fu3HncROG0006LlpaWuOuuu2LVqlXxi1/8ImpqamLUqFHxxS9+MS688MLcd+XKlVFXVxcPPPBAtLS0xNSpU+Ohhx46qs8d3rhW69ati3Xr1vX4uSicuqpKR/upHpxE3vhT2Z4+yqnKZwoAJFEAIIkCAMlnCgAkdwoAJFEAIPX5zykcz3+1IABH1pdPC9wpAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASKIAQBo00AvgxPTVr3618MwZZ5xR1rkuvvjiwjPXXnttWecq6p577ik809raWta57r///rLmoAh3CgAkUQAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASFWlUqnUpx2rqvp7LQyQ1atXF545Vg+cOxm1t7eXNXfllVcWnnn55ZfLOhcnp7683LtTACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAGjTQC6CyTsaH27W1tRWeWb9+feGZUaNGFZ6ZOXNm4ZnRo0cXnomImD9/fuGZO+64o6xzcepypwBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgOSBeMepCRMmlDV39dVXV3glvfv9739feGbWrFllnWvv3r2FZw4cOFB4ZvDgwYVntmzZUnjm/e9/f+GZiIja2tqy5qAIdwoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEgeiHecGjZsWFlzVVVVhWfKebjdxz72scIzu3btKjxzLC1atKjwzNixY/thJb176KGHjtm5OHW5UwAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJKnpB6n1q1bV9bcBRdcUHhm//79hWf27dtXeOZ4N2/evMIz1dXV/bASGDjuFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkDwQ7yTz0ksvDfQSjgtf+9rXCs9ceOGF/bCSnn79618f0zkowp0CAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQBSValUKvVpx6qq/l4L9GrGjBmFZ5qbmwvPDB48uPDMnj17Cs/Mmzev8ExExJNPPlnWHLyhLy/37hQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJIoAJAGDfQC4EgmTJhQeKach9uVY/Xq1YVnPNiO45k7BQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIHlKKsdMS0tLWXMf/ehHK7uQw1i1alXhmaVLl/bDSmDguFMAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAECqKpVKpT7tWFXV32vhBDJs2LDCM9u2bSvrXLW1tYVn9u7dW3imoaGh8Ex7e3vhGRgofXm5d6cAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJIoAJBEAYA0aKAXwIlp7dq1hWfKebBduZqamgrPeLgduFMA4L+IAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBA8kA8YtasWYVnLrnkkn5YSe+eeOKJwjONjY2VXwicAtwpAJBEAYAkCgAkUQAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgeSDeSaa2trbwzJIlSwrPVFdXF54p1zPPPFN45sCBA5VfCJwC3CkAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgDJU1JPMosWLSo884EPfKAfVtJTS0tLWXONjY2VXQhwWO4UAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQqkqlUqlPO1ZV9fdaqIDXXnut8Ex1dXU/rKSn8847r6y5Xbt2VXglcGrqy8u9OwUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKAKRBA70ATh1vfetby5r717/+VeGVDKyOjo6y5sq5DuU87PCcc84pPFOOt7zlLWXNfeUrX6nsQiqos7OzrLmvf/3rhWf+8Y9/lHWuI3GnAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGA5IF4HDPbt28f6CUcF5qbm8ua27VrV+GZoUOHFp6ZO3du4RmOzu7duwvP3H777f2wEncKAPwXUQAgiQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIASRQASFWlUqnUpx2rqvp7LVTAz3/+88IzH//4x/thJZxK/v3vfxee6erq6oeV9O7BBx8sPLN169Z+WEnvNm7cWHhmy5YthWf68nLvTgGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJFEAIIkCAEkUAEiekkosXry48Ex1dXU/rKRy6uvrC8/MnTu3H1ZSOStXriw88+KLL1Z+Ib1Yu3Zt4Zm2trZ+WAn/j6ekAlCIKACQRAGAJAoAJFEAIIkCAEkUAEiiAEASBQCSKACQRAGAJAoAJA/EAzhFeCAeAIWIAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACCJAgBJFABIogBAEgUAkigAkEQBgCQKACRRACAN6uuOpVKpP9cBwHHAnQIASRQASKIAQBIFAJIoAJBEAYAkCgAkUQAgiQIA6T+qfVziwpPzEQAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 11. Plot a confusion matrix comparing your model's predictions to the truth labels." + ], + "metadata": { + "id": "qQwzqlBWxrpG" + } + }, + { + "cell_type": "code", + "source": [ + "# See if torchmetrics exists, if not, install it\n", + "try:\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " assert int(mlxtend.__version__.split(\".\")[1]) >= 19, \"mlxtend verison should be 0.19.0 or higher\"\n", + "except:\n", + " !pip install -q torchmetrics -U mlxtend # <- Note: If you're using Google Colab, this may require restarting the runtime\n", + " import torchmetrics, mlxtend\n", + " print(f\"mlxtend version: {mlxtend.__version__}\")\n", + " # Import mlxtend upgraded version\n", + "import mlxtend\n", + "print(mlxtend.__version__)\n", + "assert int(mlxtend.__version__.split(\".\")[1]) >= 19" + ], + "metadata": { + "id": "vSrXiT_AbQ6e", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "40248d65-99ff-43d7-af57-cabb3e8933bf" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m927.3/927.3 kB\u001b[0m \u001b[31m49.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m109.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m84.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m51.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m12.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m9.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m6.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m86.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hmlxtend version: 0.23.4\n", + "0.23.4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Make predictions across all test data\n", + "from tqdm.auto import tqdm\n", + "model_gpu.eval()\n", + "y_preds = []\n", + "with torch.inference_mode():\n", + " for batch, (X, y) in tqdm(enumerate(test_dataloader)):\n", + " # Make sure data on right device\n", + " X, y = X.to(device), y.to(device)\n", + " # Forward pass\n", + " y_pred_logits = model_gpu(X)\n", + " # Logits -> Pred probs -> Pred label\n", + " y_pred_labels = torch.argmax(torch.softmax(y_pred_logits, dim=1), dim=1)\n", + " # Append the labels to the preds list\n", + " y_preds.append(y_pred_labels)\n", + " y_preds=torch.cat(y_preds).cpu()\n", + "len(y_preds)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 66, + "referenced_widgets": [ + "a2963dd0080b449d8f7f90573c4da188", + "9db0a911e60c4271b78101ea50573155", + "cbdaec3285264cd2a71bab7d8a8216f9", + "0d573b771475435fa51639e5bfb8cb28", + "c08d9d15e6eb4e818aa97aa31c66ec95", + "08da86e0e8404cd1b02654bd24c62732", + "45397b429d5d47feab451defd8614c0d", + "3beb124807bb4957940a8e9638f0fa5c", + "c49009c851e94e55b2c1f3c4c901e205", + "8ae0360136974b5ba1b7b607de3686c1", + "2e9c4f7159c545efb4f667c1be12a5b0" + ] + }, + "id": "YmzNi-X_iaN7", + "outputId": "73f9d0e9-0adb-40dd-a91a-2aded6723ef1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "0it [00:00, ?it/s]" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "a2963dd0080b449d8f7f90573c4da188" + } + }, + "metadata": {} + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "10000" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "source": [ + "test_data.targets[:10], y_preds[:10]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qQC7oh1tig9S", + "outputId": "a80a26d7-182a-4fc3-a1ea-f9edb46e8337" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]),\n", + " tensor([7, 2, 1, 0, 4, 1, 4, 9, 5, 9]))" + ] + }, + "metadata": {}, + "execution_count": 46 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from torchmetrics import ConfusionMatrix\n", + "from mlxtend.plotting import plot_confusion_matrix\n", + "\n", + "# Setup confusion matrix\n", + "confmat = ConfusionMatrix(task=\"multiclass\", num_classes=len(class_names))\n", + "confmat_tensor = confmat(preds=y_preds,\n", + " target=test_data.targets)\n", + "\n", + "# Plot the confusion matrix\n", + "fix, ax = plot_confusion_matrix(\n", + " conf_mat=confmat_tensor.numpy(),\n", + " class_names=class_names,\n", + " figsize=(10, 7)\n", + ")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 638 + }, + "id": "czblDny_in5U", + "outputId": "11864434-840c-4d49-d8c9-4c974f04fb55" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 12. Create a random tensor of shape `[1, 3, 64, 64]` and pass it through a `nn.Conv2d()` layer with various hyperparameter settings (these can be any settings you choose), what do you notice if the `kernel_size` parameter goes up and down?" + ], + "metadata": { + "id": "lj6bDhoWxt2y" + } + }, + { + "cell_type": "code", + "source": [ + "random_tensor = torch.rand([1, 3, 64, 64])\n", + "random_tensor.shape\n", + "conv_layer = nn.Conv2d(in_channels=3,\n", + " out_channels=64,\n", + " kernel_size=3,\n", + " stride=2,\n", + " padding=1)\n", + "\n", + "print(f\"Random tensor original shape: {random_tensor.shape}\")\n", + "random_tensor_through_conv_layer = conv_layer(random_tensor)\n", + "print(f\"Random tensor through conv layer shape: {random_tensor_through_conv_layer.shape}\")\n" + ], + "metadata": { + "id": "leCTsqtSbR5P", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "18c91e86-d1d6-4db9-9f04-9b3c8146dd02" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Random tensor original shape: torch.Size([1, 3, 64, 64])\n", + "Random tensor through conv layer shape: torch.Size([1, 64, 32, 32])\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 13. Use a model similar to the trained `model_2` from notebook 03 to make predictions on the test [`torchvision.datasets.FashionMNIST`](https://pytorch.org/vision/main/generated/torchvision.datasets.FashionMNIST.html) dataset.\n", + "* Then plot some predictions where the model was wrong alongside what the label of the image should've been.\n", + "* After visualing these predictions do you think it's more of a modelling error or a data error?\n", + "* As in, could the model do better or are the labels of the data too close to each other (e.g. a \"Shirt\" label is too close to \"T-shirt/top\")?" + ], + "metadata": { + "id": "VHS20cNTxwSi" + } + }, + { + "cell_type": "code", + "source": [ + "# Download FashionMNIST train & test\n", + "from torchvision import datasets\n", + "from torchvision import transforms\n", + "\n", + "fashion_mnist_train = datasets.FashionMNIST(root=\".\",\n", + " download=True,\n", + " train=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "fashion_mnist_test = datasets.FashionMNIST(root=\".\",\n", + " train=False,\n", + " download=True,\n", + " transform=transforms.ToTensor())\n", + "\n", + "len(fashion_mnist_train), len(fashion_mnist_test)\n", + "# Get the class names of the Fashion MNIST dataset\n", + "fashion_mnist_class_names = fashion_mnist_train.classes\n", + "fashion_mnist_class_names" + ], + "metadata": { + "id": "78a8LjtdbSZj", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "3dae493e-8c24-4559-8ed8-ec6de4145e58" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to ./FashionMNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 26.4M/26.4M [00:02<00:00, 9.29MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 29.5k/29.5k [00:00<00:00, 150kB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/train-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 4.42M/4.42M [00:01<00:00, 2.79MB/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-images-idx3-ubyte.gz to ./FashionMNIST/raw\n", + "\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n", + "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 5.15k/5.15k [00:00<00:00, 11.5MB/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to ./FashionMNIST/raw\n", + "\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['T-shirt/top',\n", + " 'Trouser',\n", + " 'Pullover',\n", + " 'Dress',\n", + " 'Coat',\n", + " 'Sandal',\n", + " 'Shirt',\n", + " 'Sneaker',\n", + " 'Bag',\n", + " 'Ankle boot']" + ] + }, + "metadata": {}, + "execution_count": 49 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Turn FashionMNIST datasets into dataloaders\n", + "from torch.utils.data import DataLoader\n", + "\n", + "fashion_mnist_train_dataloader = DataLoader(fashion_mnist_train,\n", + " batch_size=32,\n", + " shuffle=True)\n", + "\n", + "fashion_mnist_test_dataloader = DataLoader(fashion_mnist_test,\n", + " batch_size=32,\n", + " shuffle=False)\n", + "\n", + "len(fashion_mnist_train_dataloader), len(fashion_mnist_test_dataloader)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CLoagbwVKEAL", + "outputId": "c52b3925-b510-47f4-f339-e659dd02e465" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1875, 313)" + ] + }, + "metadata": {}, + "execution_count": 50 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# model_2 is the same architecture as MNIST_model\n", + "model_2 = MNIST_model(input_shape=1,\n", + " hidden_units=10,\n", + " output_shape=10).to(device)\n", + "model_2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "jDkmCa2tKLZy", + "outputId": "fdaaa05e-de01-44bb-ffa0-b59d1a2ca089" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "MNIST_model(\n", + " (conv_block_1): Sequential(\n", + " (0): Conv2d(1, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (conv_block_2): Sequential(\n", + " (0): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU()\n", + " (2): Conv2d(10, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (3): ReLU()\n", + " (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (classifier): Sequential(\n", + " (0): Flatten(start_dim=1, end_dim=-1)\n", + " (1): Linear(in_features=490, out_features=10, bias=True)\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 51 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Setup loss and optimizer\n", + "from torch import nn\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model_2.parameters(), lr=0.01)" + ], + "metadata": { + "id": "3k_32qrnKQnY" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Setup metrics\n", + "from tqdm.auto import tqdm\n", + "from torchmetrics import Accuracy\n", + "\n", + "acc_fn = Accuracy(task = 'multiclass', num_classes=len(fashion_mnist_class_names)).to(device)\n", + "\n", + "# Setup training/testing loop\n", + "epochs = 5\n", + "for epoch in tqdm(range(epochs)):\n", + " train_loss, test_loss_total = 0, 0\n", + " train_acc, test_acc = 0, 0\n", + "\n", + " ### Training\n", + " model_2.train()\n", + " for batch, (X_train, y_train) in enumerate(fashion_mnist_train_dataloader):\n", + " X_train, y_train = X_train.to(device), y_train.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred = model_2(X_train)\n", + " loss = loss_fn(y_pred, y_train)\n", + " train_loss += loss\n", + " train_acc += acc_fn(y_pred, y_train)\n", + "\n", + " # Backprop and gradient descent\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " train_loss /= len(fashion_mnist_train_dataloader)\n", + " train_acc /= len(fashion_mnist_train_dataloader)\n", + "\n", + " ### Testing\n", + " model_2.eval()\n", + " with torch.inference_mode():\n", + " for batch, (X_test, y_test) in enumerate(fashion_mnist_test_dataloader):\n", + " X_test, y_test = X_test.to(device), y_test.to(device)\n", + "\n", + " # Forward pass and loss\n", + " y_pred_test = model_2(X_test)\n", + " test_loss = loss_fn(y_pred_test, y_test)\n", + " test_loss_total += test_loss\n", + "\n", + " test_acc += acc_fn(y_pred_test, y_test)\n", + "\n", + " # Adjust the loss/acc (find the loss/acc per epoch)\n", + " test_loss /= len(fashion_mnist_test_dataloader)\n", + " test_acc /= len(fashion_mnist_test_dataloader)\n", + "\n", + " # Print out what's happening\n", + " print(f\"Epoch: {epoch} | Train loss: {train_loss:.3f} | Train acc: {train_acc:.2f} | Test loss: {test_loss_total:.3f} | Test acc: {test_acc:.2f}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 156, + "referenced_widgets": [ + "d97f28b38c98433896ac99037182b3cd", + "5171e7d0c89349d1942872a271d098d5", + "73a16e5349d341b5af0b013731ced828", + "7e44d7a46ba4402cb164b2433ffdd3bf", + "1b5f5ad03c8b4abbbcd9e9ff4c28b149", + "062c9c612da0434ba794c973c5857510", + "04ac343c4b8e419fab2787d7972b4da1", + "458a4274c8b74a289184eedd1180e26c", + "2b92883149594d35a1b72a9bbdd3e41a", + "9f9fb380066f4175aceea26385626884", + "1940c92f2cd1436cb186071674146a15" + ] + }, + "id": "71Lk8G9-KXh2", + "outputId": "a0d0ca1f-3dfa-4f1f-ad51-a163a34cda43" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + " 0%| | 0/5 [00:00" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file