From de137c3d8352807cdd9a556db62b3aebc8cd0f38 Mon Sep 17 00:00:00 2001
From: Denis Thomas <thomas.denis@etu.ec-lyon.fr>
Date: Wed, 4 Dec 2024 18:03:24 +0000
Subject: [PATCH] Upload New File

---
 TD2_Deep_Learning.ipynb | 2731 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 2731 insertions(+)
 create mode 100644 TD2_Deep_Learning.ipynb

diff --git a/TD2_Deep_Learning.ipynb b/TD2_Deep_Learning.ipynb
new file mode 100644
index 0000000..e2ce67b
--- /dev/null
+++ b/TD2_Deep_Learning.ipynb
@@ -0,0 +1,2731 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7edf7168",
+   "metadata": {
+    "id": "7edf7168"
+   },
+   "source": [
+    "# TD2: Deep learning"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbb8c8df",
+   "metadata": {
+    "id": "fbb8c8df"
+   },
+   "source": [
+    "In this TD, you must modify this notebook to answer the questions. To do this,\n",
+    "\n",
+    "1. Fork this repository\n",
+    "2. Clone your forked repository on your local computer\n",
+    "3. Answer the questions\n",
+    "4. Commit and push regularly\n",
+    "\n",
+    "The last commit is due on Wednesday, December 4, 11:59 PM. Later commits will not be taken into account."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d167a29",
+   "metadata": {
+    "id": "3d167a29"
+   },
+   "source": [
+    "Install and test PyTorch from  https://pytorch.org/get-started/locally."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "330a42f5",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "330a42f5",
+    "outputId": "1b461c4d-5146-4dc0-f86b-af990ebebc34"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.5.1+cu121)\n",
+      "Requirement already satisfied: torchvision in /usr/local/lib/python3.10/dist-packages (0.20.1+cu121)\n",
+      "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.16.1)\n",
+      "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch) (4.12.2)\n",
+      "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.4.2)\n",
+      "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n",
+      "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2024.10.0)\n",
+      "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch) (1.13.1)\n",
+      "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n",
+      "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from torchvision) (1.26.4)\n",
+      "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.10/dist-packages (from torchvision) (11.0.0)\n",
+      "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (3.0.2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install torch torchvision"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0882a636",
+   "metadata": {
+    "id": "0882a636"
+   },
+   "source": [
+    "\n",
+    "To test run the following code"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "b1950f0a",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "collapsed": true,
+    "id": "b1950f0a",
+    "outputId": "7928313b-35f0-448c-de63-d886e523fc72"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor([[-0.2838,  1.1002, -0.2854, -0.3491,  0.1990, -1.3343, -0.5687, -0.7595,\n",
+      "         -0.0926, -2.4920],\n",
+      "        [-1.1461, -1.2718,  0.5804,  1.5253,  0.4094,  0.1221,  0.9656, -0.7938,\n",
+      "         -1.1333,  2.4852],\n",
+      "        [-0.2726,  1.7889,  0.6313,  0.4595, -0.8495,  0.3804, -0.4525,  0.8911,\n",
+      "          1.9623, -1.5363],\n",
+      "        [-0.5621,  1.5283, -0.2384,  0.9895,  0.4308, -1.1083, -2.2885, -2.3651,\n",
+      "         -0.5921,  1.7363],\n",
+      "        [ 0.3859,  0.9262, -1.6880,  1.3435, -0.1577,  0.1539,  0.7345, -0.4864,\n",
+      "         -1.8207, -0.5257],\n",
+      "        [-1.3270, -1.0961, -0.0713, -1.7331,  0.2279, -0.1261, -0.7092,  0.8750,\n",
+      "          0.1082, -1.7152],\n",
+      "        [-1.9420, -0.0669, -0.6286,  0.3125, -0.5001, -1.1138, -0.0692, -0.9393,\n",
+      "         -0.9670, -0.6182],\n",
+      "        [-0.7197,  0.1052,  2.5205,  0.7508,  0.1782, -0.9654, -2.4957, -1.3703,\n",
+      "         -0.6951, -1.7983],\n",
+      "        [ 0.1393,  1.2484, -0.5033,  1.2783,  0.7590,  0.9832, -1.4695,  0.9761,\n",
+      "          0.8216, -2.0430],\n",
+      "        [ 1.9597,  1.1379, -1.0448, -0.3021,  0.9703,  1.5877,  1.4919, -0.3954,\n",
+      "          1.8203,  0.2380],\n",
+      "        [-0.6342,  0.3309, -0.0303, -0.4851,  1.1376,  1.2448, -1.2360, -1.2666,\n",
+      "          1.6848,  0.3165],\n",
+      "        [ 0.1279,  0.0323, -1.0584,  0.3167,  0.8141, -1.1893, -0.5875, -0.9052,\n",
+      "         -0.6756,  0.3488],\n",
+      "        [-0.7408,  1.3921,  0.3673, -0.6543, -1.0036, -1.4894,  0.7741, -2.0253,\n",
+      "         -0.4621,  1.0710],\n",
+      "        [ 0.5183,  1.3840,  0.6692, -1.7814, -0.4336,  0.0963, -2.0286,  0.1410,\n",
+      "          1.0903,  0.1991]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "N, D = 14, 10\n",
+    "x = torch.randn(N, D).type(torch.FloatTensor)\n",
+    "print(x)\n",
+    "\n",
+    "from torchvision import models\n",
+    "\n",
+    "alexnet = models.alexnet()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23f266da",
+   "metadata": {
+    "id": "23f266da"
+   },
+   "source": [
+    "## Exercise 1: CNN on CIFAR10\n",
+    "\n",
+    "The goal is to apply a Convolutional Neural Net (CNN) model on the CIFAR10 image dataset and test the accuracy of the model on the basis of image classification. Compare the Accuracy VS the neural network implemented during TD1.\n",
+    "\n",
+    "Have a look at the following documentation to be familiar with PyTorch.\n",
+    "\n",
+    "https://pytorch.org/tutorials/beginner/pytorch_with_examples.html\n",
+    "\n",
+    "https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ba1c82d",
+   "metadata": {
+    "id": "4ba1c82d"
+   },
+   "source": [
+    "You can test if GPU is available on your machine and thus train on it to speed up the process"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "6e18f2fd",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "6e18f2fd",
+    "outputId": "7178af4f-2ac6-4684-a551-f537dcadb3a5"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CUDA is not available.  Training on CPU ...\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "\n",
+    "# check if CUDA is available\n",
+    "train_on_gpu = torch.cuda.is_available()\n",
+    "\n",
+    "if not train_on_gpu:\n",
+    "    print(\"CUDA is not available.  Training on CPU ...\")\n",
+    "else:\n",
+    "    print(\"CUDA is available!  Training on GPU ...\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5cf214eb",
+   "metadata": {
+    "id": "5cf214eb"
+   },
+   "source": [
+    "Next we load the CIFAR10 dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "462666a2",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "462666a2",
+    "outputId": "8f5a8193-bed9-4b76-9820-cd0217d10f27"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Files already downloaded and verified\n",
+      "Files already downloaded and verified\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data.sampler import SubsetRandomSampler\n",
+    "\n",
+    "\n",
+    "# number of subprocesses to use for data loading\n",
+    "num_workers = 0\n",
+    "# how many samples per batch to load\n",
+    "batch_size = 20\n",
+    "# percentage of training set to use as validation\n",
+    "valid_size = 0.2\n",
+    "\n",
+    "# convert data to a normalized torch.FloatTensor\n",
+    "transform = transforms.Compose(\n",
+    "    [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]\n",
+    ")\n",
+    "\n",
+    "# choose the training and test datasets\n",
+    "train_data = datasets.CIFAR10(\"data\", train=True, download=True, transform=transform)\n",
+    "test_data = datasets.CIFAR10(\"data\", train=False, download=True, transform=transform)\n",
+    "\n",
+    "# obtain training indices that will be used for validation\n",
+    "num_train = len(train_data)\n",
+    "indices = list(range(num_train))\n",
+    "np.random.shuffle(indices)\n",
+    "split = int(np.floor(valid_size * num_train))\n",
+    "train_idx, valid_idx = indices[split:], indices[:split]\n",
+    "\n",
+    "# define samplers for obtaining training and validation batches\n",
+    "train_sampler = SubsetRandomSampler(train_idx)\n",
+    "valid_sampler = SubsetRandomSampler(valid_idx)\n",
+    "\n",
+    "# prepare data loaders (combine dataset and sampler)\n",
+    "train_loader = torch.utils.data.DataLoader(\n",
+    "    train_data, batch_size=batch_size, sampler=train_sampler, num_workers=num_workers\n",
+    ")\n",
+    "valid_loader = torch.utils.data.DataLoader(\n",
+    "    train_data, batch_size=batch_size, sampler=valid_sampler, num_workers=num_workers\n",
+    ")\n",
+    "test_loader = torch.utils.data.DataLoader(\n",
+    "    test_data, batch_size=batch_size, num_workers=num_workers\n",
+    ")\n",
+    "\n",
+    "# specify the image classes\n",
+    "classes = [\n",
+    "    \"airplane\",\n",
+    "    \"automobile\",\n",
+    "    \"bird\",\n",
+    "    \"cat\",\n",
+    "    \"deer\",\n",
+    "    \"dog\",\n",
+    "    \"frog\",\n",
+    "    \"horse\",\n",
+    "    \"ship\",\n",
+    "    \"truck\",\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "58ec3903",
+   "metadata": {
+    "id": "58ec3903"
+   },
+   "source": [
+    "CNN definition (this one is an example)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "317bf070",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "317bf070",
+    "outputId": "74ed377f-0efd-4277-c78b-bf3973a69da9"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Net(\n",
+      "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
+      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
+      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
+      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
+      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "# define the CNN architecture\n",
+    "\n",
+    "\n",
+    "class Net(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Net, self).__init__()\n",
+    "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
+    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
+    "        self.fc2 = nn.Linear(120, 84)\n",
+    "        self.fc3 = nn.Linear(84, 10)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.pool(F.relu(self.conv1(x)))\n",
+    "        x = self.pool(F.relu(self.conv2(x)))\n",
+    "        x = x.view(-1, 16 * 5 * 5)\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.fc3(x)\n",
+    "        return x\n",
+    "\n",
+    "\n",
+    "# create a complete CNN\n",
+    "model_1 = Net()\n",
+    "print(model_1)\n",
+    "# move tensors to GPU if CUDA is available\n",
+    "if train_on_gpu:\n",
+    "    model_1.cuda()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2dc4974",
+   "metadata": {
+    "id": "a2dc4974"
+   },
+   "source": [
+    "Loss function and training using SGD (Stochastic Gradient Descent) optimizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fcYbuCt5Ejh1",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "fcYbuCt5Ejh1",
+    "outputId": "b78f3724-53fb-4d9f-a149-73b540afb761"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 43.519861 \tValidation Loss: 38.486876 \tdecrease_strike: 0\n",
+      "Validation loss decreased (inf --> 38.486876).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 34.675180 \tValidation Loss: 31.490289 \tdecrease_strike: 0\n",
+      "Validation loss decreased (38.486876 --> 31.490289).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 30.521290 \tValidation Loss: 28.425634 \tdecrease_strike: 0\n",
+      "Validation loss decreased (31.490289 --> 28.425634).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 28.317458 \tValidation Loss: 27.084840 \tdecrease_strike: 0\n",
+      "Validation loss decreased (28.425634 --> 27.084840).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 26.667578 \tValidation Loss: 25.805486 \tdecrease_strike: 0\n",
+      "Validation loss decreased (27.084840 --> 25.805486).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 25.254479 \tValidation Loss: 25.475996 \tdecrease_strike: 0\n",
+      "Validation loss decreased (25.805486 --> 25.475996).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 24.076636 \tValidation Loss: 24.895369 \tdecrease_strike: 0\n",
+      "Validation loss decreased (25.475996 --> 24.895369).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 23.055378 \tValidation Loss: 23.246398 \tdecrease_strike: 0\n",
+      "Validation loss decreased (24.895369 --> 23.246398).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 22.239478 \tValidation Loss: 23.512736 \tdecrease_strike: 0\n",
+      "Epoch: 9 \tTraining Loss: 21.384813 \tValidation Loss: 23.095901 \tdecrease_strike: 1\n",
+      "Validation loss decreased (23.246398 --> 23.095901).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 20.676189 \tValidation Loss: 22.104892 \tdecrease_strike: 0\n",
+      "Validation loss decreased (23.095901 --> 22.104892).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 19.967947 \tValidation Loss: 22.255865 \tdecrease_strike: 0\n",
+      "Epoch: 12 \tTraining Loss: 19.319032 \tValidation Loss: 22.597742 \tdecrease_strike: 1\n",
+      "Epoch: 13 \tTraining Loss: 18.707190 \tValidation Loss: 23.039709 \tdecrease_strike: 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.optim as optim\n",
+    "\n",
+    "# We define a training function tu reduce the amount of code , we will use it to train evry model for exercice 1 and 2\n",
+    "def training(model,model_name,criterion,optimizer):\n",
+    "    criterion = nn.CrossEntropyLoss()  # specify loss function\n",
+    "    optimizer = optim.SGD(model.parameters(), lr=0.01)  # specify optimizer\n",
+    "\n",
+    "    n_epochs = 30  # number of epochs to train the model ( we set 30 because we are sure to not pass it)\n",
+    "\n",
+    "    train_loss_list = []  # list to store loss to visualize\n",
+    "    valid_loss_list = []  # list to store loss to visualize\n",
+    "\n",
+    "    valid_loss_min = np.Inf  # track change in validation loss\n",
+    "    valid_loss_last = np.Inf  # track change in validation loss\n",
+    "\n",
+    "    #We had an early stopage, it's a\n",
+    "    decrease_strike = 0\n",
+    "\n",
+    "    for epoch in range(n_epochs):\n",
+    "        # Keep track of training and validation loss\n",
+    "        train_loss = 0.0\n",
+    "        valid_loss = 0.0\n",
+    "\n",
+    "        # Train the model\n",
+    "        model.train()\n",
+    "        for data, target in train_loader:\n",
+    "            # Move tensors to GPU if CUDA is available\n",
+    "            if train_on_gpu:\n",
+    "                data, target = data.cuda(), target.cuda()\n",
+    "            # Clear the gradients of all optimized variables\n",
+    "            optimizer.zero_grad()\n",
+    "            # Forward pass: compute predicted outputs by passing inputs to the model\n",
+    "            output = model(data)\n",
+    "            # Calculate the batch loss\n",
+    "            loss = criterion(output, target)\n",
+    "            # Backward pass: compute gradient of the loss with respect to model parameters\n",
+    "            loss.backward()\n",
+    "            # Perform a single optimization step (parameter update)\n",
+    "            optimizer.step()\n",
+    "            # Update training loss\n",
+    "            train_loss += loss.item() * data.size(0)\n",
+    "\n",
+    "        # Validate the model\n",
+    "        model.eval()\n",
+    "        for data, target in valid_loader:\n",
+    "            # Move tensors to GPU if CUDA is available\n",
+    "            if train_on_gpu:\n",
+    "                data, target = data.cuda(), target.cuda()\n",
+    "            # Forward pass: compute predicted outputs by passing inputs to the model\n",
+    "            output = model(data)\n",
+    "            # Calculate the batch loss\n",
+    "            loss = criterion(output, target)\n",
+    "            # Update average validation loss\n",
+    "            valid_loss += loss.item() * data.size(0)\n",
+    "\n",
+    "        # Calculate average losses\n",
+    "        train_loss = train_loss / len(train_loader)\n",
+    "        valid_loss = valid_loss / len(valid_loader)\n",
+    "        train_loss_list.append(train_loss)\n",
+    "\n",
+    "\n",
+    "        # Print training/validation statistics\n",
+    "        print(\n",
+    "            \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f} \\tdecrease_strike: {}\".format(\n",
+    "                epoch, train_loss, valid_loss, decrease_strike\n",
+    "            )\n",
+    "        )\n",
+    "\n",
+    "        if valid_loss > valid_loss_last:\n",
+    "            decrease_strike += 1\n",
+    "        else:\n",
+    "            decrease_strike = 0\n",
+    "        if decrease_strike == 3:\n",
+    "            break\n",
+    "\n",
+    "        valid_loss_list.append(valid_loss)\n",
+    "        valid_loss_last = valid_loss\n",
+    "\n",
+    "        # Save model if validation loss has decreased\n",
+    "        if valid_loss <= valid_loss_min:\n",
+    "            print(\n",
+    "                \"Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...\".format(\n",
+    "                    valid_loss_min, valid_loss\n",
+    "                )\n",
+    "            )\n",
+    "            torch.save(model.state_dict(), f\"{model_name}.pt\")\n",
+    "            valid_loss_min = valid_loss\n",
+    "    return valid_loss_list, train_loss_list\n",
+    "\n",
+    "model = model_1\n",
+    "model_name = \"model_1\"\n",
+    "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
+    "optimizer = optim.SGD(model.parameters(), lr=0.01)  # specify optimizer\n",
+    "\n",
+    "valid_loss_list, train_loss_list = training(model,model_name,criterion,optimizer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13e1df74",
+   "metadata": {
+    "id": "13e1df74"
+   },
+   "source": [
+    "Does overfit occur? If so, do an early stopping."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d39df818",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 472
+    },
+    "id": "d39df818",
+    "outputId": "1baf470d-39e3-4d09-b3bb-0a94168f9fd9"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(range(len(train_loss_list)), train_loss_list)\n",
+    "plt.plot(range(len(valid_loss_list)), valid_loss_list)\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Performance of Model 1\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "zRUTQCilgC7N",
+   "metadata": {
+    "id": "zRUTQCilgC7N"
+   },
+   "source": [
+    "On commence par rajouter au plot la validation loss pour pouvoir determiner si on a affaire a un over fitting\n",
+    "\n",
+    "Avec 30 epochs on réalise que notre loss de train s'éloigne enormement de notre loss de validation, on en conclut donc que l'on apprend trop des données d'entrainement , il semble donc nécessaire de rajouter un early stopage a notre fonction d'entrainement si l'on souhaite limiter le nombre d'inférence, limiter le temps d'entrainement.\n",
+    "\n",
+    "On note tous de même que dans notre fonction on enregistre deja le modéle avec la meilleur validation loss ce qui permet deja le plus souvent de s'abstenir d'un early stopage\n",
+    "\n",
+    "On rajoute tous de même une variable **decrease_strike** qui pour une époch n, lorsque la validation loss est plus grande que au rang n-1 est indenté de 1. Une fois que **decrease_strike** = 3, on arrete l'entrainement. En effet on decide de se stopper lorque que l'on observe plus d'amélioration sur la validation loss. On aurait pu prendre un deacrease_strike plus élevè, mais pour des raison de performance on choisit 3."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "11df8fd4",
+   "metadata": {
+    "id": "11df8fd4"
+   },
+   "source": [
+    "\n",
+    "Now loading the model with the lowest validation loss value\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e93efdfc",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "e93efdfc",
+    "outputId": "5f8919fe-db28-444b-d4cb-06833ffeb9f7"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-9-144d81137707>:1: 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",
+      "  model_1.load_state_dict(torch.load(\"./model_1.pt\"))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 22.319471\n",
+      "\n",
+      "Test Accuracy of airplane: 67% (675/1000)\n",
+      "Test Accuracy of automobile: 78% (786/1000)\n",
+      "Test Accuracy of  bird: 35% (353/1000)\n",
+      "Test Accuracy of   cat: 55% (557/1000)\n",
+      "Test Accuracy of  deer: 56% (563/1000)\n",
+      "Test Accuracy of   dog: 46% (463/1000)\n",
+      "Test Accuracy of  frog: 76% (769/1000)\n",
+      "Test Accuracy of horse: 59% (595/1000)\n",
+      "Test Accuracy of  ship: 68% (688/1000)\n",
+      "Test Accuracy of truck: 64% (640/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 60% (6089/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_1.load_state_dict(torch.load(\"./model_1.pt\"))\n",
+    "\n",
+    "def test_model(model):\n",
+    "  # track test loss\n",
+    "  test_loss = 0.0\n",
+    "  class_correct = list(0.0 for i in range(10))\n",
+    "  class_total = list(0.0 for i in range(10))\n",
+    "\n",
+    "  model.eval()\n",
+    "  # iterate over test data\n",
+    "  for data, target in test_loader:\n",
+    "      # move tensors to GPU if CUDA is available\n",
+    "      if train_on_gpu:\n",
+    "          data, target = data.cuda(), target.cuda()\n",
+    "      # forward pass: compute predicted outputs by passing inputs to the model\n",
+    "      output = model(data)\n",
+    "      # calculate the batch loss\n",
+    "      loss = criterion(output, target)\n",
+    "      # update test loss\n",
+    "      test_loss += loss.item() * data.size(0)\n",
+    "      # convert output probabilities to predicted class\n",
+    "      _, pred = torch.max(output, 1)\n",
+    "      # compare predictions to true label\n",
+    "      correct_tensor = pred.eq(target.data.view_as(pred))\n",
+    "      correct = (\n",
+    "          np.squeeze(correct_tensor.numpy())\n",
+    "          if not train_on_gpu\n",
+    "          else np.squeeze(correct_tensor.cpu().numpy())\n",
+    "      )\n",
+    "      # calculate test accuracy for each object class\n",
+    "      for i in range(batch_size):\n",
+    "          label = target.data[i]\n",
+    "          class_correct[label] += correct[i].item()\n",
+    "          class_total[label] += 1\n",
+    "\n",
+    "  # average test loss\n",
+    "  test_loss = test_loss / len(test_loader)\n",
+    "  print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n",
+    "\n",
+    "  for i in range(10):\n",
+    "      if class_total[i] > 0:\n",
+    "          print(\n",
+    "              \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n",
+    "              % (\n",
+    "                  classes[i],\n",
+    "                  100 * class_correct[i] / class_total[i],\n",
+    "                  np.sum(class_correct[i]),\n",
+    "                  np.sum(class_total[i]),\n",
+    "              )\n",
+    "          )\n",
+    "      else:\n",
+    "          print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n",
+    "\n",
+    "  print(\n",
+    "      \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n",
+    "      % (\n",
+    "          100.0 * np.sum(class_correct) / np.sum(class_total),\n",
+    "          np.sum(class_correct),\n",
+    "          np.sum(class_total),\n",
+    "      )\n",
+    "  )\n",
+    "  # Calculer l'accuracy par classe\n",
+    "  class_accuracy = [100 * class_correct[i] / class_total[i] for i in range(10)]\n",
+    "  overall_accuracy = 100.0 * np.sum(class_correct) / np.sum(class_total)\n",
+    "\n",
+    "  return class_accuracy, overall_accuracy\n",
+    "\n",
+    "class_accuracy_model_1, overall_accuracy_model_1 = test_model(model_1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "PSMnsWQtliZM",
+   "metadata": {
+    "id": "PSMnsWQtliZM"
+   },
+   "source": [
+    "On obtient un score de précision de ..%, on note tous de même que notre modéle n'a pas les même performance pour toutes les classes, il reconnait mieux un camion qu'un chat. On peut imaginer que nos données d'entrainement ne sont pas forcement de qualité égale entre chaque classe"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "944991a2",
+   "metadata": {
+    "id": "944991a2"
+   },
+   "source": [
+    "Build a new network with the following structure.\n",
+    "\n",
+    "- It has 3 convolutional layers of kernel size 3 and padding of 1.\n",
+    "- The first convolutional layer must output 16 channels, the second 32 and the third 64.\n",
+    "- At each convolutional layer output, we apply a ReLU activation then a MaxPool with kernel size of 2.\n",
+    "- Then, three fully connected layers, the first two being followed by a ReLU activation and a dropout whose value you will suggest.\n",
+    "- The first fully connected layer will have an output size of 512.\n",
+    "- The second fully connected layer will have an output size of 64.\n",
+    "\n",
+    "Compare the results obtained with this new network to those obtained previously."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e-r5iZVmyGM-",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "e-r5iZVmyGM-",
+    "outputId": "5b1e0382-bf13-4723-dcab-f8ed79f2fe80"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Net_Prime(\n",
+      "  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+      "  (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
+      "  (fc2): Linear(in_features=512, out_features=64, bias=True)\n",
+      "  (fc3): Linear(in_features=64, out_features=10, bias=True)\n",
+      "  (dropout1): Dropout(p=0.5, inplace=False)\n",
+      "  (dropout2): Dropout(p=0.5, inplace=False)\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "class Net_Prime(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Net_Prime, self).__init__()\n",
+    "        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)\n",
+    "        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)\n",
+    "        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, padding=1)\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "\n",
+    "        self.fc1 = nn.Linear(64 * 4 * 4, 512)\n",
+    "        self.fc2 = nn.Linear(512, 64)\n",
+    "        self.fc3 = nn.Linear(64, 10)\n",
+    "\n",
+    "        self.dropout1 = nn.Dropout(p=0.5)\n",
+    "        self.dropout2 = nn.Dropout(p=0.5)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.pool(F.relu(self.conv1(x)))\n",
+    "        x = self.pool(F.relu(self.conv2(x)))\n",
+    "        x = self.pool(F.relu(self.conv3(x)))\n",
+    "\n",
+    "        x = x.view(-1, 64 * 4 * 4)\n",
+    "\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = self.dropout1(x)\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.dropout2(x)\n",
+    "        x = self.fc3(x)\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "model_2 = Net_Prime()\n",
+    "print(model_2)\n",
+    "\n",
+    "if train_on_gpu:\n",
+    "    model_2.cuda()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6sgJJsVKixyn",
+   "metadata": {
+    "id": "6sgJJsVKixyn"
+   },
+   "source": [
+    "Une fois notre modèle définit on l'entraine avec notre fonction définit précédement.\n",
+    "\n",
+    "On note que l'on a choisit un dropout de 0.5, en effet d'après certaine recherche, 0.5 permet de bonne performance moyenne. Et que si on observe un underfitting ( sous apprentissage ) on peut choisir un dropout plus faible ( ce qui n'est pas le cas pour nous comme on le voit après )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "_cZ4GPlx0afe",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "collapsed": true,
+    "id": "_cZ4GPlx0afe",
+    "outputId": "e48a6de2-d988-416e-a72f-d38cbd9887ce"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 45.672791 \tValidation Loss: 43.047058 \tdecrease_strike: 0\n",
+      "Validation loss decreased (inf --> 43.047058).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 40.327569 \tValidation Loss: 36.178651 \tdecrease_strike: 0\n",
+      "Validation loss decreased (43.047058 --> 36.178651).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 35.442007 \tValidation Loss: 31.407951 \tdecrease_strike: 0\n",
+      "Validation loss decreased (36.178651 --> 31.407951).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 32.533369 \tValidation Loss: 29.002847 \tdecrease_strike: 0\n",
+      "Validation loss decreased (31.407951 --> 29.002847).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 30.439840 \tValidation Loss: 27.056548 \tdecrease_strike: 0\n",
+      "Validation loss decreased (29.002847 --> 27.056548).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 28.872974 \tValidation Loss: 26.517271 \tdecrease_strike: 0\n",
+      "Validation loss decreased (27.056548 --> 26.517271).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 27.291483 \tValidation Loss: 24.217914 \tdecrease_strike: 0\n",
+      "Validation loss decreased (26.517271 --> 24.217914).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 25.774302 \tValidation Loss: 22.862273 \tdecrease_strike: 0\n",
+      "Validation loss decreased (24.217914 --> 22.862273).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 24.405660 \tValidation Loss: 21.796175 \tdecrease_strike: 0\n",
+      "Validation loss decreased (22.862273 --> 21.796175).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 23.212506 \tValidation Loss: 21.211581 \tdecrease_strike: 0\n",
+      "Validation loss decreased (21.796175 --> 21.211581).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 22.055963 \tValidation Loss: 20.629673 \tdecrease_strike: 0\n",
+      "Validation loss decreased (21.211581 --> 20.629673).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 21.008659 \tValidation Loss: 18.969281 \tdecrease_strike: 0\n",
+      "Validation loss decreased (20.629673 --> 18.969281).  Saving model ...\n",
+      "Epoch: 12 \tTraining Loss: 20.047877 \tValidation Loss: 18.698060 \tdecrease_strike: 0\n",
+      "Validation loss decreased (18.969281 --> 18.698060).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 19.115555 \tValidation Loss: 17.939314 \tdecrease_strike: 0\n",
+      "Validation loss decreased (18.698060 --> 17.939314).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 18.313360 \tValidation Loss: 17.183658 \tdecrease_strike: 0\n",
+      "Validation loss decreased (17.939314 --> 17.183658).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 17.476438 \tValidation Loss: 18.531100 \tdecrease_strike: 0\n",
+      "Epoch: 16 \tTraining Loss: 16.772289 \tValidation Loss: 16.799301 \tdecrease_strike: 1\n",
+      "Validation loss decreased (17.183658 --> 16.799301).  Saving model ...\n",
+      "Epoch: 17 \tTraining Loss: 16.053549 \tValidation Loss: 16.628458 \tdecrease_strike: 0\n",
+      "Validation loss decreased (16.799301 --> 16.628458).  Saving model ...\n",
+      "Epoch: 18 \tTraining Loss: 15.514302 \tValidation Loss: 16.047684 \tdecrease_strike: 0\n",
+      "Validation loss decreased (16.628458 --> 16.047684).  Saving model ...\n",
+      "Epoch: 19 \tTraining Loss: 14.983400 \tValidation Loss: 15.802514 \tdecrease_strike: 0\n",
+      "Validation loss decreased (16.047684 --> 15.802514).  Saving model ...\n",
+      "Epoch: 20 \tTraining Loss: 14.371601 \tValidation Loss: 15.707258 \tdecrease_strike: 0\n",
+      "Validation loss decreased (15.802514 --> 15.707258).  Saving model ...\n",
+      "Epoch: 21 \tTraining Loss: 13.758254 \tValidation Loss: 16.701231 \tdecrease_strike: 0\n",
+      "Epoch: 22 \tTraining Loss: 13.175235 \tValidation Loss: 15.723462 \tdecrease_strike: 1\n",
+      "Epoch: 23 \tTraining Loss: 12.656061 \tValidation Loss: 16.682197 \tdecrease_strike: 0\n",
+      "Epoch: 24 \tTraining Loss: 12.212412 \tValidation Loss: 15.556893 \tdecrease_strike: 1\n",
+      "Validation loss decreased (15.707258 --> 15.556893).  Saving model ...\n",
+      "Epoch: 25 \tTraining Loss: 11.689359 \tValidation Loss: 15.391013 \tdecrease_strike: 0\n",
+      "Validation loss decreased (15.556893 --> 15.391013).  Saving model ...\n",
+      "Epoch: 26 \tTraining Loss: 11.226528 \tValidation Loss: 16.020862 \tdecrease_strike: 0\n",
+      "Epoch: 27 \tTraining Loss: 10.741721 \tValidation Loss: 16.218087 \tdecrease_strike: 1\n",
+      "Epoch: 28 \tTraining Loss: 10.338628 \tValidation Loss: 16.461058 \tdecrease_strike: 2\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.optim as optim\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
+    "optimizer = optim.SGD(model_2.parameters(), lr=0.01)  # specify optimizer\n",
+    "\n",
+    "train_loss_list,valid_loss_list = training(model_2,\"model_2\",criterion,optimizer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "Osm3Jrli1IKN",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 472
+    },
+    "id": "Osm3Jrli1IKN",
+    "outputId": "fd96811e-89c4-4e60-aa89-8ec0546f852f"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(range(len(train_loss_list)), train_loss_list)\n",
+    "plt.plot(range(len(valid_loss_list)), valid_loss_list)\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Performance of Model 2\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "jSbZwi8o3g0H",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "jSbZwi8o3g0H",
+    "outputId": "4bb7d105-42dd-4472-c775-3a482c6b61ef"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "<ipython-input-13-d8164c873b61>:1: 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",
+      "  model_2.load_state_dict(torch.load(\"./model_2.pt\"))\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 15.681746\n",
+      "\n",
+      "Test Accuracy of airplane: 69% (697/1000)\n",
+      "Test Accuracy of automobile: 85% (855/1000)\n",
+      "Test Accuracy of  bird: 62% (629/1000)\n",
+      "Test Accuracy of   cat: 62% (626/1000)\n",
+      "Test Accuracy of  deer: 69% (696/1000)\n",
+      "Test Accuracy of   dog: 66% (660/1000)\n",
+      "Test Accuracy of  frog: 80% (803/1000)\n",
+      "Test Accuracy of horse: 81% (816/1000)\n",
+      "Test Accuracy of  ship: 85% (853/1000)\n",
+      "Test Accuracy of truck: 82% (821/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 74% (7456/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "model_2.load_state_dict(torch.load(\"./model_2.pt\"))\n",
+    "\n",
+    "class_accuracy_model_2, overall_accuracy_model_2 = test_model(model_2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "mwNaxPsktCiF",
+   "metadata": {
+    "id": "mwNaxPsktCiF"
+   },
+   "source": [
+    "On obtient grace a notre modèle plus complexe un bien meilleur résulat on passe de 60% a 74%.\n",
+    "\n",
+    "Compléxifié le modèle permet une meilleur \"compréhension\" des données."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "pCo1ldoMqR6w",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 436
+    },
+    "id": "pCo1ldoMqR6w",
+    "outputId": "eead77dd-8715-42e8-e25f-0204f1e380f5"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "def plot_performances(class_accuracy_model_1,class_accuracy_model_2,overall_accuracy_model_1,overall_accuracy_model_2,model_name_1,model_name_2):\n",
+    "  classes = [\"plane\", \"car\", \"bird\", \"cat\", \"deer\", \"dog\", \"frog\", \"horse\", \"ship\", \"truck\"]\n",
+    "  x = np.arange(len(classes))\n",
+    "  width = 0.35\n",
+    "\n",
+    "  fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "\n",
+    "  color1 = 'blueviolet'  # Bleu clair\n",
+    "  color2 = 'slateblue'  # Rouge corail\n",
+    "\n",
+    "  rects1 = ax.bar(x - width/2, class_accuracy_model_1, width, label=model_name_1, color=color1, alpha=0.8)\n",
+    "  rects2 = ax.bar(x + width/2, class_accuracy_model_2, width, label=model_name_2, color=color2, alpha=0.8)\n",
+    "\n",
+    "  ax.set_ylabel('Précision (%)')\n",
+    "  ax.set_xticks(x)\n",
+    "  ax.set_xticklabels(classes, rotation=45)\n",
+    "  ax.legend()\n",
+    "\n",
+    "  def autolabel(rects):\n",
+    "      for rect in rects:\n",
+    "          height = rect.get_height()\n",
+    "          ax.annotate(f'{height:.1f}',\n",
+    "                    xy=(rect.get_x() + rect.get_width() / 2, height),\n",
+    "                    xytext=(0, 3),\n",
+    "                    textcoords=\"offset points\",\n",
+    "                    ha='center', va='bottom')\n",
+    "\n",
+    "  autolabel(rects1)\n",
+    "  autolabel(rects2)\n",
+    "\n",
+    "  ax.text(0.5, 1.15,\n",
+    "          f'Précision globale:\\n{model_name_1}: \\n{overall_accuracy_model_1:.1f}%\\n{model_name_2}: \\n{overall_accuracy_model_2:.1f}%',\n",
+    "          ha='center',\n",
+    "          va='center',\n",
+    "          transform=ax.transAxes,\n",
+    "          bbox=dict(facecolor='white', alpha=0.8, edgecolor='none', pad=10),\n",
+    "          weight='bold',\n",
+    "          fontsize=10)\n",
+    "\n",
+    "  plt.tight_layout()\n",
+    "\n",
+    "  plt.show()\n",
+    "\n",
+    "plot_performances(class_accuracy_model_1,class_accuracy_model_2,overall_accuracy_model_1,overall_accuracy_model_2,\"model_1\",\"model_2\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0jM865YWtlFs",
+   "metadata": {
+    "id": "0jM865YWtlFs"
+   },
+   "source": [
+    "On décide de tracé un diagramme baton permettant de comparer la performance du modèle 1 et du modèle 2 pour chaque classe.\n",
+    "\n",
+    "Le modèle 2 est plus efficasse sur toutes les classes, ces performances sont bien plus élevé pour la plupart et legerement pour d'autre. Il reste globalement bien plus performant"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bc381cf4",
+   "metadata": {
+    "id": "bc381cf4"
+   },
+   "source": [
+    "## Exercise 2: Quantization: try to compress the CNN to save space\n",
+    "\n",
+    "Quantization doc is available from https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic\n",
+    "        \n",
+    "The Exercise is to quantize post training the above CNN model. Compare the size reduction and the impact on the classification accuracy\n",
+    "\n",
+    "\n",
+    "The size of the model is simply the size of the file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ef623c26",
+   "metadata": {
+    "id": "ef623c26"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "def print_size_of_model(model, label=\"\"):\n",
+    "    torch.save(model.state_dict(), \"temp.p\")\n",
+    "    size = os.path.getsize(\"temp.p\")\n",
+    "    print(\"model: \", label, \" \\t\", \"Size (KB):\", size / 1e3)\n",
+    "    os.remove(\"temp.p\")\n",
+    "    return size\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "05c4e9ad",
+   "metadata": {
+    "id": "05c4e9ad"
+   },
+   "source": [
+    "Post training quantization example"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c4c65d4b",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "c4c65d4b",
+    "outputId": "05ebdf2d-4616-463d-d981-1db13b96d29b"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model:  int8  \t Size (KB): 76.522\n",
+      "model:  fp32  \t Size (KB): 251.278\n",
+      "Le modèle quantizé est 69.55% plus léger que le modèle non quantizé\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.quantization\n",
+    "\n",
+    "quantized_model_1 = torch.quantization.quantize_dynamic(model_1, dtype=torch.qint8)\n",
+    "size_quant = print_size_of_model(quantized_model_1, \"int8\")\n",
+    "size = print_size_of_model(model_1, \"fp32\")\n",
+    "reduction = ((size - size_quant) / size) * 100\n",
+    "\n",
+    "print(f\"Le modèle quantizé est {reduction:.2f}% plus léger que le modèle non quantizé\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "FTzASdnZvbha",
+   "metadata": {
+    "id": "FTzASdnZvbha"
+   },
+   "source": [
+    "On commence par afficher la taille de nos deux modèles, la première chose très notable est la différence de taille entre les deux, On prend quasiment 70% moins de place. En effet grace a la quantization on a maintenant un modèle bien plus leger, qui le rend bien plus facile a utiliser/stocker"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b108e17",
+   "metadata": {
+    "id": "7b108e17"
+   },
+   "source": [
+    "For each class, compare the classification test accuracy of the initial model and the quantized model. Also give the overall test accuracy for both models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "AzLCy65jLqEf",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "AzLCy65jLqEf",
+    "outputId": "d67f55d1-b7e6-4acf-829e-bd9d62d18304"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 22.334124\n",
+      "\n",
+      "Test Accuracy of airplane: 67% (670/1000)\n",
+      "Test Accuracy of automobile: 78% (784/1000)\n",
+      "Test Accuracy of  bird: 35% (356/1000)\n",
+      "Test Accuracy of   cat: 55% (558/1000)\n",
+      "Test Accuracy of  deer: 56% (560/1000)\n",
+      "Test Accuracy of   dog: 46% (463/1000)\n",
+      "Test Accuracy of  frog: 76% (768/1000)\n",
+      "Test Accuracy of horse: 59% (594/1000)\n",
+      "Test Accuracy of  ship: 68% (685/1000)\n",
+      "Test Accuracy of truck: 64% (644/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 60% (6082/10000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "class_accuracy_model_1_quant, overall_accuracy_model_1_quant = test_model(quantized_model_1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "OGiAqCapwuH2",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 619
+    },
+    "id": "OGiAqCapwuH2",
+    "outputId": "0972cfb3-8121-4ad6-fd69-cf83ea197f7a"
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKYAAAJGCAYAAABhio1eAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAACqm0lEQVR4nOzdeXxN1/7/8feROTIgiUSImCKJkBgbQ0ta89QaLrekKEprnkt6FVVjB6UoravBVVWtoXprKFGpKYao+QoSMUQitIIYIpL8/vBzvj2NkJA4htfz8diPR87aa6/92edqm/u21tqGrKysLAEAAAAAAACPWSFzFwAAAAAAAIDnE8EUAAAAAAAAzIJgCgAAAAAAAGZBMAUAAAAAAACzIJgCAAAAAACAWRBMAQAAAAAAwCwIpgAAAAAAAGAWBFMAAAAAAAAwC4IpAADwTDt37pzGjRunFStWmLsUAAAA/A3BFAAAeGbdvn1br7/+ulauXKkGDRrk6VqDwSCDwaAFCxbkqn98fLzxms2bN+e92AK0efNmY23x8fF5ujav38P9vPnmmzIYDAoJCXnksQAAwLOBYAoAADwxQkJCjEGIwWCQhYWFSpYsqdatW2v79u15Hu+9995TSkqKIiIi5OLikqdrg4ODFRwcLDc3t1z1t7GxMV7j5OSU51oBAACeR5bmLgAAAODvrK2tVa1aNaWlpenQoUP673//q3Xr1mnbtm164YUX7nnNrVu3ZG1tbdL20Ucf6aOPPnqoGqKiovLUv0SJEnm+BgAA4HnHjCkAAPDEuRvy/P7771q1apWkO8vylixZIsl0SdhHH32kUqVKydbW1nj94sWLVatWLdnb28vBwUGNGzfWrl27TO6RlJSk3r17y8vLS9bW1nJ3d1fnzp2N5/++hC01NVV9+vSRl5eXbGxs5Obmpnr16mnhwoWScl7Kt3XrVjVt2lTOzs6ysbGRv7+/Pv74Y2VkZBj7lClTRgaDQSNHjlT//v3l4uKi4sWLa9CgQbp9+/Z9v6sDBw6oTp06srW1VVBQkLZs2WKsY9y4cfe9dvXq1XrxxRfl4OAgW1tbVatWTfPnz79n3ytXrqhbt25ydHSUm5ubxowZo6ysLOP5bt26ycfHR46OjrK2tpa3t7cGDhyoK1eu3LeGtLQ0jR07Vj4+PrK2tlbx4sXVo0cPXbx40djnr99tfiwpBAAATw5mTAEAgKfWjh07tGXLFvn6+urmzZuS7sySGjlypCSpYsWKSk1N1caNG7V161Zt27ZN1atX1x9//KHatWvr1KlTkiQfHx+lpaVp7dq1Od5rzJgxmjt3rmxsbBQQEKCUlBTt3LlTPj4+6tat2z2v2bx5sxo3bqzbt2+raNGi8vb21tGjR/Xuu+/q2LFjmjdvnkn/zz77TI6OjrKzs1NCQoI+//xzVa5cWb169brn+Ddu3FCLFi2UkJAgKysrpaenq1WrVrn67hYvXqwuXbpIktzd3WVra6t9+/bprbfeUlJSkv71r3+Z9H/vvffk7OwsZ2dnJSQk6MMPP5Srq6sGDhwoSfrxxx9laWmp8uXL6+rVq4qLi9PMmTOVmJio77//Psc62rVrpzVr1sjCwkIBAQGKj49XeHi4du7cqT179sjOzi5XzwMAAJ5OzJgCAABPnMTERNWuXVvVqlVTmzZtJEmWlpbq1KmTSb9bt27pv//9r44cOaLz58/r+vXr+uCDDyRJH3zwgWJiYnTq1CnVrFlTN2/e1IQJEyRJs2fPNoZSy5Yt07Fjx3Tq1Clt2rQpx5qOHz8uSXr//fe1d+9excXFKTk5WUOGDMnxmrFjx+r27dvy9vZWXFycjh07pkGDBkmS5s+fr7i4OJP+pUqVUlxcnE6cOCFPT09JUkRERI7jL1myRAkJCZKklStX6siRI5o2bVqO/f/qbvAUHBysU6dO6eTJk2rbtq0kaeLEibp+/bpJ/+rVqys+Pl4nT57USy+9JEmaNGmS8XxkZKQuXryoffv2KTY21jj+qlWrjKHh30VGRmrNmjWSpE2bNmn//v06evSo7OzsdOTIEeMMOSsrK/n6+srX11fOzs65ej4AAPB0IJgCAABPnFu3bmnnzp06cOCA3Nzc1LJlS0VGRio4ONikn6+vr5o3by5JsrCw0OHDh42BytixY2UwGGRlZaU9e/ZIkn7//XdJ0s6dOyVJFSpUUIcOHYzjVatWLceaWrduLelOMOXt7a2mTZtq5syZcnd3z/Ga3bt3S5JatGihIkWKSJJxuWBWVpaio6NN+r/66qtydnaWra2typYtK0k6f/58juMfPnxYkmRvb6+WLVtKkjp27Jhj/7uSk5N1+vRpSXdmLNnY2MhgMOj111+XdGcm1t2x7/rHP/4hKysrWVlZ6R//+IextgsXLkiSNm7cqMqVK8vOzk4Gg0ETJ06UdGcJ5t0+f/fX5ZUNGjSQwWCQp6enbty4Ien/9vkqWbKkjh49qqNHjxrDMwAA8GxgKR8AAHjieHt7Kz4+/oH97hcKdezY0Rju3OXo6PjQNfXu3Vt+fn5avXq1Dh48qOjoaP3yyy/6/vvvdejQoYce96/uhlfSnRlikkz2ccqJwWDIl/s/rG+++UbDhw+XdGd/MC8vL128eNE4I+yv+2nl5O+hoyR5eHjkb6EAAOCJw4wpAADw1Pp7IBMQEGDck8je3l4TJ07UlClTNHnyZDVq1Mg4I+puCHLixAmtWLHCeP2+fftyvNeuXbsUEBCgTz75ROvXr9d///tfSXdmLf3xxx/3vKZWrVqSpDVr1iglJUWS9O233xprr1GjRh6f2FTlypUlSdeuXdMvv/wi6c7SxAcpXry4SpcuLUlasWKF0tLSlJWVpaVLl0qS7OzsFBAQYHLNihUrdPv2bd2+fdv4nbm7u8vNzc04s8nR0VEnT57Uzp071aRJkwfWcff7kaSwsDBFRUUpKipKW7du1bhx49SzZ09JUkJCgvz8/OTn56eVK1c+cFwAAPD0IJgCAADPDHt7e73//vuSpAULFqhkyZIKDAyUs7OzyZv5+vXrJ29vb0lS+/bt5evrq7Jly+rll1/OcezPP/9cHh4eKlu2rGrUqKGmTZtKurPMrFixYve85oMPPpClpaVOnTqlcuXKqWLFipo+fbokqWfPnipXrtwjPW/nzp1VsmRJSXeWGgYEBNx3z6u/urvUbufOnfL29lbZsmWNoc+//vUv2dvbm/Tfs2ePypQpozJlyigyMlKSNGrUKElSYGCgJOnq1asqV66cypUrl6uALCQkxPg9tmnTRn5+fgoICFCRIkXUvHlz46y59PR0xcTEKCYmRpcvX87V8wEAgKcDwRQAAHimhIWFaeHChapVq5auXLmiuLg4lSxZUu+8847atWsnSXJxcVFUVJR69eqlkiVLKi4uTtevX1ezZs1yHLdly5Z66aWXdOPGDR08eFC2trZq3bq11qxZk+NSupCQEP36669q3LixMjIyFB8fLz8/P02dOlVz58595Ge1tbXVmjVrjDPAChUqZJyRJem+b7R744039OOPP6pevXq6evWqkpKSVLVqVf373//O9kY+6c5G5w0bNtTly5fl4uKif/3rX8Y38vXs2VNDhw6Vq6urrl69qpCQEI0fPz5Xz7Bq1SqNGTNGPj4+iouLU1JSkvz9/TV69GjjjDAAAPDsMmTlZuMCAAAAPJFOnDih8uXLG8Oxb775Rm+88YYkad26dcYZSQAAAE8igikAAICnWJs2bXTgwAFVrlxZly5d0rZt25SVlaX69etr8+bNZt8YHQAA4H54Kx8AAMBTLCQkRDExMdq4caMyMzPl6+urDh06aNSoUYRSAADgiceMKQAAAAAAAJgFm58DAAAAAADALAimAAAAAAAAYBYEUwAAAGYUEhIig8GgkJCQPF03btw4GQwGlSlTpkDqAgAAeBwIpgAAAJ4Dv/32m1q0aCE3NzcZDAYZDAbNnTvX3GUBAIDnHMEUAADAc2Dv3r3asGGDihUrZu5SAAAAjAimAAAA/r8yZcrIYDCoS5cuGjp0qJydnVWyZEmFh4crMTFRLVu2VOHChRUUFKRt27aZXLt161Y1bdpUzs7OsrGxkb+/vz7++GNlZGQY+1y6dEkdO3aUvb29SpcuneOMpbS0NI0dO1Y+Pj6ytrZW8eLF1aNHD128ePGhn61Lly66cuWK1q9ff99+D7u0EAAA4GFYmrsAAACAJ833338vR0dH2dvb69y5c+rVq5fKly+va9euydraWgcOHFCnTp0UGxsrKysrbd68WY0bN9bt27dVtGhReXt76+jRo3r33Xd17NgxzZs3T5L01ltvacWKFZIke3t7DR8+/J73b9eundasWSMLCwsFBAQoPj5e4eHh2rlzp/bs2SM7O7s8P5OLi8vDfyEAAAAFhBlTAAAAf+Pk5KTjx49ry5YtkqSMjAxZWVkpNjZWP/zwgyTpzJkzio2NlSSNHTtWt2/flre3t+Li4nTs2DENGjRIkjR//nzFxcUpNjbWGEqNHDlSR48eVXR0tNLS0kzuHRkZqTVr1kiSNm3apP379+vo0aOys7PTkSNHtGTJkgJ99tKlS8vX11elS5cu0PsAAABIBFMAAADZvPjiiypSpIjJG++aNGkiGxsblStXzth2/vx5SdLu3bslSS1atFCRIkUkSZ07d5YkZWVlKTo6WocPHzZe1759e0mSr6+vAgMDTe69a9cu488NGjSQwWCQp6enbty4IUmKiorKp6e8t0WLFuno0aNatGhRgd4HAABAYikfAABANk5OTpIkS0vLbG0Gg8HYlpWVVaB1BAcHZ2vz8PAo0HsCAAA8TgRTAAAAj6hWrVr67bfftGbNGqWkpKhIkSL69ttvJd0JsmrUqKHMzExj/5UrV6pWrVo6duyYDhw4kG2su8LCwvTaa69Jkm7fvq2NGzfKz8+vQJ+la9eu2rVrl1544QVmTQEAgALHUj4AAIBH9MEHH8jS0lKnTp1SuXLlVLFiRU2fPl2S1LNnT5UrV04VKlRQmzZtJEmTJ0+Wv7+/qlevLgsLC5OxQkJC1LRpU0lSmzZt5Ofnp4CAABUpUkTNmzdXfHz8Q9W4YsUKVahQweRte2PGjFGFChUUGhpqbDt9+rRiYmJ0+vTph7oPAABAXhBMAQAAPKKQkBD9+uuvaty4sTIyMhQfHy8/Pz9NnTpVc+fONfabP3++2rdvL1tbW12+fFnjx49X7dq1s423atUqjRkzRj4+PoqLi1NSUpL8/f01evRoVa5c+aFqvHLlimJjY3Xq1Clj24ULFxQbG6uEhISHGhMAAOBRGbIKenMEAAAAAAAA4B7YYwoAAOAZcK+ZV3cV9Jv8AAAAHhYzpgAAAJ4Bf31b4N/x6x4AAHhSMWMKAADgGUD4BAAAnkZsfg4AAAAAAACzIJgCAAAAAACAWRBMAQAA5IMLFy5owIAB8vb2lrW1tVxdXdWwYUPFxcVJkq5evaohQ4aoVKlSsra2Vvny5fXBBx/o9u3bDxx769atatq0qYoXLy57e3sFBwfrp59+MukTHh6ucuXKycHBQS+//LKOHTtmcr5ly5Zq2rRp/j0wAABAPmDzcwAAgEd08eJFvfDCCzp58qSsra3l4+OjrKwsnTx5Ur/88ovq1q2rV155RZGRkbKyslK5cuV0/PhxZWZmqkuXLlq0aFGOY0dERKhp06bKyMiQh4eHnJ2dFRMTI4PBoOXLl6tt27Y6evSoAgIC1LVrV02cOFFVqlSRn5+ftm3bJklasmSJevXqpUOHDqls2bKP62sBAAB4IGZMAQAAPKLRo0fr5MmTCggIUHx8vA4dOqTDhw8rJSVFtWrV0qpVqxQZGSlJWrFihY4eParp06dLkv7zn/9o7969OY795ZdfKiMjQyVLllR8fLyOHj2qzp07KysrSyNHjpQkHTx4UJmZmapbt648PT3l6+ur/fv3S5L++OMPDR48WB9++CGhFAAAeOIQTAEAADyCrKwsLVu2TJLk5eWlxo0bq3DhwgoKCtLy5ctlY2OjtWvXSpLs7OzUokULSVL79u2NY6xbty7H8TMzMyVJBoNBBoNBklSo0J1f4Y4fP67Tp0+rSpUqKlSokLZv365z584pJiZGQUFBkqShQ4eqTJkyGjRoUD4/OQAAwKMjmAIAAHgEFy5c0KVLlyTdCZhSUlJUtGhRHThwQJ07d9YPP/ygM2fOSJJcXFyMoZK7u7txjNOnT+c4fseOHSVJZ8+eVZkyZeTv76/FixcbzyckJMjPz0///ve/FRkZKR8fH1WpUkVff/21Nm7cqG+//VZz5szRu+++qxIlSqh06dKaOnVqvn8PAAAAD4NgCgAA4BH8dfNyf39/xcXFKS4uTv7+/pKkWbNm3fO63G7z2bFjRy1YsECBgYG6fPmy0tLS9PrrrxvPW1lZSZK6d++uuLg4Xbt2TZs3b5aXl5fefvttDR8+XLt27dK0adM0YMAAvfrqqxo1atR9Z2kBAAA8LgRTAAAAj8DNzU3W1taSpKCgIFlbW8va2tq4lC4+Pl5eXl6S7mySfndpXnJysnGM0qVL3/ce3bp10/79+3Xt2jXFxcUpMDBQ0p0lfT4+Pve8ZsyYMbK0tNSYMWO0ceNGSdKAAQP09ttvS5I2bNjwsI8MAACQbwimAAAAHoGVlZXq168vSTpw4IDS09OVnp6uAwcOSJJ8fHzUrFkzSdLNmze1Zs0aSdLy5cuNY9w9v3LlSvn5+cnPz08JCQmSpBs3bmjnzp3GvocPH9a0adOM1zk7O2erae/evZoxY4a++uor2draGmdnWVtbG2dYAQAAPAkszV0AAADA027ChAn67bffdOTIEeOb7xISEmRhYaH33ntP9evX14svvqitW7eqXbt2Kl++vI4dOyZJ6ty5s6pXry5Junz5smJiYiRJ6enpkqRr166pdu3a8vT0lLOzs44fP67bt2/L1dVVM2bMyFbL7du39dZbb6l79+5q0KCBJKlRo0ZauXKl1qxZo7i4OElSw4YNC/ZLAQAAyAVmTAEAADyi4OBgbdq0SSEhIbp06ZJu3rypRo0aadu2bXr55ZdlYWGhn3/+WQMHDpSbm5tiY2NVunRpjRkzRgsWLLjv2HZ2dmrWrJlu376tEydOyMXFRV27dtXu3btVoUKFbP2nTZumpKQkffzxx8a23r17a+DAgerVq5c++eQTTZgwwfh2QAAAAHMyZOV2500AAAAAAAAgHzFjCgAAAAAAAGZBMAUAAAAAAACzIJgCAAAAAACAWRBMAQAAAAAAwCwIpgAAAPBEOHfunMaNG6cVK1aYuxQAAPCYEEwBAIDnQkhIiAwGg0JCQvJ03bhx42QwGFSmTJkCqetZsWDBAhkMBhkMhoe6/vbt23r99de1cuVKNWjQIJ+rAwAATyqCKQAAgHz022+/qUWLFnJzczMGNXPnzjV3WfnmbsD35ptvmrS7ubkpODhYwcHBDzXue++9p5SUFEVERMjFxSUfKgUAAE8DgikAAIB8tHfvXm3YsEHFihUzdymPVcuWLRUVFaWoqKiHuv6jjz7SgQMH5Orqms+VAQCAJxnBFAAAeOzKlCkjg8GgLl26aOjQoXJ2dlbJkiUVHh6uxMREtWzZUoULF1ZQUJC2bdtmcu3WrVvVtGlTOTs7y8bGRv7+/vr444+VkZFh7HPp0iV17NhR9vb2Kl26dI4zltLS0jR27Fj5+PjI2tpaxYsXV48ePXTx4sWHfrYuXbroypUrWr9+/UOPceDAAdWuXVu2trYKCgrSli1bjLOvxo0bJ0navHmzsS0+Pt547d22BQsWSJLOnj2rFi1ayMvLS3Z2drKzs1PlypU1ffp0ZWVlGa+7+7/JyJEj1b9/f7m4uKh48eIaNGiQbt++bRw7MjJSkrRw4UKT+/99KV98fLzx89+Pu88gSYsXL1atWrVkb28vBwcHNW7cWLt27TL5Pu7W9vdZWgAA4Olnae4CAADA8+v777+Xo6Oj7O3tde7cOfXq1Uvly5fXtWvXZG1trQMHDqhTp06KjY2VlZWVNm/erMaNG+v27dsqWrSovL29dfToUb377rs6duyY5s2bJ0l66623jBto29vba/jw4fe8f7t27bRmzRpZWFgoICBA8fHxCg8P186dO7Vnzx7Z2dnl+ZkedRnajRs31KJFCyUkJMjKykrp6elq1arVQ4938eJFrV27VqVKlZK/v78SEhJ0+PBhDRkyRFZWVurXr59J/88++0yOjo6ys7NTQkKCPv/8c1WuXFm9evVScHCwjhw5oqtXr8rV1VXly5eXJNnY2GS7r42NjcmyvuTkZJ08eVKSjN/rRx99pJEjR0qSKlasqNTUVG3cuFFbt27Vtm3bVL169Yd+bgAA8HRgxhQAADAbJycnHT9+XFu2bJEkZWRkyMrKSrGxsfrhhx8kSWfOnFFsbKwkaezYsbp9+7a8vb0VFxenY8eOadCgQZKk+fPnKy4uTrGxscZQauTIkTp69Kiio6OVlpZmcu/IyEitWbNGkrRp0ybt379fR48elZ2dnY4cOaIlS5Y8lu/g75YsWaKEhARJ0urVq3XkyBFNmzbtoccrW7asTp48qTNnzmjv3r1KTExU/fr1JUlLly7N1r9UqVKKi4vTiRMn5OnpKUmKiIiQJEVFRRnDor8u3StRokS2cUqUKGE8/9///leWlnf+PrROnToaOHCgrl+/rg8++ECS9MEHHygmJkanTp1SzZo1dfPmTU2YMME4Vvny5eXr63vP+wAAgKcbwRQAADCbF198UUWKFDF5412TJk1kY2OjcuXKGdvOnz8vSdq9e7ckqUWLFipSpIgkqXPnzpKkrKwsRUdH6/Dhw8br2rdvL0ny9fVVYGCgyb3/ulysQYMGMhgM8vT01I0bNyTpofdKelR367e3t1ezZs0kSR07dnzo8SwtLfXRRx/J29tbVlZWsrCw0G+//SZJOnfuXLb+r776qpydnWVra6uyZctK+r/v/2HcuHFDr776qo4fPy5fX1/99NNPsrOz0+HDh3X9+nVJdwJHg8EgKysr7dmzR5L0+++/G8eIiIjQ0aNHNXny5IeuAwAAPJlYygcAAMzGyclJkoyzaf7adnevIkkmeyEVhHu9Sc7Dw6NA7/kgf33+B52/u7/W5cuXs/UbPHiw/v3vf0uSfHx8VKxYMcXGxurixYsm+3LddTfwk/7vf5eH/f4zMzPVuXNn7dixQx4eHlq3bt09lzp27NjRGILd5ejo+FD3BAAATxeCKQAA8NSoVauWfvvtN61Zs0YpKSkqUqSIvv32W0l3gpoaNWooMzPT2H/lypWqVauWjh07pgMHDmQb666wsDC99tprkqTbt29r48aN8vPzewxPlF3lypUlSdeuXdMvv/yiJk2aGJc1/lXx4sWNPx87dkzly5fX999/n63f3ZlfTZo00fr163Xz5k3Vrl37oTd4t7e3N9b3IIMGDdKqVavk6OioNWvWmMyMCwgIkJ2dnW7cuCF7e3tNnDhRFhYWysrKUkREhG7dumXs27BhQyUkJKht27bMmgIA4BnDUj4AAPDU+OCDD2RpaalTp06pXLlyqlixoqZPny5J6tmzp8qVK6cKFSqoTZs2kqTJkyfL399f1atXl4WFhclYISEhatq0qSSpTZs28vPzU0BAgIoUKaLmzZubvOkuL1asWKEKFSooJCTE2DZmzBhVqFBBoaGhD7y+c+fOKlmypCSpdevWCggI0ODBg7P18/HxUenSpY3XvPzyy9k2MpdkXML4yy+/yNfXV15eXjpz5sxDPNkddwO7FStWqHr16sblhn8XFRWlWbNmSbqz2XmfPn1Uu3Zt1a5dW//+979lb2+v999/X5K0YMEClSxZUoGBgXJ2ds72Zr7Y2FjFxMQoMTHxoesGAABPJoIpAADw1AgJCdGvv/6qxo0bKyMjQ/Hx8fLz89PUqVM1d+5cY7/58+erffv2srW11eXLlzV+/HjVrl0723irVq3SmDFj5OPjo7i4OCUlJcnf31+jR482zlzKqytXrig2NlanTp0ytl24cEGxsbHGTc3vx9bWVj///LNxeWGhQoW0evXqbP0sLS313XffqVq1arp586b+/PNPrVy5Mlu/adOm6bXXXpODg4OuXr2qESNGqHXr1g/1bJI0fPhwNWrUSPb29vr999+Ne0L93c2bN40/Jycna+fOncbj7Nmzku7MVFu4cKFq1aqlK1euKC4uTiVLltQ777yjdu3aPXSNAADg6WHIKuhNGwAAAPDI7u4pNXbsWI0bN868xQAAAOQT9pgCAADIg3vNvLorN2/y27t3r/r27XvPc9WrV9cXX3zx0LUBAAA8bQimAAAA8mDnzp2PdP2VK1dyHMPW1vaRxgYAAHjasJQPAAAAAAAAZsHm5wAAAAAAADALgikAAAAAAACYBcEUAABAPrhw4YIGDBggb29vWVtby9XVVQ0bNlRcXJwk6erVqxoyZIhKlSola2trlS9fXh988IFu3779wLEjIiLUuHFjubu7y8bGRp6envrHP/6hgwcPGvv8/PPPCggIkL29vWrVqpVtH6u+ffuqcuXKSk9Pz98HBwAAeATsMQUAAPCILl68qBdeeEEnT56UtbW1fHx8lJWVpZMnT+qXX35R3bp19corrygyMlJWVlYqV66cjh8/rszMTHXp0kWLFi3Kcexjx46pSpUqunXrlooWLaoyZcro0KFDSk9Pl5ubmxITE3X16lWVKlVKtWvX1rJly1S3bl2lpqbq7NmzkqRt27YpJCREW7Zsue9bBQEAAB43ZkwBAAA8otGjR+vkyZMKCAhQfHy8Dh06pMOHDyslJUW1atXSqlWrFBkZKUlasWKFjh49qunTp0uS/vOf/2jv3r05jr1r1y7dunVLkrR27Vrt3btXYWFhkqQ//vhDqampOn78uK5du6bg4GAVK1ZM1atXV0JCgi5evKhbt26pV69e6tOnD6EUAAB44hBMAQAAPIKsrCwtW7ZMkuTl5aXGjRurcOHCCgoK0vLly2VjY6O1a9dKkuzs7NSiRQtJUvv27Y1jrFu3Lsfxg4ODZW1tLUlq0aKFqlevrsmTJ8vZ2Vmff/65nJ2dVaFCBRUuXFg7d+7Un3/+qb1796pkyZJydXXVxIkTde3aNU2aNKmgvgIAAICHRjAFAADwCC5cuKBLly5JuhMwpaSkqGjRojpw4IA6d+6sH374QWfOnJEkubi4qFChO79+ubu7G8c4ffp0juP7+Pho48aNcnNz059//qnff/9d6enpKlWqlCpVqiRJKlq0qL777judO3dOpUqVkoODg3744QcdOXJEU6ZM0Zw5czR79myVLl1aJUqU0LBhw3K1txUAAEBBI5gCAAB4BH8NePz9/RUXF6e4uDj5+/tLkmbNmnXP63K7zWdCQoJ69OihCxcu6LvvvlNqaqoGDx6sw4cPq2XLlkpMTJQktWzZUkeOHNH169e1Z88evfDCC+rVq5fat28vg8GgUaNGqXXr1howYICmTZumf//734/45AAAAI+OYAoAAOARuLm5GZfaBQUFydraWtbW1goKCpIkxcfHy8vLS9KdTdIzMzMlScnJycYxSpcuneP4X3zxhU6cOCEnJyd17NhRhQsXVteuXSVJN27c0LZt23K8LiYmRjNmzNDGjRslSe+8844GDBggSdqwYcOjPDYAAEC+IJgCAAB4BFZWVqpfv74k6cCBA0pPT1d6eroOHDgg6c5SvGbNmkmSbt68qTVr1kiSli9fbhzj7vmVK1fKz89Pfn5+SkhIkCRdvnxZknT16lUdO3ZMkrRnzx7jtYULF85W09mzZ/Xee+9p2rRpcnNzM87Osra2lpWVVf49PAAAwCMimAIAAHhEEyZMkLW1tY4cOaKyZcuqbNmyOnLkiCwsLPTee++pTZs2evHFFyVJ7dq1k7+/vwYPHixJ6ty5s6pXry7pTggVExOjmJgYpaenS5Latm0rg8GgrKwsVa9eXYGBgXrnnXckSd7e3goJCclWT9++fVWnTh3jzKpGjRpJuvNWv59//lmS1LBhwwL7PgAAAHKLYAoAAOARBQcHa9OmTQoJCdGlS5d08+ZNNWrUSNu2bdPLL78sCwsL/fzzzxo4cKDc3NwUGxur0qVLa8yYMVqwYMF9x27YsKHWrFmjRo0aycHBQceOHVPp0qX11ltvacuWLbKzszPpv2zZMkVERGju3LnGthYtWmjChAmaOnWq3n77bQ0cOFC9e/cuiK8CAAAgTwxZud15EwAAAAAAAMhHzJgCAAAAAACAWRBMAQAAAAAAwCwIpgAAAAAAAGAWBFMAAAAAAAAwC4IpAAAAAAAAmAXBFAAAAAAAAMyCYAoAAAAAAABmQTAFAAAAAAAAsyCYAgAAAAAAgFkQTAEAAAAAAMAsCKYAAAAAAABgFgRTAAAAAAAAMAuCKQAAAAAAAJgFwRQAAAAAAADMgmAKAAAAAAAAZkEwBQAAAAAAALMgmAIAAAAAAIBZEEwBAAAAAADALAimAAAAAAAAYBYEUwAAAAAAADALgikAAAAAAACYBcEUAAAAAAAAzMLS3AUUtMzMTJ07d06Ojo4yGAzmLgcAAAAAAOCZlpWVpatXr8rT01OFCt1/TtQzH0ydO3dOXl5e5i4DAAAAAADguXLmzBmVKlXqvn2e+WDK0dFR0p0vw8nJyczVAAAAAAAAPNuuXLkiLy8vYyZzP898MHV3+Z6TkxPBFAAAAAAAwGOSmy2V2PwcAAAAAAAAZkEwBRSwMmXKyGAwZDv69esnSUpKSlKXLl3k4eGhwoULq3r16lq+fPkDx01ISNAbb7whFxcX2dnZqUqVKtqzZ09BPw4AAAAAAPmGYAooYLt371ZiYqLx2LBhgySpQ4cOkqSuXbsqJiZGq1ev1sGDB9WuXTt17NhRv//+e45jXrp0SfXq1ZOVlZXWrl2rI0eO6NNPP1XRokVzVVNBhWV3TZkyRQaDQYMHD871NQAAAACA588zv8cUYG5ubm4mn6dMmaLy5curQYMGkqTt27drzpw5euGFFyRJo0eP1meffabo6GhVq1btnmNOnTpVXl5eCg8PN7aVLVs21zXt3r1bGRkZxs+HDh1S48aNTcKylJQUrV69Wq6urlqyZIk6duyoPXv25FjTX8f+8ssvFRgYmOt6AAAAgOdZZmambt26Ze4ygFyzsrKShYVFvoxFMAU8Rrdu3dLixYs1dOhQ4yZwdevW1XfffaeWLVuqSJEiWrZsmW7evKmQkJAcx1m9erWaNm2qDh06KDIyUiVLllTfvn3Vq1evXNVREGGZJKWmpio0NFTz5s3ThAkTclULAAAA8Dy7deuWTp48qczMTHOXAuRJkSJF5OHhkasNzu+HYAp4jFatWqWUlBS9+eabxrZly5bpn//8p1xcXGRpaSl7e3utXLlSFSpUyHGcuLg4zZkzR0OHDtV7772n3bt3a+DAgbK2tla3bt3yVFN+hWWS1K9fP7Vs2VKNGjUimAIAAAAeICsrS4mJibKwsJCXl5cKFWK3HTz5srKydP36dSUnJ0uSSpQo8UjjmTWYysjI0Lhx47R48WIlJSXJ09NTb775pkaPHm38P8hZWVkaO3as5s2bp5SUFNWrV09z5syRj4+POUsHHsr8+fPVvHlzeXp6Gtvef/99paSkaOPGjXJ1ddWqVavUsWNHbdmyRVWqVLnnOJmZmapZs6YmTZokSapWrZoOHTqkuXPn5jmYyq+wbOnSpdq7d692796dp/sDAAAAz6vbt2/r+vXr8vT0lL29vbnLAXLNzs5OkpScnKzixYs/0rI+swZTU6dO1Zw5c7Rw4UIFBARoz5496t69u5ydnTVw4EBJ0kcffaTPP/9cCxcuVNmyZfX++++radOmOnLkiGxtbc1ZPpAnp06d0saNG7VixQpjW2xsrGbNmqVDhw4pICBAkhQUFKQtW7Zo9uzZmjt37j3HKlGihCpVqmTS5u/vn6cNyu/Kj7DszJkzGjRokDZs2MA/lwAAAEAu3d331dra2syVAHl3N0xNT09/eoOp7du367XXXlPLli0l3XlT2Lfffqtdu3ZJujNbavr06Ro9erRee+01SdKiRYvk7u6uVatW6fXXXzdb7UBehYeHq3jx4sY/75J0/fp1Sco2ZdfCwuK+a8zr1aunmJgYk7Zjx47J29s7TzXlV1gWHR2t5ORkVa9e3diWkZGh3377TbNmzVJaWlq+bYwHAAAAPGsedY8ewBzy68+tWRew1q1bVxERETp27Jgkaf/+/dq6dauaN28uSTp58qSSkpLUqFEj4zXOzs4KDg7Wjh077jlmWlqarly5YnIA5paZmanw8HB169ZNlpb/lwf7+fmpQoUKevvtt7Vr1y7Fxsbq008/1YYNG9SmTRtjv4YNG2rWrFnGz0OGDFFUVJQmTZqkEydOaMmSJfrqq6/Ur1+/PNWVX2FZw4YNdfDgQe3bt8941KxZU6Ghodq3bx+hFAAAeVCmTBkZDIZsx1//O79jxw698sorKly4sJycnFS/fn3duHEjxzGvXr2qwYMHy9vbW3Z2dqpbty7L7wEATwSzBlOjRo3S66+/Lj8/P1lZWalatWoaPHiwQkNDJUlJSUmSJHd3d5Pr3N3djef+bvLkyXJ2djYeXl5eBfsQQC5s3LhRp0+fVo8ePUzaraystGbNGrm5ual169YKDAzUokWLtHDhQrVo0cLYLzY2VhcvXjR+rlWrllauXKlvv/1WlStX1ocffqjp06cb/9nJjfwMyxwdHVW5cmWTo3DhwnJxcVHlypXz+nUBAPBc2717txITE43Hhg0bJEkdOnSQdCeUatasmZo0aaJdu3Zp9+7d6t+//303TX7rrbe0YcMG/ec//9HBgwfVpEkTNWrUSAkJCQ+spyCCsoyMDL3//vsqW7as7OzsVL58eX344YfKysrK7dcEAHhGmHUp37Jly/TNN99oyZIlCggI0L59+zR48GB5enrmeQPnu8LCwjR06FDj5ytXrhBOweyaNGmS4y9aPj4+D9wbKj4+Pltbq1at1KpVq4eu6UFh2ahRo9S6dWulpqaqQoUKDwzLAABA/nBzczP5PGXKFJUvX14NGjSQdGfm9MCBAzVq1ChjH19f3xzHu3HjhpYvX64ff/xR9evXlySNGzdOP/30k+bMmfPAN+nu3r3buA+OJB06dEiNGzfOFpSFhYVp5syZsrS01P79++8blOVmr1ngebao470nYhSUrss8Huv9ciskJERVq1bV9OnTc9V/wYIFGjx4sFJSUgq0LuQvswZTI0aMMM6akqQqVaro1KlTmjx5srp16yYPjzv/cJw/f97k9YPnz59X1apV7zmmjY2NbGxsCrx24GlXEGHZX23evPkhKwMAAHfdunVLixcv1tChQ2UwGJScnKydO3cqNDRUdevWVWxsrPz8/DRx4kS9+OKL9xzj9u3bysjIyPaCEjs7O23duvWBNeR3UCY9eK9ZAChoiYmJGjZsmPbs2aMTJ05o4MCBuQ7AkL/MupTv+vXr993HpmzZsvLw8FBERITx/JUrV7Rz507VqVPnsdYKAAAAPG6rVq1SSkqK3nzzTUlSXFycpDsznnr16qV169apevXqatiwoY4fP37PMRwdHVWnTh19+OGHOnfunDIyMrR48WLt2LFDiYmJearnblDWo0cPk6CsePHiqlu3rtzd3dWgQYMHBl4P2msWAApaWlqa3NzcNHr0aAUFBZm7nOeaWYOp1q1ba+LEifr5558VHx+vlStXatq0aWrbtq2kOzu8Dx48WBMmTNDq1at18OBBde3aVZ6eniZ73QAAAADPovnz56t58+by9PSUJONf4L799tvq3r27qlWrps8++0y+vr76+uuvcxznP//5j7KyslSyZEnZ2Njo888/V6dOne673O5e8iMokx681yyAJ1tISIgGDBigwYMHq2jRonJ3d9e8efN07do1de/eXY6OjqpQoYLWrl1rvCYyMlIvvPCCbGxsVKJECY0aNUq3b982nr927Zq6du0qBwcHlShRQp9++mm2+6alpWn48OEqWbKkChcurODg4IdeqVGmTBnNmDFDXbt2lbOz80ONgfxh1mBq5syZ+sc//qG+ffvK399fw4cP19tvv60PP/zQ2Ofdd9/VgAED1Lt3b9WqVUupqalat25dtqnIAAAAwLPk1KlT2rhxo9566y1j293tLSpVqmTS19/fX6dPn85xrPLlyysyMlKpqak6c+aMdu3apfT0dJUrVy5PNeVXUPbXvWb37t2rhQsX6pNPPtHChQvzVA8A81m4cKFcXV21a9cuDRgwQH369FGHDh1Ut25d7d27V02aNFGXLl10/fp1JSQkqEWLFqpVq5b279+vOXPmaP78+SZ73I0YMUKRkZH68ccf9csvv2jz5s3au3evyT379++vHTt2aOnSpTpw4IA6dOigZs2a3TcIx5PPrHtMOTo6avr06fddx2kwGDR+/HiNHz/+8RUGAAAAmFl4eLiKFy9u3IdJuvM3/J6enoqJiTHpe+zYsVwtgytcuLAKFy6sS5cuaf369froo49yXc/doGzFihXGtocNyh601yyAJ19QUJBGjx4t6c5LyKZMmSJXV1f16tVLkjRmzBjNmTNHBw4c0E8//SQvLy/NmjVLBoNBfn5+OnfunEaOHKkxY8bo+vXrmj9/vhYvXqyGDRtKuhN8lSpVyni/06dPKzw8XKdPnzaG48OHD9e6desUHh6uSZMmPeZvAPnFrMEU8Cx63G/QyI0n9S0bAADg3jIzMxUeHq5u3brJ0vL/fmU3GAwaMWKExo4dq6CgIFWtWlULFy7U0aNH9cMPPxj7NWzYUG3btlX//v0lSevXr1dWVpZ8fX114sQJjRgxQn5+furevXuua8rPoOxBe80CePIFBgYaf7awsJCLi4uqVKlibHN3d5ckJScn63//+5/q1Kkjg8FgPF+vXj2lpqbq7NmzunTpkm7duqXg4GDj+WLFipm8SOHgwYPKyMhQxYoVTepIS0uTi4tLvj8fHh+CKeA5MHX0UXOXkM3ICX7mLgEAgCfWxo0bdfr0afXo0SPbucGDB+vmzZsaMmSI/vzzTwUFBWnDhg0qX768sU9sbKwuXrxo/Hz58mWFhYXp7NmzKlasmNq3b6+JEyfKysoqV/Xkd1B2d6/Z0qVLKyAgQL///rumTZt2z+cF8GT6+78/DAaDSdvdECq/AufU1FRZWFgoOjpaFhYWJuccHBzy5R4wD4IpAAAA4AnTpEkTZWVl5Xh+1KhRGjVqVI7n4+PjTT537NhRHTt2fOh68jsomzlzpt5//3317dtXycnJ8vT01Ntvv60xY8Y8dI0Anlz+/v5avny5srKyjIHVtm3b5OjoqFKlSqlYsWKysrLSzp07Vbp0aUnSpUuXdOzYMTVo0ECSVK1aNWVkZCg5OVkvvfSS2Z4F+Y9gCgAAAMB95XdQlpu9ZgE8O/r27avp06drwIAB6t+/v2JiYjR27FgNHTpUhQoVkoODg3r27KkRI0bIxcVFxYsX17/+9S+TJb8VK1ZUaGiounbtqk8//VTVqlXThQsXFBERocDAQJNlxrm1b98+SXdmY124cEH79u2TtbV1tn3zULAIpgAAAAAAeII8a3vElixZUmvWrNGIESMUFBSkYsWKqWfPnsbN0yXp448/Vmpqqlq3bi1HR0cNGzZMly9fNhknPDxcEyZM0LBhw5SQkCBXV1fVrl1brVq1eqi6qlWrZvw5OjpaS5Yskbe3d7YwHQXLkHW/v/p4Bly5ckXOzs66fPmynJyczF0OngNP4ubniRVTzF1CNuwxBQAAgOfdzZs3dfLkSZUtW1a2trbmLgfIk/v9+c1LFlPovmcBAAAAAACAAkIwBQAAAAAAnikBAQFycHC45/HNN9+Yuzz8BXtMAQAAAGbyJG4B8KztbQPg+bRmzRqlp6ff85y7u/tjrgb3QzAFAAAAwGjq6KPmLiEb9qYEkFfe3t7mLgG5xFI+AAAAAAAAmAXBFAAAAAAAAMyCYAoAAAAAAABmQTAFAAAAAAAAsyCYAgAAAAAAgCTp1q1bmjRpkv73v/89lvsRTAEAAAAAgCdOSEiIBg8enOv+CxYsUJEiRQqsnqdJfHy8DAaD9u3bl+drhw0bpoMHD8rP7/G8EdXysdwFAAAAAADkytTRRx/r/UZOeDwBxJMkMTFRw4YN0549e3TixAkNHDhQ06dPN3dZD+XNN99USkqKVq1aZWzz8vJSYmKiXF1d8zTWsmXLdPjwYa1bt04GgyGfK703ZkwBAAAAAIDnSlpamtzc3DR69GgFBQWZu5x8Z2FhIQ8PD1la5m0+UseOHbVp0yZZW1sXUGXZEUwBAAAAAIBcCwkJ0YABAzR48GAVLVpU7u7umjdvnq5du6bu3bvL0dFRFSpU0Nq1a43XREZG6oUXXpCNjY1KlCihUaNG6fbt28bz165dU9euXeXg4KASJUro008/zXbftLQ0DR8+XCVLllThwoUVHByszZs3P9QzlClTRjNmzFDXrl3l7Oyc5+szMjI0dOhQFSlSRC4uLnr33XfVrVs3tWnTxuQef5+FVbVqVY0bN874edq0aapSpYoKFy4sLy8v9e3bV6mpqcbzd5cnrl+/Xv7+/nJwcFCzZs2UmJgoSRo3bpwWLlyoH3/8UQaDQQaDQZs3b862lO/NN980nv/rcff7y8/vNq8IpgAAAAAAQJ4sXLhQrq6u2rVrlwYMGKA+ffqoQ4cOqlu3rvbu3asmTZqoS5cuun79uhISEtSiRQvVqlVL+/fv15w5czR//nxNmDDBON6IESMUGRmpH3/8Ub/88os2b96svXv3mtyzf//+2rFjh5YuXaoDBw6oQ4cOatasmY4fP/64H1+ffvqpFixYoK+//lpbt27Vn3/+qZUrV+Z5nEKFCunzzz/X4cOHtXDhQm3atEnvvvuuSZ/r16/rk08+0X/+8x/99ttvOn36tIYPHy5JGj58uDp27GgMqxITE1W3bt1s95kxY4bxfGJiogYNGqTixYsb95Ey53fLHlMAAAAAACBPgoKCNHr0aElSWFiYpkyZIldXV/Xq1UuSNGbMGM2ZM0cHDhzQTz/9JC8vL82aNUsGg0F+fn46d+6cRo4cqTFjxuj69euaP3++Fi9erIYNG0q6E3yVKlXKeL/Tp08rPDxcp0+flqenp6Q7ocy6desUHh6uSZMmPdbnnz59usLCwtSuXTtJ0ty5c7V+/fo8j/PXzd3LlCmjCRMm6J133tEXX3xhbE9PT9fcuXNVvnx5SXdCpPHjx0uSHBwcZGdnp7S0NHl4eOR4H2dnZ+PMsBUrVujLL7/Uxo0b5eHhYfbvlmAKAAAAAADkSWBgoPFnCwsLubi4qEqVKsY2d3d3SVJycrL+97//qU6dOiabaderV0+pqak6e/asLl26pFu3bik4ONh4vlixYvL19TV+PnjwoDIyMlSxYkWTOtLS0uTi4pLvz3c/ly9fVmJiokm9lpaWqlmzprKysvI01saNGzV58mQdPXpUV65c0e3bt3Xz5k1dv35d9vb2kiR7e3tjKCVJJUqUUHJy8kPV/vvvv6tLly6aNWuW6tWrJ8n83y3BFAAAAAAAyBMrKyuTzwaDwaTtbgiVmZmZL/dLTU2VhYWFoqOjZWFhYXLOwcEhX+6R3woVKpQtqEpPTzf+HB8fr1atWqlPnz6aOHGiihUrpq1bt6pnz566deuWMZi613ed1wBMkpKSkvTqq6/qrbfeUs+ePY3t5v5uCaYAAAAAAECB8ff31/Lly5WVlWUMrLZt2yZHR0eVKlVKxYoVk5WVlXbu3KnSpUtLki5duqRjx46pQYMGkqRq1aopIyNDycnJeumll8z2LNKdZXElSpTQzp07Vb9+fUnS7du3FR0drerVqxv7ubm5GTcpl6QrV67o5MmTxs/R0dHKzMzUp59+qkKF7mwBvmzZsjzXY21trYyMjPv2uXnzpl577TX5+flp2rRpJufM/d0STAEAAAAAgALTt29fTZ8+XQMGDFD//v0VExOjsWPHaujQoSpUqJAcHBzUs2dPjRgxQi4uLipevLj+9a9/GcMaSapYsaJCQ0PVtWtXffrpp6pWrZouXLigiIgIBQYGqmXLlnmu6+4b61JTU3XhwgXt27dP1tbWqlSp0gOvHTRokKZMmSIfHx9j2JOSkmLS55VXXtGCBQvUunVrFSlSRGPGjDGZkVShQgWlp6dr5syZat26tbZt26a5c+fm+TnKlCmj9evXKyYmRi4uLvd8y+Dbb7+tM2fOKCIiQhcuXDC2FytWrEC+27wgmAIAAAAA4AkycoKfuUvIVyVLltSaNWs0YsQIBQUFqVixYurZs6dx83RJ+vjjj5WamqrWrVvL0dFRw4YN0+XLl03GCQ8P14QJEzRs2DAlJCTI1dVVtWvXVqtWrR6qrmrVqhl/jo6O1pIlS+Tt7a34+PgHXjts2DAlJiaqW7duKlSokHr06KG2bdua1BwWFqaTJ0+qVatWcnZ21ocffmgyYyooKEjTpk3T1KlTFRYWpvr162vy5Mnq2rVrnp6jV69e2rx5s2rWrKnU1FT9+uuvKlOmjEmfyMhIJSYmZgvdfv31V4WEhOT7d5sXhqyHWZj4FLly5YqcnZ11+fJlOTk5mbscPAcWdUwydwnZJFZMMXcJ2Txr/7EFAOBh8HtD7vB7A55VN2/e1MmTJ1W2bFnZ2tqauxw8ojfffFMpKSlatWqVuUt5LO735zcvWUyh+54FAAAAAAAACgjBFAAAAAAAeKYEBATIwcHhnsc333zzwOtzutbBwUFbtmx5DE/w/GCPKQAAAAAA8ExZs2aN0tPT73nO3d39gdff3Rj9XkqWLHnP9gULFuSmNPwNwRQAAAAAAHimeHt7P9L1FSpUyKdK8CAs5QMAAAAAwIye8XeS4RmVX39uCaYAAAAAADADCwsLSdKtW7fMXAmQd9evX5ckWVlZPdI4LOUDAAAAADxzEhISNHLkSK1du1bXr19XhQoVFB4erpo1a0qSUlNTNWrUKK1atUp//PGHypYtq4EDB+qdd96577jTp0/XnDlzdPr0abm6uuof//iHJk+eLFtb2zzXaGlpKXt7e124cEFWVlYqVIi5I3jyZWVl6fr160pOTlaRIkWMAevDIpgCAAAAADxTLl26pHr16unll1/W2rVr5ebmpuPHj6to0aLGPkOHDtWmTZu0ePFilSlTRr/88ov69u0rT09Pvfrqq/ccd8mSJRo1apS+/vpr1a1bV8eOHdObb74pg8GgadOmPbCunMIyR0dHnTp1SpmZmUpJSdH169eVmZkpS0tLOTo6ytHRMccxU1NT9ccff5i0GQwGlS5dOpffFvBwihQpIg8Pj0ceh2AKAAAAAPBMmTp1qry8vBQeHm5sK1u2rEmf7du3q1u3bgoJCZEk9e7dW19++aV27dqVYzC1fft21atXT507d5YklSlTRp06ddLOnTsfWNP9wrKyZcvq1q1bGjNmjKKiojRhwgSVLFlSW7du1fjx4zVz5ky98sor9xx35cqVmjhxotauXWtsMxgMcnV1fWBNwMOysrJ65JlSdxFMAQAAAACeKatXr1bTpk3VoUMHRUZGqmTJkurbt6969epl7FO3bl2tXr1aPXr0kKenpzZv3qxjx47ps88+y3HcunXravHixdq1a5deeOEFxcXFac2aNerSpcsDa3pQWGZra6s1a9bon//8p+rXry9JKl++vD7//HNt375dLVq0uOe4aWlpOnv2rLy8vB5YA/AkYgErAAAAAOCZEhcXpzlz5sjHx0fr169Xnz59NHDgQC1cuNDYZ+bMmapUqZJKlSola2trNWvWTLNnzzaGQvfSuXNnjR8/Xi+++KKsrKxUvnx5hYSE6L333ntgTatXr1bNmjXVoUMHFS9eXNWqVdO8efNM+twNyxISEpSVlaVff/1Vx44dU5MmTe47dmpqqry9veXl5aXXXntNhw8ffmA9wJOCYAoAAAAA8EzJzMxU9erVNWnSJFWrVk29e/dWr169NHfuXGOfmTNnKioqSqtXr1Z0dLQ+/fRT9evXTxs3bsxx3M2bN2vSpEn64osvtHfvXq1YsUI///yzPvzwwwfWVFBhma+vr77++mv9+OOPWrx4sTIzM1W3bl2dPXs2l98WYF5mDabKlCkjg8GQ7ejXr58k6ebNm+rXr59cXFzk4OCg9u3b6/z58+Ys+YmUkJCgN954Qy4uLrKzs1OVKlW0Z88e4/l7fccGg0Eff/xxjmOOGzcuW38/P7/H8TgAAAAA8EhKlCihSpUqmbT5+/vr9OnTkqQbN27ovffe07Rp09S6dWsFBgaqf//++uc//6lPPvkkx3Hff/99denSRW+99ZaqVKmitm3batKkSZo8ebIyMzPvW1NBhWV16tRR165dVbVqVTVo0EArVqyQm5ubvvzyy9x8VYDZmXWPqd27dysjI8P4+dChQ2rcuLE6dOggSRoyZIh+/vlnff/993J2dlb//v3Vrl07bdu2zVwlP3Fy87aJxMREk2vWrl2rnj17qn379vcdOyAgwORfgJaWbEkGAAAA4MlXr149xcTEmLQdO3ZM3t7ekqT09HSlp6erUCHTuRoWFhb3DZiuX79+z2skKSsr67415RSWLV++XNL/hWUrV65Uy5YtJUmBgYHat2+fPvnkEzVq1Oi+499lZWWlatWq6cSJE7nqD5ibWZMGNzc3k89TpkxR+fLl1aBBA12+fFnz58/XkiVLjG8fCA8Pl7+/v6KiolS7dm1zlPzEyc3bJv7++sYff/xRL7/8ssqVK3ffsS0tLfPl1Y8AAAAA8DgNGTJEdevW1aRJk9SxY0ft2rVLX331lb766itJkpOTkxo0aKARI0bIzs5O3t7eioyM1KJFizRt2jTjOF27dlXJkiU1efJkSVLr1q01bdo0VatWTcHBwTpx4oTef/99tW7d+oFvKCuosOzvMjIydPDgwRw3SweeNE/MHlO3bt3S4sWL1aNHDxkMBkVHRys9Pd0kFfbz81Pp0qW1Y8eOHMdJS0vTlStXTI5nWW420Pur8+fP6+eff1bPnj0fOPbx48fl6empcuXKKTQ01DjtNTcKYnmhJM2ePVtlypSRra2tgoODtWvXrlzXBAAAAOD5UKtWLa1cuVLffvutKleurA8//FDTp09XaGiosc/SpUtVq1YthYaGqlKlSpoyZYomTpyod955x9jn9OnTJitQRo8erWHDhmn06NGqVKmSevbsqaZNm+Zq2dyQIUMUFRWlSZMm6cSJE1qyZIm++uor41Y2fw3LNm/erJMnT2rBggVatGiR2rZtaxyna9euCgsLM34eP368fvnlF8XFxWnv3r164403dOrUKb311luP9B0Cj8sTszZr1apVSklJ0ZtvvilJSkpKkrW1tYoUKWLSz93dXUlJSTmOM3nyZH3wwQcFWOmT5e4GekOHDtV7772n3bt3a+DAgbK2tla3bt2y9V+4cKEcHR3Vrl27+44bHBysBQsWyNfXV4mJifrggw/00ksv6dChQ3J0dLzvtQW1vPC7777T0KFDNXfuXAUHB2v69Olq2rSpYmJiVLx48fvWBAAAAOD50qpVK7Vq1SrH8x4eHiYrT+5l8+bNJp8tLS01duxYjR07Ns/13A3LwsLCNH78eJUtW/aeYVlYWJhCQ0P1559/ytvb+55h2V9nVV26dEm9evVSUlKSihYtqho1amj79u3Zlg0CTypD1oMWwj4mTZs2lbW1tX766SdJ0pIlS9S9e3elpaWZ9HvhhRf08ssva+rUqfccJy0tzeSaK1euyMvLS5cvX5aTk1PBPYCZWFtbq2bNmtq+fbuxbeDAgdq9e/c9Z5b5+fmpcePGmjlzZp7uk5KSIm9vb02bNu2Bs61GjRqlbdu2acuWLbkev02bNrp69aoiIiJy7BMcHKxatWpp1qxZku5sHujl5aUBAwZo1KhRub5XQVvUMefg1FwSK6aYu4RsRk5gM30AAPi9IXf4vQEAni5XrlyRs7NzrrKYJ2Ip36lTp7Rx40aTqYYeHh66deuWUlJSTPqeP3/+vvse2djYyMnJyeR4lj3obRN/tWXLFsXExDzUlM4iRYqoYsWKudpAryCWF966dUvR0dEmSzsLFSqkRo0a3XdpJwAAAAAAeHI9EcFUeHi4ihcvbnzzgCTVqFFDVlZWJjNoYmJidPr0adWpU8ccZT6RHrSB3l/Nnz9fNWrUUFBQUJ7vk5qaqtjYWJUoUeKBfe8uL/Tx8dH69evVp08fDRw4UAsXLrxn/9wsL7x48aIyMjLk7u5u0v6gpZ0AAAAAAODJZfZgKjMzU+Hh4erWrZssLf9vyytnZ2f17NlTQ4cO1a+//qro6Gh1795dderU4Y18f/GgDfTuunLlir7//vscZ0s1bNjQuEROkoYPH67IyEjFx8dr+/btatu2rSwsLNSpU6cH1pSZmanq1atr0qRJqlatmnr37q1evXpp7ty59+z/9ddfKzQ0VLa2tnl4cgAAAAAA8LQz++bnGzdu1OnTp9WjR49s5z777DMVKlRI7du3V1pampo2baovvvjCDFU+uXKzgZ50ZxO9rKysHIOl2NhYXbx40fj57Nmz6tSpk/744w+5ubnpxRdfVFRUlNzc3B5YU07LC5cvX56t793lhd999919x3R1dZWFhYXOnz9v0v6gpZ0AAAAAAODJZfZgqkmTJspp/3VbW1vNnj1bs2fPfsxVPV0e9LYJSerdu7d69+6d4/n4+HiTz0uXLn3oegpieaG1tbVq1KihiIgItWnTRtKdmVkRERHq37//Q9cKAAAA4On3JL5IoOsy/gIdyA2zL+XDs6eglhcOHTpU8+bN08KFC/W///1Pffr00bVr19S9e/cCfR4AAAAAAFAwzD5jCs+eglpe+M9//lMXLlzQmDFjlJSUpKpVq2rdunXZNkQHAAAAAHObOvqouUvIZuQEP3OXAGRDMIUCURDLCyWpf//+LN0DAAAAAOAZwVI+AAAAAAAAmAXBFAAAAAAAAMyCYAoAAAAAAEBSQkKC3njjDbm4uMjOzk5VqlTRnj177tn3nXfekcFg0PTp03M9/pQpU2QwGDR48OD8KfgZwB5TTxlegwoAAAAAQP67dOmS6tWrp5dffllr166Vm5ubjh8/rqJFi2bru3LlSkVFRcnT0zPX4+/evVtffvmlAgMD87Pspx4zpgAAAAAAwGNXULOTZs+erTJlysjW1lbBwcHatWtXruqZOnWqvLy8FB4erhdeeEFly5ZVkyZNVL58+Wx1DxgwQN98842srKxyNXZqaqpCQ0M1b968ewZdzzNmTOGR8RpUAAAAAEBeFNTspO+++05Dhw7V3LlzFRwcrOnTp6tp06aKiYlR8eLF73vt6tWr1bRpU3Xo0EGRkZEqWbKk+vbtq169ehn7ZGZmqkuXLhoxYoQCAgJy/bz9+vVTy5Yt1ahRI02YMCHX1z0PmDEFAAAAAAAeq4KanTRt2jT16tVL3bt3V6VKlTR37lzZ29vr66+/fuC1cXFxmjNnjnx8fLR+/Xr16dNHAwcO1MKFC03qtrS01MCBA3P9rEuXLtXevXs1efLkXF/zPCGYAgAAAAAAj9Xq1atVs2ZNdejQQcWLF1e1atU0b948kz55nZ1069YtRUdHq1GjRsa2QoUKqVGjRtqxY8cDr8/MzFT16tU1adIkVatWTb1791avXr00d+5cSVJ0dLRmzJihBQsWyGAw5Oo5z5w5o0GDBumbb76Rra1trq553hBMAQAAAACAx6ogZiddvHhRGRkZcnd3N2l3d3dXUtKDXyRWokQJVapUyaTN399fp0+fliRt2bJFycnJKl26tCwtLWVpaalTp05p2LBhKlOmzD3HjI6OVnJysqpXr268JjIyUp9//rksLS2VkZGRq2d7lrHHFAAAAAAAeKwyMzNVs2ZNTZo0SZJUrVo1HTp0SHPnzlW3bt2Ms5P27t2b69lJj6pevXqKiYkxaTt27Ji8vb0lSV26dDGZjSVJTZs2VZcuXdS9e/d7jtmwYUMdPHjQpK179+7y8/PTyJEjZWFhkY9P8HQimAIAAAAAAI9VTrOTli9fLsl0dtJdGRkZGjZsmKZPn674+PhsY7q6usrCwkLnz583aT9//rw8PDweWNOQIUNUt25dTZo0SR07dtSuXbv01Vdf6auvvpIkubi4yMXFxeQaKysreXh4yNfX19jWsGFDtW3bVv3795ejo6MqV65sck3hwoXl4uKSrf15xVI+AAAAAADwWOVmdtKBAwe0b98+4+Hp6akRI0Zo/fr19xzT2tpaNWrUUEREhLEtMzNTERERqlOnzgNrqlWrllauXKlvv/1WlStX1ocffqjp06crNDQ0T88WGxurixcv5uma5xkzpgAAAAAAwGNVELOTJGno0KHq1q2batasqRdeeEHTp0/XtWvXclxq93etWrVSq1atcv0c95q5da+2v9q8eXOux38eEEwBAAAAAIDH6u7spLCwMI0fP15ly5bNl9lJ//znP3XhwgWNGTNGSUlJqlq1qtatW5dtQ3Q8OQimAAAAAADAY1dQs5P69+9vnEGFJx97TAEAAAAAAMAsCKYAAAAAAABgFgRTAAAAAAAAMAv2mAIAAAAAAM+dqaOPmruEbEZO8DN3CY8dM6YAAAAAAABgFsyYAgAAAAAABWpRxyRzl5BdRXMXAIkZUwAAAAAAADATgikAAAAAAACYBcEUAAAAAAAAzIJgCgAAAAAAAGZBMAUAAAAAAACzIJgCAAAAgDwYN26cDAaDyeHn52c8Hxsbq7Zt28rNzU1OTk7q2LGjzp8//0hjAsCzimAKAAAAAPIoICBAiYmJxmPr1q2SpGvXrqlJkyYyGAzatGmTtm3bplu3bql169bKzMx8qDFzoyDCsr+aMmWKDAaDBg8enOtrACA3LM1dAAAAAAA8bSwtLeXh4ZGtfdu2bYqPj9fvv/8uJycnSdLChQtVtGhRbdq0SY0aNcrzmLkVEBCgjRs3mown/V9YFhQUpE2bNkmS3n//fbVu3VpRUVEqVOj+8xV2796tL7/8UoGBgQ9dGwDkhBlTAAAAAJBHx48fl6enp8qVK6fQ0FCdPn1akpSWliaDwSAbGxtjX1tbWxUqVOiBM6ByGjO37gZbdw9XV1dJ/xeWLViwQFWqVFGVKlW0cOFC7dmzxxhU5SQ1NVWhoaGaN2+eihYtmqd6ACA3CKYAAAAAIA+Cg4O1YMECrVu3TnPmzNHJkyf10ksv6erVq6pdu7YKFy6skSNH6vr167p27ZqGDx+ujIwMJSYmPtSYuVUQYVm/fv3UsmXL+870AoBHQTAFAAAAAHnQvHlzdejQQYGBgWratKnWrFmjlJQULVu2TG5ubvr+++/1008/ycHBQc7OzkpJSVH16tXvu2TufmPmRkGEZUuXLtXevXs1efLkPH9HAJBb7DEFAAAAAI+gSJEiqlixok6cOCFJatKkiWJjY3Xx4kVZWlqqSJEi8vDwULly5R56zAdp3ry58efAwEAFBwfL29tby5YtU8+ePfX999+rT58++vzzz1WoUCF16tTpvmHZmTNnNGjQIG3YsEG2tra5rhsA8ooZUwAAAADwCFJTUxUbG6sSJUqYtLu6uqpIkSLatGmTkpOT9eqrrz7ymLmVU1iWnJysixcv6j//+Y8SEhJyDMuio6OVnJys6tWry9LSUpaWloqMjNTnn38uS0tLZWRkPFRdAPB3BFMAAAAAkAfDhw9XZGSk4uPjtX37drVt21YWFhbq1KmTJCk8PFxRUVGKjY3V4sWL1aFDBw0ZMkS+vr7GMRo2bKhZs2blesy8etSwrGHDhjp48KD27dtnPGrWrKnQ0FDt27dPFhYWD1UXAPwdS/kAAAAAIA/Onj2rTp066Y8//pCbm5tefPFFRUVFyc3NTZIUExOjsLAw/fnnnypTpoz+9a9/aciQISZj3F3ql9sxH2T48OFq3bq1vL29de7cOY0dOzZbWObv7y83Nzft2LFDgwYNumdY1rZtW/Xv31+Ojo6qXLmyyT0KFy4sFxeXbO0A8CjMHkwlJCRo5MiRWrt2ra5fv64KFSooPDxcNWvWlCRlZWVp7NixmjdvnlJSUlSvXj3NmTNHPj4+Zq4cAAAAwPNo6dKl9z0/ZcoUTZky5b594uPj8zTmgxREWAYAj4NZg6lLly6pXr16evnll7V27Vq5ubnp+PHjKlq0qLHPRx99pM8//1wLFy5U2bJl9f7776tp06Y6cuQIm/ABAAAAgAomLPu7zZs357EqAHgwswZTU6dOlZeXl8LDw41tZcuWNf6clZWl6dOna/To0XrttdckSYsWLZK7u7tWrVql119//bHXDAAAAAAAgPxh1s3PV69erZo1a6pDhw4qXry4qlWrpnnz5hnPnzx5UklJSWrUqJGxzdnZWcHBwdqxY8c9x0xLS9OVK1dMDgAAAAAAADx5zBpMxcXFGfeLWr9+vfr06aOBAwdq4cKFkqSkpCRJkru7u8l17u7uxnN/N3nyZDk7OxsPLy+vgn0IAAAAAAAAPBSzBlOZmZmqXr26Jk2apGrVqql3797q1auX5s6d+9BjhoWF6fLly8bjzJkz+VgxAAAAAAAA8otZg6kSJUqoUqVKJm3+/v46ffq0JMnDw0OSdP78eZM+58+fN577OxsbGzk5OZkcAACg4I0bN04Gg8Hk8PPzM+mzY8cOvfLKKypcuLCcnJxUv3593bhxI8cx58yZo8DAQON/0+vUqaO1a9cW9KMAAADgMTHr5uf16tVTTEyMSduxY8fk7e0t6c5G6B4eHoqIiFDVqlUlSVeuXNHOnTvVp0+fx10uAAB4gICAAG3cuNH42dLy/37V2LFjh5o1a6awsDDNnDlTlpaW2r9/vwoVyvnvyUqVKqUpU6bIx8dHWVlZWrhwoV577TX9/vvvCggIKNBnAYC7FnW89zYi5pRYMcXcJZgYOcHvwZ0A4B7MOmNqyJAhioqK0qRJk3TixAktWbJEX331lfr16ydJMhgMGjx4sCZMmKDVq1fr4MGD6tq1qzw9PdWmTRtzlg4AAO7B0tJSHh4exsPV1dV4bsiQIRo4cKBGjRqlgIAA+fr6qmPHjrKxsclxvNatW6tFixby8fFRxYoVNXHiRDk4OCgqKipX9RTELC5Jmj17tsqUKSNbW1sFBwdr165duaoHAAAApswaTNWqVUsrV67Ut99+q8qVK+vDDz/U9OnTFRoaauzz7rvvasCAAerdu7dq1aql1NRUrVu3Tra2tmasHADwuD0oYAgJCcl2/p133rnvmH/vf/f4+OOPzVZTamqq+vfvr1KlSsnOzk6VKlV6pL0XH7fjx4/L09NT5cqVU2hoqHF5fnJysnbu3KnixYurbt26cnd3V4MGDbR169Zcj52RkaGlS5fq2rVrqlOnTq6vCwgIUGJiovH46z3vzuJq0qSJdu3apd27d6t///73ncX13XffaejQoRo7dqz27t2roKAgNW3aVMnJybmuCQAAAHeYdSmfJLVq1UqtWrXK8bzBYND48eM1fvz4x1gVAOBJdL9lYpLUq1cvk/9e2Nvb33e8xMREk89r165Vz5491b59e7PVNHToUG3atEmLFy9WmTJl9Msvv6hv377y9PTUq6++muu6zCE4OFgLFiyQr6+vEhMT9cEHH+ill17SoUOHFBcXJ+lOmPfJJ5+oatWqWrRokRo2bKhDhw7Jx8cnx3EPHjyoOnXq6ObNm3JwcNDKlSuz7VF5P3dncd3LX2dx3eXr63vf8aZNm6ZevXqpe/fukqS5c+fq559/1tdff20yDgAAAB7M7MEUAAC5db+AQboT+tzv/N/9ve+PP/6ol19+WeXKlTNbTdu3b1e3bt0UEhIiSerdu7e+/PJL7dq164kPppo3b278OTAwUMHBwfL29tayZcvk7+8vSXr77beNgU61atUUERGhr7/+WpMnT85xXF9fX+3bt0+XL1/WDz/8oG7duikyMjLX4dTdWVy2traqU6eOJk+erNKlSxtncYWGhqpu3bqKjY2Vn5+fJk6cqBdffPGeY926dUvR0dEKCwszthUqVEiNGjXSjh07clUPAAAA/o9Zl/IBAJAXOS0Tu+ubb76Rq6urKleurLCwMF2/fj3XY58/f14///yzevbsadaa6tatq9WrVyshIUFZWVn69ddfdezYMTVp0iRPdT0JihQpoooVK+rEiRMqUaKEJN33bbw5sba2VoUKFVSjRg1NnjxZQUFBmjFjRq5quDuLa926dZozZ45Onjypl156SVevXjWZxdWrVy+tW7dO1atXV8OGDXX8+PF7jnfx4kVlZGTI3d3dpN3d3V1JSU/e5sgAAABPOmZMAQCeCvdbJubo6KjOnTvL29tbnp6eOnDggEaOHKmYmBitWLEiV+MvXLhQjo6OateunVlrmjlzpnr37q1SpUrJ0tJShQoV0rx581S/fv1c1/WkSE1NVWxsrLp06aIyZcrI09Pznm/j/etMq9zIzMxUWlparvoW1CwuAAAA5A+CKQDAU+F+AUPPnj3Vu3dv4/kqVaqoRIkSatiwoWJjY1W+fPkHjv/1118rNDQ0Ty/XKIiaZs6cqaioKK1evVre3t767bff1K9fP3l6eqpRo0a5rs0chg8frtatW8vb21vnzp3T2LFjZWFhoU6dOslgMGjEiBEaO3asgoKCVLVqVS1cuFBHjx7VDz/8YByjYcOGatu2rfr37y9JCgsLU/PmzVW6dGldvXpVS5Ys0ebNm7V+/fqHqvGvs7heeeUVSXmbxeXq6ioLCwudP3/epP38+fN5WrIJAACAOwimAABPpb8GDPcSHBwsSTpx4sQDg6ktW7YoJiZG3333nVlrunHjht577z2tXLlSLVu2lHQn8Nq3b58++eSTJz6YOnv2rDp16qQ//vhDbm5uevHFFxUVFSU3NzdJ0uDBg3Xz5k0NGTJEf/75p4KCgrRhwwaT7yI2NlYXL140fk5OTlbXrl2VmJgoZ2dnBQYGav369WrcuPFD1fios7isra1Vo0YNRUREqE2bNpLuzOCKiIgwhmkAAADIPYIpAMBT6a8Bw73s27dPkox7G93P/PnzVaNGDQUFBZm1pvT0dKWnp6tQIdMtIC0sLJSZmflItT0OS5cufWCfUaNG3ffNdfHx8Saf58+f/0g1FcQsrqFDh6pbt26qWbOmXnjhBU2fPl3Xrl0zLgcEAABA7hFMAQCeCvcLGGJjY7VkyRK1aNFCLi4uOnDggIYMGaL69esrMDDQOIafn58mT56stm3bGtuuXLmi77//Xp9++qnZa3JyclKDBg00YsQI2dnZydvbW5GRkVq0aJGmTZv2aF/gc6ogZnH985//1IULFzRmzBglJSWpatWqWrduXbYN0QEAAPBgBFMAgKfC/QKGmzdvauPGjcaZK15eXmrfvr1Gjx5tMkZMTIwuX75s0rZ06VJlZWWpU6dOT0RNS5cuVVhYmEJDQ/Xnn3/K29tbEydO1DvvvJPn+lAws7gkqX///izdAwAAyAcEUwCAp8L9AgYvLy9FRkY+cIysrKxsbb179zbZpNzcNXl4eCg8PPyh6gEAAACeNoUe3AUAAAAAAADIfwRTAAAAAAAAMAuCKQAAAAAAAJgFe0wBAICHsqhjkrlLyKbrMg9zlwAAAIA8IJgCAADPjKmjj5q7hGxGTvAzdwkAAABPLIIpAABy6UkLPQg8AAAA8LQjmAIAPJGexGViqmjuAgAAAIBnC5ufAwAAAAAAwCwIpgAAAAAAAGAWBFMAAAAAAAAwC4IpAAAAAAAAmAXBFAAAAAAAAMyCYAoAAAAAAABmQTAFAAAAAAAAsyCYAgAAAAAAgFkQTAEAAAAAAMAsCKYAAAAAAABgFgRTAAAAAAAAMAuCKQAAAAAAAJgFwRQAAAAAAADMgmAKAAAAAAAAZkEwBQAAAAAAALMgmAIAAAAAAIBZEEwBAAAAAADALAimAAAAAAAAYBYEUwAAAAAAADALgikAAAAAAACYBcEUAAAAAAAAzIJgCgAAAAAAAGZBMAUAAAAAAACzIJgCAAAAAACAWZg1mBo3bpwMBoPJ4efnZzx/8+ZN9evXTy4uLnJwcFD79u11/vx5M1YMAAAAAACA/GL2GVMBAQFKTEw0Hlu3bjWeGzJkiH766Sd9//33ioyM1Llz59SuXTszVgsAAAAAAID8Ymn2Aiwt5eHhka398uXLmj9/vpYsWaJXXnlFkhQeHi5/f39FRUWpdu3a9xwvLS1NaWlpxs9XrlwpmMIBAAAAAADwSMw+Y+r48ePy9PRUuXLlFBoaqtOnT0uSoqOjlZ6erkaNGhn7+vn5qXTp0tqxY0eO402ePFnOzs7Gw8vLq8CfAQAAAAAAAHn3SMHUX2cmPYzg4GAtWLBA69at05w5c3Ty5Em99NJLunr1qpKSkmRtba0iRYqYXOPu7q6kpKQcxwwLC9Ply5eNx5kzZx6pRgAAAAAAABSMPC3lW7t2rZYuXaotW7bozJkzyszMVOHChVWtWjU1adJE3bt3l6enZ67Ha968ufHnwMBABQcHy9vbW8uWLZOdnV1eSjOysbGRjY3NQ10LAAAAAACAxydXM6ZWrlypihUrqkePHrK0tNTIkSO1YsUKrV+/Xv/+97/VoEEDbdy4UeXKldM777yjCxcuPFQxRYoUUcWKFXXixAl5eHjo1q1bSklJMelz/vz5e+5JBQAAgLyZMmWKDAaDBg8ebNK+Y8cOvfLKKypcuLCcnJxUv3593bhxI8dx5syZo8DAQDk5OcnJyUl16tTR2rVrn5maAABAwcnVjKmPPvpIn332mZo3b65ChbJnWR07dpQkJSQkaObMmVq8eLGGDBmS52JSU1MVGxurLl26qEaNGrKyslJERITat28vSYqJidHp06dVp06dPI8NAACA/7N79259+eWXCgwMNGnfsWOHmjVrprCwMM2cOVOWlpbav3//PX8HvKtUqVKaMmWKfHx8lJWVpYULF+q1117T77//roCAgKe6JgAAULByFUzdb7PxvypZsqSmTJmS65sPHz5crVu3lre3t86dO6exY8fKwsJCnTp1krOzs3r27KmhQ4eqWLFicnJy0oABA1SnTp0c38gHAACAB0tNTVVoaKjmzZunCRMmmJwbMmSIBg4cqFGjRhnbfH197zte69atTT5PnDhRc+bMUVRUVK5DoCexJgAAUPAe+a18165d05UrVx7q2rNnz6pTp07y9fVVx44d5eLioqioKLm5uUmSPvvsM7Vq1Urt27dX/fr15eHhoRUrVjxqyQAAAM+1fv36qWXLliZvP5ak5ORk7dy5U8WLF1fdunXl7u6uBg0aaOvWrbkeOyMjQ0uXLtW1a9fyNMv9SawJAAAUvDxtfv5XR44cUdeuXbV3714ZDAZVqlRJ4eHhqlmzZq7HWLp06X3P29raavbs2Zo9e/bDlgkAAIC/WLp0qfbu3avdu3dnOxcXFydJGjdunD755BNVrVpVixYtUsOGDXXo0CH5+PjkOO7BgwdVp04d3bx5Uw4ODlq5cqUqVar01NYEAAAej4eeMfX222+rf//+Sk1N1R9//KF27dqpW7du+VkbAAAA8tGZM2c0aNAgffPNN7K1tc12PjMzU9Kd3/O6d++uatWq6bPPPpOvr6++/vrr+47t6+urffv2aefOnerTp4+6deumI0eOPJU1AQCAxyfXwdRrr72mhIQE4+cLFy7o1Vdflb29vYoUKaIWLVro/PnzBVIkAAAAHl10dLSSk5NVvXp1WVpaytLSUpGRkfr8889laWkpd3d3Sco2q8jf31+nT5++79jW1taqUKGCatSoocmTJysoKEgzZsx4KmsCAACPT66X8r3xxht65ZVX1K9fPw0YMED9+/dXQECAGjRooPT0dG3atEnDhg0ryFoBAADwCBo2bKiDBw+atHXv3l1+fn4aOXKkypUrJ09PT8XExJj0OXbsmJo3b56ne2VmZiotLe2prAkAADw+uQ6mOnTooCZNmmjkyJGqXbu25s6dq19++UWbN29WRkaGRo0apVq1ahVkrQAAAHgEjo6Oqly5sklb4cKF5eLiYmwfMWKExo4dq6CgIFWtWlULFy7U0aNH9cMPPxivadiwodq2bav+/ftLksLCwtS8eXOVLl1aV69e1ZIlS7R582atX7/+qawJAAA8Pnna/NzZ2Vlz587V1q1b1a1bNzVu3Fgffvih7O3tC6o+AAAAPEaDBw/WzZs3NWTIEP35558KCgrShg0bVL58eWOf2NhYXbx40fg5OTlZXbt2VWJiopydnRUYGKj169ercePGz2xNAAAgf+QpmPrzzz918uRJValSRdHR0Zo0aZJxA8oWLVoUVI0AAAAoIJs3b87WNmrUKI0aNSrHa+Lj400+z58//5mvCQAAFIxcb36+ZMkSlSpVSi1btpS3t7fWrl2rsWPH6scff9RHH32kjh07svk5AAAAAAAAci3XwVRYWJi+/vprJSUlKSIiQu+//74kyc/PT5s3b1bjxo1Vp06dAisUAAAAAAAAz5ZcB1Opqany9fWVJJUvX17Xr183Od+rVy9FRUXlb3UAAAAAAAB4ZuV6j6lu3bqpZcuWCgkJ0Z49e9SlS5dsfYoXL56vxQEAAAAAAODZletgatq0aXr55Zd19OhRvfnmm2rSpElB1gUAAAAAAIBnXJ7eyte6dWu1bt26oGoBAABAPlrUMcncJWSTWDHF3CVkM3KCn7lLAADguZWrPaaWLl2a6wHPnDmjbdu2PXRBAAAAAAAAeD7kKpiaM2eO/P399dFHH+l///tftvOXL1/WmjVr1LlzZ1WvXl1//PFHvhcKAAAAAACAZ0uulvJFRkZq9erVmjlzpsLCwlS4cGG5u7vL1tZWly5dUlJSklxdXfXmm2/q0KFDcnd3L+i6AQAAAAAA8JTL9R5Tr776ql599VVdvHhRW7du1alTp3Tjxg25urqqWrVqqlatmgoVytUELAAAAAAAACBvm59Lkqurq9q0aVMApQAAAAAAAOB5whQnAAAAAAAAmAXBFAAAAAAAAMyCYAoAAAAAAABmQTAFAAAAAAAAsyCYAgAAAAAAgFnk+a18GRkZWrBggSIiIpScnKzMzEyT85s2bcq34gAAAAAAAPDsynMwNWjQIC1YsEAtW7ZU5cqVZTAYCqIuAAAAAAAAPOPyHEwtXbpUy5YtU4sWLQqiHgAAAAAAADwn8rzHlLW1tSpUqFAQtQAAAAAAAOA5kudgatiwYZoxY4aysrIKoh4AAAAAAAA8J/K8lG/r1q369ddftXbtWgUEBMjKysrk/IoVK/KtOAAAAAAAADy78hxMFSlSRG3bti2IWgAAAAAAAPAcyXMwFR4eXhB1AAAAAAAA4DmT52DqrgsXLigmJkaS5OvrKzc3t3wrCgAAAAAAAM++PG9+fu3aNfXo0UMlSpRQ/fr1Vb9+fXl6eqpnz566fv16QdQIAAAAAACAZ1Ceg6mhQ4cqMjJSP/30k1JSUpSSkqIff/xRkZGRGjZsWEHUCAAAAAAAgGdQnpfyLV++XD/88INCQkKMbS1atJCdnZ06duyoOXPm5Gd9AAAAAAAAeEblecbU9evX5e7unq29ePHiLOUDAAAAAABAruU5mKpTp47Gjh2rmzdvGttu3LihDz74QHXq1MnX4gAAAAAAAPDsyvNSvhkzZqhp06YqVaqUgoKCJEn79++Xra2t1q9fn+8FAgAAAAAA4NmU52CqcuXKOn78uL755hsdPXpUktSpUyeFhobKzs4u3wsEAAAAAADAsynPwZQk2dvbq1evXvldCwAAAAAAAJ4judpjavXq1UpPTzf+fL/jYU2ZMkUGg0GDBw82tt28eVP9+vWTi4uLHBwc1L59e50/f/6h7wEAAAAAAIAnR65mTLVp00ZJSUkqXry42rRpk2M/g8GgjIyMPBexe/duffnllwoMDDRpHzJkiH7++Wd9//33cnZ2Vv/+/dWuXTtt27Ytz/cAAAAAAADAkyVXM6YyMzNVvHhx4885HQ8TSqWmpio0NFTz5s1T0aJFje2XL1/W/PnzNW3aNL3yyiuqUaOGwsPDtX37dkVFReX5PgAAAAAAAHiy5CqYepCUlJSHvrZfv35q2bKlGjVqZNIeHR2t9PR0k3Y/Pz+VLl1aO3bsyHG8tLQ0XblyxeQAAAAAAADAkyfPwdTUqVP13XffGT936NBBxYoVU8mSJbV///48jbV06VLt3btXkydPznYuKSlJ1tbWKlKkiEm7u7u7kpKSchxz8uTJcnZ2Nh5eXl55qgkAAAAAAACPR56Dqblz5xrDng0bNmjjxo1at26dmjdvrhEjRuR6nDNnzmjQoEH65ptvZGtrm9cychQWFqbLly8bjzNnzuTb2AAAAAAAAMg/udr8/K+SkpKMwdR///tfdezYUU2aNFGZMmUUHByc63Gio6OVnJys6tWrG9syMjL022+/adasWVq/fr1u3bqllJQUk1lT58+fl4eHR47j2tjYyMbGJq+PBQAAAAAAgMcszzOmihYtapyFtG7dOuMeUFlZWXna/Lxhw4Y6ePCg9u3bZzxq1qyp0NBQ489WVlaKiIgwXhMTE6PTp0+rTp06eS0bAAAAAAAAT5g8z5hq166dOnfuLB8fH/3xxx9q3ry5JOn3339XhQoVcj2Oo6OjKleubNJWuHBhubi4GNt79uypoUOHqlixYnJyctKAAQNUp04d1a5dO69lAwAAAAAA4AmT5xlTn332mfr3769KlSppw4YNcnBwkCQlJiaqb9+++VrcZ599platWql9+/aqX7++PDw8tGLFiny9BwA8iebMmaPAwEA5OTnJyclJderU0dq1a43nQ0JCZDAYTI533nnngeP+73//06uvvipnZ2cVLlxYtWrV0unTpwvyUQAAAAAgR3meMWVlZaXhw4dnax8yZMgjF7N582aTz7a2tpo9e7Zmz579yGMDwNOkVKlSmjJlinx8fJSVlaWFCxfqtdde0++//66AgABJUq9evTR+/HjjNfb29vcdMzY2Vi+++KJ69uypDz74QE5OTjp8+HC+voACAAAAAPIiV8HU6tWr1bx5c1lZWWn16tX37fvqq6/mS2EA8DjNmTNHc+bMUXx8vCQpICBAY8aMMS5XDgkJUWRkpMk1b7/9tubOnZvjmOPGjdPSpUt15swZWVtbq0aNGpo4cWKuXhTRunVrk88TJ07UnDlzFBUVZQym7O3t7/syiL/717/+pRYtWuijjz4ytpUvXz7X1wMAAABAfstVMNWmTRslJSWpePHiatOmTY79DAZDnjZAB4AnRUHMUKpYsaJmzZqlcuXK6caNG/rss8/UpEkTnThxQm5ubrmuLSMjQ99//72uXbtm8vKHb775RosXL5aHh4dat26t999/P8eaMjMz9fPPP+vdd99V06ZN9fvvv6ts2bIKCwu777/XAQAAAKAg5SqYyszMvOfPAPCsKIgZSp07dzb5PG3aNM2fP18HDhxQw4YNH3j9wYMHVadOHd28eVMODg5auXKlKlWqZBzb29tbnp6eOnDggEaOHKmYmJgc9+FLTk5WamqqpkyZogkTJmjq1Klat26d2rVrp19//VUNGjTI9XMBAAAAQH7J8x5TAPCsy48ZSn9369YtffXVV3J2dlZQUFCurvH19dW+fft0+fJl/fDDD+rWrZsiIyNVqVIl9e7d29ivSpUqKlGihBo2bKjY2Nh7Ls+7+5cKr732mnFPwKpVq2r79u2aO3cuwRQAAAAAs8hzMDVw4EBVqFBBAwcONGmfNWuWTpw4oenTp+dXbQDwWOXnDKW7/vvf/+r111/X9evXVaJECW3YsEGurq65qsfa2loVKlSQJNWoUUO7d+/WjBkz9OWXX2bre3ffqhMnTtwzmHJ1dZWlpaXxee7y9/fX1q1bc1UPAAAAAOS3Qnm9YPny5apXr1629rp16+qHH37Il6IAwBzuzlDauXOn+vTpo27duunIkSOSpN69e6tp06aqUqWKQkNDtWjRIq1cuVKxsbH3HfPll1/Wvn37tH37djVr1kwdO3ZUcnLyQ9WXmZmptLS0e57bt2+fJKlEiRL3PG9tba1atWopJibGpP3YsWPy9vZ+qHoAAAAA4FHlOZj6448/5OzsnK3dyclJFy9ezJeiAMAc7s5QqlGjhiZPnqygoCDNmDHjnn3/OkPpfgoXLqwKFSqodu3amj9/viwtLTV//vwH1hIWFqbffvtN8fHxOnjwoMLCwrR582aFhoYqNjZWH374oaKjoxUfH6/Vq1era9euql+/vgIDA41j+Pn5aeXKlcbPI0aM0Hfffad58+bpxIkTmjVrln766Sf17ds3N18PAAAAAOS7PAdTFSpU0Lp167K1r127VuXKlcuXogDgSfAoM5QeZsy/Sk5OVteuXeXr66uGDRtq9+7dWr9+vRo3bixra2tt3LhRTZo0kZ+fn4YNG6b27dvrp59+MhkjJiZGly9fNn5u27at5s6dq48++khVqlTRv//9by1fvlwvvvhinp4BAAAAAPJLnveYGjp0qPr3768LFy7olVdekSRFRETo008/ZX8pAE+tsLAwNW/eXKVLl9bVq1e1ZMkSbd68WevXr1dsbKyWLFmiFi1ayMXFRQcOHNCQIUPuOUNp8uTJatu2ra5du6aJEyfq1VdfVYkSJXTx4kXNnj1bCQkJ6tChwwPrud+sKi8vL0VGRj5wjKysrGxtPXr0UI8ePR54LQAAAAA8DnkOpnr06KG0tDRNnDhRH374oSSpTJkymjNnjrp27ZrvBQLA43B3hlJiYqKcnZ0VGBhonKF05swZbdy4UdOnT9e1a9fk5eWl9u3ba/To0SZj/HWGkoWFhY4ePaqFCxfq4sWLcnFxUa1atbRlyxYFBASY4xEBAAAA4ImT52BKkvr06aM+ffrowoULsrOzk4ODQ37XBQCPVX7PULK1tX3gG/sAAAAA4HmX5z2mJOn27dvauHGjVqxYYfw/YufOnVNqamq+FgcAAAAAAIBn1wNnTF2/fl329vbGz6dOnVKzZs10+vRppaWlqXHjxnJ0dNTUqVOVlpamuXPnFmjBAAAAAAAAeDY8cMbUZ599pq+++sr4edCgQapZs6YuXbokOzs7Y3vbtm0VERFRMFUCAAAAAADgmfPAGVNvvPGGOnTooLNnz2r8+PHasmWLtm/fLmtra5N+ZcqUUUJCQoEVCgAAAAAAgGfLA4Mpb29vbdmyRUOHDpUkZWZmKiMjI1u/s2fPytHRMf8rBIDnwNTRR81dQjYjJ/iZuwQAAAAAz7hcvZXPxsZGs2fPliQ1adJE06dPNy7vMxgMSk1N1dixY9WiRYuCqxQA8smijknmLiG7iuYuAAAAAAAev1wFU3/1ySefqFmzZqpUqZJu3rypzp076/jx43J1ddW3335bEDUCAAAAAADgGZTnYMrLy0v79+/Xd999p/379ys1NVU9e/ZUaGioyWboAAAAAAAAwP3kKZhKT0+Xn5+f/vvf/yo0NFShoaEFVRcAAAAAAACecYXy0tnKyko3b94sqFoAAAAAAADwHMlTMCVJ/fr109SpU3X79u2CqAcAAAAAAADPiTzvMbV7925FRETol19+UZUqVVS4cGGT8ytWrMi34gAAAAAAAPDsynMwVaRIEbVv374gagEAAAAAAMBzJM/BVHh4eEHUAQAAAAAAgOdMrveYyszM1NSpU1WvXj3VqlVLo0aN0o0bNwqyNgAAAAAAADzDch1MTZw4Ue+9954cHBxUsmRJzZgxQ/369SvI2gAAAAAAAPAMy3UwtWjRIn3xxRdav369Vq1apZ9++knffPONMjMzC7I+AAAAAAAAPKNyHUydPn1aLVq0MH5u1KiRDAaDzp07VyCFAQAAAAAA4NmW62Dq9u3bsrW1NWmzsrJSenp6vhcFAAAAAACAZ1+u38qXlZWlN998UzY2Nsa2mzdv6p133lHhwoWNbStWrMjfCgEAAAAAAPBMynUw1a1bt2xtb7zxRr4WAwAAAAAAgOdHroOp8PDwgqwDAAAAAAAAz5lc7zEFAAAAAAAA5CeCKQAAAAAAAJgFwRQAAAAAAADMgmAKAAAAAAAAZkEwBQAAAAAAALMgmAIAAAAAAIBZmDWYmjNnjgIDA+Xk5CQnJyfVqVNHa9euNZ6/efOm+vXrJxcXFzk4OKh9+/Y6f/68GSsGAAAAAABAfjFrMFWqVClNmTJF0dHR2rNnj1555RW99tprOnz4sCRpyJAh+umnn/T9998rMjJS586dU7t27cxZMgAAAAAAAPKJpTlv3rp1a5PPEydO1Jw5cxQVFaVSpUpp/vz5WrJkiV555RVJUnh4uPz9/RUVFaXatWubo2QAAAAAAADkkydmj6mMjAwtXbpU165dU506dRQdHa309HQ1atTI2MfPz0+lS5fWjh07chwnLS1NV65cMTkAAAAAAADw5DF7MHXw4EE5ODjIxsZG77zzjlauXKlKlSopKSlJ1tbWKlKkiEl/d3d3JSUl5Tje5MmT5ezsbDy8vLwK+AkAAAAAAADwMMweTPn6+mrfvn3auXOn+vTpo27duunIkSMPPV5YWJguX75sPM6cOZOP1QIAAAAAACC/mHWPKUmytrZWhQoVJEk1atTQ7t27NWPGDP3zn//UrVu3lJKSYjJr6vz58/Lw8MhxPBsbG9nY2BR02QAAAAAAAHhEZp8x9XeZmZlKS0tTjRo1ZGVlpYiICOO5mJgYnT59WnXq1DFjhQAAAAAAAMgPZp0xFRYWpubNm6t06dK6evWqlixZos2bN2v9+vVydnZWz549NXToUBUrVkxOTk4aMGCA6tSpwxv5AAAAAAAAngFmDaaSk5PVtWtXJSYmytnZWYGBgVq/fr0aN24sSfrss89UqFAhtW/fXmlpaWratKm++OILc5YMAAAAAACAfGLWYGr+/Pn3PW9ra6vZs2dr9uzZj6kiAAAAAAAAPC5P3B5TAAAAAAAAeD4QTAEAAAAAAMAsCKYAAAAAAABgFgRTAAAAAAAAMAuCKQAAAAAAAJgFwRQAAAAAAADMgmAKAAAAAAAAZkEwBQAAAAAAALMgmAIAAAAAAIBZEEwBAAAAAADALAimAAAAAAAAYBYEUwAAAAAAADALgikAAAAAAACYBcEUAAAAAAAAzIJgCgAAAAAAAGZBMAUAAAAAAACzIJgCAAAAAACAWRBMAQAAAAAAwCwIpgAAAAAAAGAWBFMAAAAAAAAwC4IpAAAAAAAAmAXBFAAAAAAA+H/t3Xd4FXX6/vH7JKQgJRBKKBGkiEoPHQRFRJAFBUVBUIqGEupSAxEBRddQBJGmKAoK0qsUgQCCgApfQom4iEivoSQEQiSE5Pn9weYsWVjX3y5kjuT9uq5cu5mZc/YJz86ZM/d85jOAIwimAAAAAAAA4AiCKQAAAAAAADiCYAoAAAAAAACOIJgCAAAAAACAIwimAAAAAAAA4AiCKQAAAAAAADiCYAoAAAAAAACOIJgCAAAAAACAIwimAAAAAAAA4AiCKQAAAAAAADiCYAoAAAAAAACOIJgCAAAAAACAIwimAAAAAAAA4AiCKQAAAAAAADiCYAoAAAAAAACOIJgCAAAAAACAIwimAAAAAAAA4AhHg6nIyEhVr15duXLlUsGCBdWiRQvt378/wzZXr15Vjx49lC9fPuXMmVMtW7ZUbGysQxUDAAAAAADgTnE0mNq0aZN69OihH374QVFRUUpJSVGjRo105coV9zZ9+/bV8uXLtWDBAm3atEmnTp3S888/72DVAAAAAAAAuBOyOfk/vnr16gy/z5gxQwULFlR0dLQee+wxJSQk6NNPP9Xs2bPVoEEDSdL06dP1yCOP6IcfflCtWrWcKBsAAAAAAAB3gEfNMZWQkCBJCgwMlCRFR0crJSVFDRs2dG/z8MMPq1ixYvr+++9v+x7Jycm6dOlShh8AAAAAAAB4Ho8JptLS0tSnTx89+uijKl++vCTpzJkz8vX1VZ48eTJsGxQUpDNnztz2fSIjIxUQEOD+uf/+++926QAAAAAAAPgveEww1aNHD+3du1dz5879n94nIiJCCQkJ7p/jx4/foQoBAAAAAABwJzk6x1S6nj17asWKFfr2228VHBzsXl6oUCFdu3ZNFy9ezDBqKjY2VoUKFbrte/n5+cnPz+9ulwwAAAAAAID/kaMjpsxMPXv21JIlS7RhwwaVKFEiw/qqVavKx8dH69evdy/bv3+/jh07ptq1a2d2uQAAAAAAALiDHB0x1aNHD82ePVvLli1Trly53PNGBQQEKHv27AoICFBoaKj69eunwMBA5c6dW7169VLt2rV5Ih8AAAAAAMCfnKPB1IcffihJql+/fobl06dPV8eOHSVJ77//vry8vNSyZUslJyercePGmjJlSiZXCgAAAAAAgDvN0WDKzP7jNv7+/po8ebImT56cCRUBAAAAAAAgs3jMU/kAAAAAAACQtRBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHAEwRQAAAAAAAAcQTAFAAAAAAAARxBMAQAAAAAAwBEEUwAAAAAAAHCEo8HUt99+q2eeeUZFihSRy+XS0qVLM6w3Mw0bNkyFCxdW9uzZ1bBhQx04cMCZYgEAAAAAAHBHORpMXblyRZUqVdLkyZNvu3706NGaMGGCPvroI23btk05cuRQ48aNdfXq1UyuFAAAAAAAAHdaNif/x5s0aaImTZrcdp2Zafz48XrjjTfUvHlzSdIXX3yhoKAgLV26VC+99FJmlgoAAAAAAIA7zGPnmDp8+LDOnDmjhg0bupcFBASoZs2a+v777//t65KTk3Xp0qUMPwAAAAAAAPA8HhtMnTlzRpIUFBSUYXlQUJB73e1ERkYqICDA/XP//fff1ToBAAAAAADw3/HYYOq/FRERoYSEBPfP8ePHnS4JAAAAAAAAt+GxwVShQoUkSbGxsRmWx8bGutfdjp+fn3Lnzp3hBwAAAAAAAJ7HY4OpEiVKqFChQlq/fr172aVLl7Rt2zbVrl3bwcoAAAAAAABwJzj6VL7ExET9+uuv7t8PHz6s3bt3KzAwUMWKFVOfPn30zjvv6MEHH1SJEiU0dOhQFSlSRC1atHCuaAAAAAAAANwRjgZTO3bs0BNPPOH+vV+/fpKkDh06aMaMGQoPD9eVK1fUpUsXXbx4UXXr1tXq1avl7+/vVMkAAAAAAAC4QxwNpurXry8z+7frXS6XRowYoREjRmRiVQAAAAAAAMgMHjvHFAAAAAAAAO5tBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHEEwBQAAAAAAAEcQTAEAAAAAAMARBFMAAAAAAABwBMEUAAAAAAAAHPGnCKYmT56sBx54QP7+/qpZs6a2b9/udEkAAAAAAAD4H3l8MDVv3jz169dPw4cP186dO1WpUiU1btxYZ8+edbo0AAAAAAAA/A88PpgaN26cOnfurFdffVVly5bVRx99pPvuu0+fffaZ06UBAAAAAADgf5DN6QJ+z7Vr1xQdHa2IiAj3Mi8vLzVs2FDff//9bV+TnJys5ORk9+8JCQmSpEuXLt3dYjPJbymXnS7hFleTE50u4RZO9pse/TH0KCN6dCv69J/Ro1t5Wo8kPu/+FT3KiB79MXze3crT+kSPbuVpPZL4vPtX9OjuSf87zOw/buuyP7KVQ06dOqWiRYvqu+++U+3atd3Lw8PDtWnTJm3btu2W17z55pt66623MrNMAAAAAAAA/Ivjx48rODj4d7fx6BFT/42IiAj169fP/XtaWpri4uKUL18+uVwuByu7N126dEn333+/jh8/rty5cztdDm6DHnk+evTnQJ88Hz3yfPTI89GjPwf65PnokeejR3eXmeny5csqUqTIf9zWo4Op/Pnzy9vbW7GxsRmWx8bGqlChQrd9jZ+fn/z8/DIsy5Mnz90qEf+QO3dudmYPR488Hz36c6BPno8eeT565Pno0Z8DffJ89Mjz0aO7JyAg4A9t59GTn/v6+qpq1apav369e1laWprWr1+f4dY+AAAAAAAA/Pl49IgpSerXr586dOigatWqqUaNGho/fryuXLmiV1991enSAAAAAAAA8D/w+GCqdevWOnfunIYNG6YzZ86ocuXKWr16tYKCgpwuDbpx6+Tw4cNvuX0SnoMeeT569OdAnzwfPfJ89Mjz0aM/B/rk+eiR56NHnsOjn8oHAAAAAACAe5dHzzEFAAAAAACAexfBFAAAAAAAABxBMAUAAAAAAABHEEwBAAAAAADAEQRTAAAAAAAAcATBFJAF8TDOPwf6BAAAAOBeRzAFZEHnz593ugT8jh9//FGS5HK5HK4Et5OSkiJJSk1NdbgS/FHpIW98fLzDleBmaWlpkv7ZH8J4z5TeJwAA7haCKSCLmTNnjooUKaITJ044XQpuY82aNXryySf12WefOV0K/sWJEycUFxcnHx8frVixQrNnz9b169edLgt/gMvl0pIlS9SpUyedPn3a6XLwD15eN76Gfv/995Ju9IlwyvOk92nt2rXat2+fw9UAf07/7rONzzzPt3v3bl25csXpMu55BFO4K37v6hofwM45f/681q9fr7Fjxyo4ONjpcnAbRYoUUcuWLTV27FhNnz7d6XLwD5cuXVLnzp3VunVrTZ8+Xc8++6yyZ8+ubNmyOV0afkf68ebAgQMaNmyYmjVrpkKFCjlcFW7+jrB7927VrVtXU6ZMkUQ45Ulu7tOWLVvUs2dPTZgwQUeOHHGuKOBPKC0tzT0K/syZMzp+/Lh7HZ95niU5OTnD7z///LOaNWums2fPOlRR1sE3atxxaWlp7qtrS5cu1f79+5UzZ06VL19ejz/+OLcnOWTHjh3q16+fJCk8PDxDn+A5KlSooEGDBum+++7Te++9J39/f7Vp08bpsrK8HDlyqGvXrho0aJC6du2qSZMm6YUXXtD169cJpzyYy+XStm3btGHDBlWtWlVt27aVmXEccpCZuY89U6ZM0c8//yx/f3/16tVL165dU58+fdwnavTJOTf36b333tOZM2eUmJiozz//XC6XS/3791epUqUcrhK3k77v7NmzR/v27ZO3t7dKliypqlWrOl1alpW+L0VERGjlypU6dOiQmjRpogYNGqhbt2585nmIDz74QEuWLNGSJUuUN29eSTemb8iePbsKFiyo1NRUeXt7O1zlvYuzUtxx6R++4eHh6t27t7Zu3aoNGzboueee0xdffOFwdVnXvn37lJSUpD179ui+++6Tl5cXtyF5mPQ5iy5duqQcOXLo8uXL6tevn+bMmeNwZVmbmcnb21vlypVTUlKSihYtqrVr1+rChQvKli0bc015uPHjx2vIkCHatm2bfvvtN3l5eXF12kHpJ15vvPGG3nzzTdWuXVsTJ05U27ZtNXToUI0ZM8a9HX1yTnqfRo4cqREjRujJJ5/U0qVL1b9/f61bt07jxo3ToUOHHK4St+NyubRo0SI1btxYH374oT744AO1bt1aH3/8sdOlZTk3jzr8+OOP9fnnn2vQoEGaOnWqvLy8NG3aNL311luSmFfUEzz66KOKiYlRaGio4uLiJEkJCQny9fVVjhw5CKXuMoIp3BULFy7U7NmzNX/+fH311Vf6y1/+osuXL/Oh66C2bdtq4MCBCgoKUps2bTip9kDe3t5avHix6tWrp+TkZLVo0UJBQUEaNmyYZsyY4XR5WVb651bevHm1Zs0avffeezp37pzat2+vCxcuyNvb270fXbt2zclScRtz5sxRWFiYzpw5oxkzZnAs8gCxsbFas2aNxowZozZt2ig0NFSRkZHq37+/hg8frokTJ0oinHKSmem3337T6tWr9de//lVNmjRRjRo19Pbbb6tbt25asGCBxowZQzjlgXbt2qWwsDANHz5cmzZtUmRkpI4ePUqvMlH6d4L0i/Vbt27VsWPH9Pbbb+vll1/Wyy+/rPHjx6tZs2b66quvtGrVKifLxT9Uq1ZN33zzjbZu3apXX31ViYmJunr1KseiTEIwhbvil19+0eOPP65atWpp8eLF6tu3ryZPnqx27dopMTFRP/30k9MlZgnx8fFKSkpSfHy8vL299cILL+jNN99UamqqOnTo4F5OOOUZ4uPjNWbMGPXv31+jRo3ShAkTNGPGDDVo0EDvvPMOI6cy2c1PcktKSpKfn5/Kli2r5s2bq1u3brp48aI6duyouLg4eXt7a9KkSVqwYAFfXhyU/m9/8uRJnTx50n2smTJlip555hl99NFHWrhwoXsSU3rlDG9vbx05ciTDE2KDg4MVGhqqSpUq6a9//asmTJggiVEETnG5XPL19ZWfn597f0kfZd23b181adJE8+fP1wcffMCcUx5m3759qlq1qrp166ajR4/qlVdeUefOnTVy5EhJ0sGDBx2u8N4WGhqqjRs3SroxYmr//v2qV6+e3n33XZ07d869XeHChdWzZ0+lpaVp69atDlWLf1WpUiWtXr1a33//vbp27arExERlz55d8+bN09dff63o6Gh9++23mjdvHmHvHUYwhbvC399fQUFBWrp0qTp06KDRo0erS5cukqTVq1drwYIFSkhIcLjKe9vKlSv10ksvqWbNmuratatWrFghb29vtWrVSt27d1d8fLw6duzoHvEBZ6SfGCckJChnzpw6d+6c/Pz83OsrV66sbt26ydfXV+Hh4fr000+dKjVLSZ/r4eb9KDQ0VCtWrFC2bNn00ksvqVu3bkpISFC9evUUFham3r17q1KlSpxIOyS9Z8uWLVOLFi3UsGFDPffcc+rdu7ck6YsvvlD16tU1evRoLVy4UImJifQqE9wu/AsICNAzzzyjbdu26cCBA+7l999/v6pUqaInn3xS7733HmF8JrrdQ2u8vb1VpkwZzZs3TydPnlS2bNnc2z3wwAMqW7asNm3apBUrVkgi6PUUZqYcOXLol19+Ud26dfX0009r0qRJkqRvv/1Wn332WYZQGHfOtWvX5OPjo8cee0zSjV489NBD+vrrr5UtWzZ98803GYLcAgUKqFq1avrpp5+4SOyg9M+ugwcP6ujRowoJCdGaNWu0bt06vfjii7p8+bLefPNN9ezZUx07dlT79u01aNAgPvPuMIIp/E/+3dP3goKC9Mknn6h169YaM2aMwsLCJEmJiYmaNm2aLl26pICAgMwsNUv56quv1KpVK9WvX1/h4eHKkSOH2rVrp0WLFrlPqnv06KFff/1V3bt3/92nKOLuSn+MfVhYmI4ePaoaNWro8OHDunDhgnubypUrq06dOnK5XPr000918eJFDoZ3mcvl+kP70ZAhQ1S3bl2dPn1aMTExKl++vNOlZ1kul0tr16513xq2cuVKDRw4UJMmTdKyZcskSTNnzlSNGjUUHh6uZcuWsR/dZTc/iSo2Ntb9JCofHx81b95ce/bs0SeffKL9+/dLki5fvqzTp0+rVatWql27tlauXKnk5GT6dJfd/DCUPXv2KCYmRjExMZKkiRMnKjg4WI0bN9aBAwd0+fJlpaamau/evRo8eLAee+wxjRw50n27CzJX+r5x6NAh93e5ggUL6vvvv1etWrXUrFkz93xGkjR//nwdPHgwwwUw3BlpaWny9fXVRx99JB8fH3366aeaO3eurl69qsaNG2vx4sWKiopSZGSkfvnlF0k3zot27dql4OBgLhI7JP2i1pIlS/TCCy9o5syZiouLU0hIiKKiolS8eHEVKFBAa9asUUxMjLZv364ff/xRe/fu5QEQd5oB/6W0tDT3f58/f7599tlnNnfuXPeygQMHmsvlslmzZtnOnTttz5491qhRIwsJCbGUlJRb3gN3xoEDB6xatWo2ZcoUMzOLjY214OBge+SRRyxnzpw2f/58MzNLSUmxefPm2eHDhx2sNmtKTU11/3//0KFDVqZMGZs2bZqZmX3yyScWGBhoEyZMsHPnzrlfExYWZqNGjbLz5887UnNW80f3o3RXr151okz8iz59+tjgwYPNzOzIkSNWsmRJCwsLM7OMx5suXbrYr7/+6kiNWUFaWlqGf+9hw4ZZxYoVrVChQlaxYkWbNWuWmZnNmjXLypUrZ1WrVrXmzZtb1apVrVKlSmZmNmDAAKtRo4Zdv37diT8hy7i5T4MGDbIyZcpY/vz57f7777eOHTtaWlqaHTt2zOrUqWMFChSwkJAQK1u2rJUqVcrMbnz/K1u2rF2+fNmpPyHLSu/dsmXLrFSpUvbhhx+6l73xxhvmcrnsyy+/tOPHj9vp06ctPDzc8uXLZz/99JOTZWcJ169ft+rVq1ulSpVs0aJF7u8IS5cuNZfLZaVLl7ZWrVpZ8+bNrUqVKpacnOxwxVnb119/bf7+/jZ58mQ7efJkhnW7d++2/Pnz24svvmgXLlxwqMKsgWAK/5Wbv8j069fPAgMD7aGHHrLg4GB7/vnn3es6d+5swcHBljNnTqtRo4Y98cQTdu3aNTMzvmzeBcnJyXbhwgXr1auXnT9/3o4fP25lypSxLl262P79+61evXqWM2dO+/LLL50uNUs6fvx4ht/Xr19vY8eOtdDQULty5Yp7+VtvvWX58uWzdu3a2euvv26dO3e2/PnzEyLeZemfa390P5o9e7bDFeNm169ft1q1atnYsWMtISHBihYtal26dHH39cMPP7Rly5Y5XGXWkf7v/re//c3y5ctns2bNsqioKGvTpo2VLVvWRo8ebWZmmzdvtvHjx1vr1q0tIiLCfQLXvn1769ixIydsmWTs2LEWGBhoGzdutC1btti8efMsf/781rJlS/c2U6dOtTFjxth7773nvsDYuXNna9CgQYZjGDLP0qVL7b777rOJEyfazz//nGFdWFiY5c2b14KCgqxGjRpWqlQp27lzp0OV3ttSU1NvWZaUlGSNGze2qlWr2oIFC9yfbatWrTKXy2UhISG2aNEi9/bp50fIPGlpaXblyhV74YUXLCIiIsO6m89Td+3aZV5eXta2bdvb9hp3BsEU/idnz561Ro0a2Y8//mgnT560pUuXWlBQkDVp0sS9za5du+y7776zv//97+6dOf0LDe6cqKgo69Onjx06dMguXbpkZjdGD7Rs2dJ9JbNLly5WoEABK1asmF28eJERa5loxIgR1rFjR/vtt9/cy7p06eK+cnb69OkM28+YMcNCQ0OtcuXK1rhxY9u1a1cmV5y1pO8L/7/7UUJCAvuRBxk9erS1atXKChUqZGFhYe7eXL161V577TUbNmyYJScn07O7ZMiQITZhwgT37+fPn7datWrZ5MmTM2w3cOBAK1GihG3ZsuWW9zh+/LhFRERYnjx5bO/evXe95qzqX0+uWrVqZUOGDMmwbPv27ZYrV65bTtjMzA4ePGjdu3e3wMBAi4mJuau14lZpaWl24cIFq1OnjkVGRprZjYsq8fHxNnPmTHdI9X//93+2aNEi27hxo506dcrJku9ZN5/T7Nu3z06fPu0e8X7lyhV78sknrVq1ahnCqRUrVpjL5bJevXpZXFycI3XjhtTUVAsJCbGhQ4fedv2ZM2fMzCwmJsb279+fmaVlOcwxhf/ahAkT9Oyzzypv3rwqUaKEihQpoqZNm+rzzz9XdHS0mjRpIunG/Di1a9fWI488Ii8vL6WlpSlbtmwOV39vWbx4sZ599lkFBgbqwoULypUrl1JSUrR7924FBwcrZ86ckm7M6/Huu+9q165dCggIYD6ITNSwYUMNHDhQ/v7+7on/p06dqoiICB08eFCLFy9WUlKSe/sOHTro448/1g8//KDFixercuXKDlWeNbhcrv9qP8qdOzf7kQPsH/OqnDt3TkePHnXvOzVr1tT27dtVpEgR9enTRy6XS8nJyRoxYoSioqLUrl07+fr60rO74OLFi9q6dasWLlyo6dOnS7oxyXlCQoJ7fpvk5GRJ0ujRoxUUFOR+8l56PxMTExUZGanly5frm2++Ubly5Rz4S+59N88p9e2330q6MUfRiRMn3NukpqaqevXq6tGjh3bs2KGkpCT3HEZxcXH67rvvtGfPHm3YsEEVKlTI/D8ii0rfVy5cuKDAwECdOnVKZcqU0eXLl/X222/r2WefVadOndSkSRMtXbpU1apV0/PPP6/HH39chQsXdrj6e8vIkSO1Y8cO9zlNRESEnnnmGVWpUkWDBg3St99+q/vuu09fffWVAgICNHr0aK1cuVJXr15V06ZNtXTpUk2dOlX9+/fP8LQ+3F3p+1D6ZPMXL15U9uzZFR8fn2G5JB0+fFiTJ0/WiRMnVKFCBZUpUybzC85KnM3F8Gd17do1+/DDD+2BBx6wsmXLZliXkpJia9assaJFi1qNGjUcqjDr2L9/v5UoUcI9F87NBg4caCVLlrQpU6ZYr169rHDhwnbo0CEHqszabh6d8c0331irVq1s69at7mXdu3c3f39/mzlzZoYRVQwXzjzsR38e6fvTkiVLrHLlylayZEkLCQmxQYMG2eXLl23WrFlWqlQpe/TRR+2ZZ56x5s2bW/78+bmF5S5K70lsbKy98MIL1qBBA/e8eU2bNrV69eq5t02/Na9bt2728ssv3/Je58+fZ2THXfKvcxQOHTrUSpcubWfOnLHx48dbxYoVbe3atRm2iYyMtDp16txyS2ViYqJdvHjxrteMW82ePdu8vb3t3Llz9uqrr1rOnDmtQIEC1qJFC5s0aZKZmdWuXdtee+01hyu9d23ZssUqVqxoLVq0sH379tmGDRssODjYvv76axs1apQ1bdrU6tata1FRUWZ2Y+RUo0aNrFixYrZhwwb397sFCxZYYGCge1QOMscPP/xgbdq0cY9Wmz59urlcLpsxY0aG7QYPHmx16tTJMOcr7h6CKfwh6V86bz7BjouLs88//9xy5cp1y8EvJSXFli1bZs2aNePk+i6LioqyMmXK2JEjR9zL0vu0c+dO69atm5UoUcKqVq3KiZkH2Lhxo+XPn9/atGljP/zwg3t5WFiY+fv725dffmlJSUkOVpg1sR/9OaQfT6KioixHjhw2btw4i4+Pt4EDB5qfn58tXLjQzMx9ctCqVSsbPXo0w+/vspvn4vjuu+/s8ccft+rVq9vChQtt586dVrx4cWvVqlWGbevUqWO9e/fO8D7cYnn3VKhQwQYNGuT+fdu2bdaiRQv37ZTR0dHWqFEja9mypa1atcrMzC5cuGCNGjWydu3aOVIz/il93zh37pyFhoba+PHjzezGPEZz5861WbNmWWJiovu2so4dO9rgwYP5Dn4XzZ0715588klr1aqV9e/fP8NtzOvWrbPnnnvO6tSp4w6nEhMTrXfv3u7PwPTe8OCAzDdp0iSrWLGitWvXzh1OpT8w4LXXXrMePXpYx44dLXfu3EylkYlcZjyDF7/v5iHfsbGx8vf3l6+vr7Jnz66LFy9q6dKlGjRokJo3b66PP/7Y/brU1FT3o09vfg/cWUuXLlXv3r21efNmFS9e3P14bpfLpa1bt8rb21sVKlRQSkqK8uTJ43S5WYqZKS0tTd7e3rpw4YJ8fHyUO3du7d27V82bN1fVqlXVv39/1axZU5LUs2dPTZkyRXPnzlWrVq0crj5rYT/yXDNnztTly5fVvXt3SdK1a9fUvXt35c6dW+PGjdPZs2dVs2ZN/eUvf9GkSZPkcrkyHH+Qefr376+DBw/q9OnT2rdvn4oWLao+ffqoYMGC6tevn/z8/FSyZEnFx8crISFBMTEx3NqfCUaMGKFFixZp165d8vLy0oIFC/T5558rISFBy5cvd3+mrV+/Xh988IG2b9+uPHnyyM/PT5K0Y8cO+fj4uB+rDmfs2LFD/fr1kyR98sknKlOmzC39OHv2rCZOnKhJkybpu+++0yOPPOJEqfe0lJQU+fj4SJIWLlyoqVOnavfu3Ro4cKDCw8Pd223YsEGTJ0/WuXPnFB4ermbNmrnX3XyMYr/KfNevX9e0adP0xRdfqGTJkpoyZYpy586tBQsWaM6cOUpISFCxYsU0YMAAbinPRCQF+F03B0ojR45UixYt9MQTT6h58+Y6ffq08uTJo+eee06jRo3S8uXL1a1bN/drbz4pIJS6eypVqqTz58+7Q0EvLy/3AW7hwoVauXKlsmfPzsl0Jlq1apX27Nkjl8slb29vLV68WE2bNlVISIieffZZnThxQlFRUYqOjtbYsWO1bds2SdKkSZPUt29fVaxY0eG/IOthP/JMV65c0RdffKFZs2ZpxowZkiRfX19dunRJtWrV0rlz5xQSEqJGjRpp8uTJcrlcWrZsmTZs2OCeDweZ44svvtD06dM1bNgwrVq1Sj///LOCg4M1e/ZsXbp0SVu2bNGLL76oBx98UI0aNXKHUtevX3e69HteQkKCsmXLJi8vL7355pv629/+pkOHDikmJkYxMTHu7Z588klNmDBBCxYsUPv27dW/f39FR0fLx8dH169f5+TZYfv27VNSUpL27NmjHDlyyOVyKSUlxb1+06ZN6tq1q2bPnq1vvvmGUOouSEtLc4dSK1asUP369dWrVy8VL15cX375pXbv3u3etkGDBurZs6dcLpdWrlwp6Z/zG918jsR+lTn279+va9euSZKyZcumzp0765VXXtGhQ4fUo0cPXbx4US+++KJmzpyp9evXa+rUqYRSmc3J4VrwbDcP/3399dctKCjIPv/8c1uxYoVVrFjRSpUq5b494uLFizZjxgxzuVw2atQop0rOsj799FPz8fGxgQMH2o8//mh///vfLTw83PLkyWP79u1zurws5cyZM1aiRAl79dVX7eDBg/bTTz9Zrly57J133rGRI0daWFiYZcuWzWbMmGEHDx60kiVLWps2bWzz5s1Ol57lsR95plOnTtmLL75o9evXt48//tjMzDp16mQ1a9a0EiVKWPfu3d23ryQmJtpLL71kI0eOzHB7Ge6+YcOG2aOPPmqpqanu246OHz9u1atXt9KlS2d4LHo6enR3pfdh8+bN9sgjj1iFChUsT548FhcXZ6tWrbIKFSpYy5YtbceOHbe85mb0yTOkpKTYvHnzrHTp0la3bl33nGHp/Tly5IjNmjXLDh486GSZ96yb942IiAgrVKiQ+4mjCxYssPr161uLFi1s9+7dGV4XHR3NLZUOuLlfv/zyi9WsWdN69uyZYb685ORkGzNmjBUqVMg6d+5s8fHxt309MgfBFG7xrwe0devWWZUqVdwnzl999ZUFBARYyZIlLSgoyB1OxcXF2cqVK/kC44DU1FSbP3++5c2b14KDg6106dL20EMPMReOQ6Kjo61atWrWo0cPGzJkiA0YMMC9LiEhwSZOnGg+Pj62bt06i4mJsTx58lhoaGiGic+R+diPPEtaWppdu3bNzMx++ukna9KkidWuXdsWLVpkhw4dsmrVqlnRokUzvOb111+34sWL24EDB5woOUtK//IeGRlp1apVc8+Rl967devWWY4cOaxs2bK2dOnSDK9B5mncuLG5XC57+umn3ctmz55t1apVs3bt2ll0dLR7Of1xXnoPjh07ZkePHrWff/7ZvXz+/PlWs2ZNa9q0qXt+HHqWeUaMGGH58+e37du3Z3gAwJIlS6xRo0bWokUL27Nnzy2vI5zKXDcH81u2bLF+/fpZ3bp1bcCAARnCqZSUFCtXrpwFBARYaGgo+5KDmGMKGXTr1k2HDh1SZGSkqlSpIknavHmzNm7cqKFDh2r16tVq37693nzzTTVs2FBPPPGEcuXKpUWLFmUY7sj8Hs44deqUjh49KpfLpRIlSigoKMjpkrKsnTt3qlu3boqNjVWzZs00adIk97qEhAT16dNHV69e1Zw5c/Tdd9+pYMGCKl26tIMVIx37kWewf8y7MX/+fC1atEjHjx/Xnj17VKRIEYWHhyt37twaMGCA8ufPrwcffFCpqanauHGj1q1bp5CQEKfLz3J++uknVa5cWW+88YaGDx/uXr5q1SpNnTpV5cuX19tvv82t/Q6Ii4tThw4dVKNGDc2dO1cVK1bUnDlzJEmzZ8/W+PHjVa5cOXXt2lW1atVyuFqkf/YtXrxYERERun79ui5cuKC2bdtq8ODBKlasmObNm6cPPvhABQoU0GeffaZ8+fI5XXaWEBcXp9atW6tjx456+eWXdfLkSf3yyy+aPXu2GjZsqMOHD2vz5s26fPmypk+frlKlSjldcpa2ceNGNWjQQOvXr1eVKlU0duxYrV27Vo899pgiIyPl7e2tS5cuqVevXipXrpzatm2r4OBgp8vOsgimkMGGDRvUpUsX1ahRQ/369VO1atUkSadPn1aBAgXUrFkzValSRe+++66SkpLUtGlTbdu2TfXr19eqVascrh7wLDExMWrevLn8/f01Z84cVa5c2b1uyJAhWrFihbZt2yZ/f3/nigQ82LZt29SgQQNNnDhRjz76qLy9vdWpUydJ0ssvv6z69etrypQpio+PV4kSJdS2bVs9+OCDDleddc2YMUNdunTRX//6V7Vq1UqBgYHq3bu3KlasqMjISEk8DMUpqamp8vLy0vTp0zVmzBiFhIRo9uzZkqQ5c+YoIiJCoaGhGjp0qMOVQroxX1STJk00btw4Pfzww4qPj1eXLl1Ur149TZw4UYULF9a8efP0zjvvqHz58pozZw77VSaIj49X+fLl9eqrr6pRo0aaMmWKDh8+rLS0NJ04cUIjRoyQn5+ftm/frgkTJtATBx0+fFi7d+/WL7/8okGDBkmSkpKSNHLkSK1du1ZlypRRWFiYli1bps2bN2vZsmUqUKCAw1VncU4O14JnSR9iumXLFitZsqS99NJLtn37dvf6EydO2AMPPGDLli0zsxvzSrVq1cq2bdvG8FTg34iJibEKFSpYx44dM8w70KVLF2vYsKElJiY6WB3g2aZOnWply5Z13x5mdmPeokcffdRKly5tixcvdrA63M7ChQutYMGCFhwcbMHBwRYSEuK+rY9bJJyXmJhon332mT388MPWtm1b9/K1a9cyFYMHef311+0vf/lLhmW7du2ywMBA69Onj5nduAVpwYIFdvjwYQcqzLqmTZtmefPmtdy5c1t4eLhFRUWZmVnbtm0tNDQ0w7acH919t/s3PnLkiPn6+pq/v7+98847ZvbPudiuXLliEydOtCpVqlihQoXsoYceynArM5zDiClI+ucVzPT/3Lx5szp27KiqVatq0KBBqlq1qiSpfv36io2NVUREhD799FNdv35dmzdvzvBaABnt2rVL7du3V1JSkh577DH5+flp4cKFWrduXYZRVAAymjlzpv72t79p8+bNKlCggPsx3T/++KPq1Kmj4sWLa+DAgerQoQOP3PYgp06d0smTJ3XlyhXVq1dP3t7eun79urJly+Z0adCNp10uWLBA7733noKDg7V69Wr3OqZicJ6ZKTQ0VCdPntSaNWuUlpam69evy9fXV7NmzVL//v21fft2FS9e3OlSs6xjx44pOTnZPUI3LS1NjRo1Uo0aNfTuu+86XF3Wc/z4cW3btk0vvPCC5s6dq+XLl+uxxx7T0KFD1bhxY82cOVOS3MehtLQ0Xbp0SceOHVPhwoUZKeUhSBGQIVA6ePCgTpw4oXr16mn58uWKjo7WqFGj9H//93+SpPHjxys4OFjjxo1Trly5tHHjRkIp4D9Iv2XCy8tL69ev1wMPPKDo6GhCKeA/qF27to4ePaqJEydKkvsx3deuXVPVqlVVsWJFNWjQQBKP3PYkRYoUUfXq1VW/fn15e3srNTWVUMqD5MiRQy+++KK6deumwMBApaWludcRSmUuM1NqaqqkG/MXJSUlyeVy6ZlnntGmTZu0bt06eXl5ufefnDlzKl++fMqVK5eTZWd5xYoV04MPPqjExERt2bJFzZs319mzZzVixAinS8tyUlJSFB4ervfff1/9+vVT27Zt9dRTT6lLly4aNWqU5s2bpzfeeEOS3KGUl5eX8uTJo4oVKxJKeRBGTGVxN19hHjx4sJYtW6Zz587pkUce0YABA1ShQgU99dRTqlKlioYOHaqKFStKunE1tHDhwnK5XFwFBf6g6OhoRURE6Msvv+RACPxBs2bN0muvvaaBAweqc+fOypMnj8aNG6djx45pwoQJyp07t9MlAn9KV69elZ+fn1wuFxcYM9mqVatUtGhRVapUSZK0ZMkSjR07VmfPnlWbNm1Uu3ZtrV69WmvWrNGECRP01FNPSZIiIiIUFRWlqKgo5c2b18k/IcszM23atEljx45VSkqKli9fLh8fH0YdOuDixYt6+umntX37doWFhWnKlCmSpN9++02zZ89WWFiYBg8erLffftvhSvF7CKaysJu/hMydO1d9+/bVRx99pIsXL2rv3r0aN26cpk+frrp166pRo0aqVq2aevfurTp16tz2PQD8Z1evXmWyc+D/g5lp7ty56tKliwoUKCAvLy/Fx8crKirK/fRYAP89boPNXLGxsapdu7bq16+vIUOGKCUlRbVr11b//v11/vx5bdmyRQ8++KBq1Kih48ePa9KkSapSpYp8fHy0d+9ebdiwgSePeojk5GT9/e9/V6VKleTl5cXFeoekpKTo6aefVlxcnAoUKKAOHTro5ZdflvTPcKpXr14KCwvTuHHjHK4W/w7BFLRx40Z9+eWXKlu2rPr27StJ7secDho0SOvXr1f27NlVt25dDRgwQG+99ZbDFQMAspojR44oJiZGv/32m2rWrKkHHnjA6ZIA4L+yc+dOde3aVbVq1VJQUJAkuW83Wr58uSZMmKC8efPqlVdeUUBAgL7++msFBgbqueee48mjHoqL9c5KTk5WfHy8OnXqpKSkJL322mt65ZVX3Ovff/99jRo1Sj/++CN3LXgogqks7syZM6pbt67Onj2rQYMGaciQIe518fHx6tixo+6//35NmjRJu3fvVoUKFRieCgAAAPwPdu7cqW7duik2NlYvvfSSRo4c6V63fPlyvf/++8qbN6+GDh3KnJTAH3To0CH17t1bV69eVYcOHdSuXTsNHz5cR48e1bhx4xQYGOh0ifg3CKagmJgYPf/88woICNC0adMyDA/u1KmTTpw4wRNbAAAAgDsoJiZGLVq0UJEiRTR16lSVK1fOvW7VqlUaMmSIypUrp48//ljZs2fnlkvgDzh8+LD69++vAwcOyN/fXwcOHNCaNWtUs2ZNp0vD7yCYgqQbB8b27durUqVK6tu3rypXrqzLly/r6aefdh8QAQAAANw5MTEx6tChg2rUqKHevXtnCKfWrl2rhx56SMWLF3ewQuDP5+TJk1qzZo1OnDih1q1b66GHHnK6JPwHBFNw27Vrl1555RXFxcWpWrVq8vX11eHDh/XDDz/I19eXyTEBAACAO2zXrl3q1KmTqlSpor59+6ps2bJOlwQAmYoZ2uAWEhKiefPmKXv27EpISNBTTz2lnTt3ytfXVykpKYRSAAAAwB0WEhKiadOmKSYmRm+//bZ+/vlnp0sCgExFMIUMypcvr8WLF+vatWvauXOnfv31V0mSj4+Pw5UBAAAA96aQkBBNmjRJp0+fVkBAgNPlAECm4lY+3NauXbsUFhamkiVLavjw4Xr44YedLgkAAAC4p129elX+/v5OlwEAmYoRU7gtrtoAAAAAmYtQCkBWxIgp/C6u2gAAAAAAgLuFYAoAAAAAAACO4FY+AAAAAAAAOIJgCgAAAAAAAI4gmAIAAAAAAIAjCKYAAAAAAADgCIIpAAAAAAAAOIJgCgAAAAAAAI4gmAIAAAAAAIAj/h/aWh/vSpZqeAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plot_performances(class_accuracy_model_1,class_accuracy_model_1_quant,overall_accuracy_model_1,overall_accuracy_model_1_quant,\"model_1\",\"model_1_quantizé\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5y3SEYQJzItG",
+   "metadata": {
+    "id": "5y3SEYQJzItG"
+   },
+   "source": [
+    "On a une différence de performance entre le modèle 1 et le modèle 1 quantizé très très faible. En effet on note dans notre cas une différence de seulement 0.1% en terme de précision"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "wavfZ-NJzXQq",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "wavfZ-NJzXQq",
+    "outputId": "307e53a6-bac2-4635-d19a-51f4699ca89c"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 22.319471\n",
+      "\n",
+      "Test Accuracy of airplane: 67% (675/1000)\n",
+      "Test Accuracy of automobile: 78% (786/1000)\n",
+      "Test Accuracy of  bird: 35% (353/1000)\n",
+      "Test Accuracy of   cat: 55% (557/1000)\n",
+      "Test Accuracy of  deer: 56% (563/1000)\n",
+      "Test Accuracy of   dog: 46% (463/1000)\n",
+      "Test Accuracy of  frog: 76% (769/1000)\n",
+      "Test Accuracy of horse: 59% (595/1000)\n",
+      "Test Accuracy of  ship: 68% (688/1000)\n",
+      "Test Accuracy of truck: 64% (640/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 60% (6089/10000)\n",
+      "Test Loss: 22.334124\n",
+      "\n",
+      "Test Accuracy of airplane: 67% (670/1000)\n",
+      "Test Accuracy of automobile: 78% (784/1000)\n",
+      "Test Accuracy of  bird: 35% (356/1000)\n",
+      "Test Accuracy of   cat: 55% (558/1000)\n",
+      "Test Accuracy of  deer: 56% (560/1000)\n",
+      "Test Accuracy of   dog: 46% (463/1000)\n",
+      "Test Accuracy of  frog: 76% (768/1000)\n",
+      "Test Accuracy of horse: 59% (594/1000)\n",
+      "Test Accuracy of  ship: 68% (685/1000)\n",
+      "Test Accuracy of truck: 64% (644/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 60% (6082/10000)\n",
+      "Modèle 1 : 6.51s\n",
+      "Modèle 1 quantizé : 5.57s\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "\n",
+    "t_start = time.time()\n",
+    "class_accuracy_model_1, overall_accuracy_model_1 = test_model(model_1)\n",
+    "t_end = time.time()\n",
+    "diff = t_end - t_start\n",
+    "\n",
+    "t_start_quant = time.time()\n",
+    "class_accuracy_model_1_quant, overall_accuracy_model_1_quant = test_model(quantized_model_1)\n",
+    "t_end_quant = time.time()\n",
+    "diff_quant = t_end_quant - t_start_quant\n",
+    "\n",
+    "print(f\"Modèle 1 : {diff:.2f}s\")\n",
+    "print(f\"Modèle 1 quantizé : {diff_quant:.2f}s\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "YTwB3Kx-02Y1",
+   "metadata": {
+    "id": "YTwB3Kx-02Y1"
+   },
+   "source": [
+    "On représente ici la différence de perfomance en vitesse entre le modèle quantizé ou non. On décide de comparer la vitesse du test pour chaque modèle, en effet on a dans la fonction test enormement d'apelle au modèle ce qui permet de verfifier si l'un ou l'autre est plus rapide. On finit par conclure que le modèle quantizé est en effet plus rapide.\n",
+    "\n",
+    "En plus de prendre moins de place il permet de réaliser des appelles plus rapide et cela pour une perte de performance très peu notable"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0a34b90",
+   "metadata": {
+    "id": "a0a34b90"
+   },
+   "source": [
+    "Try training aware quantization to mitigate the impact on the accuracy (doc available here https://pytorch.org/docs/stable/quantization.html#torch.quantization.quantize_dynamic)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "A3TOm7jx1YP6",
+   "metadata": {
+    "id": "A3TOm7jx1YP6"
+   },
+   "source": [
+    "On tente ici d'effectuer un entrainement QAT, qui selon l'état de l'art permet un quantization plus performante (ici ce ne sera surement pas notable au vu des très bonne performance de notre modèle quantizé dynamiquement au dessus)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "jLU1pW-NR58b",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "collapsed": true,
+    "id": "jLU1pW-NR58b",
+    "outputId": "92e969fc-8c31-4b44-e7d1-668c001a87a8"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 45.202924 \tValidation Loss: 41.452921 \tdecrease_strike: 0\n",
+      "Validation loss decreased (inf --> 41.452921).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 37.786418 \tValidation Loss: 34.370768 \tdecrease_strike: 0\n",
+      "Validation loss decreased (41.452921 --> 34.370768).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 32.532339 \tValidation Loss: 31.501696 \tdecrease_strike: 0\n",
+      "Validation loss decreased (34.370768 --> 31.501696).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 29.877512 \tValidation Loss: 28.729775 \tdecrease_strike: 0\n",
+      "Validation loss decreased (31.501696 --> 28.729775).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 27.976724 \tValidation Loss: 26.721879 \tdecrease_strike: 0\n",
+      "Validation loss decreased (28.729775 --> 26.721879).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 26.422833 \tValidation Loss: 27.219907 \tdecrease_strike: 0\n",
+      "Epoch: 6 \tTraining Loss: 25.135119 \tValidation Loss: 25.298651 \tdecrease_strike: 1\n",
+      "Validation loss decreased (26.721879 --> 25.298651).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 23.964395 \tValidation Loss: 25.356723 \tdecrease_strike: 0\n",
+      "Epoch: 8 \tTraining Loss: 22.962856 \tValidation Loss: 24.598866 \tdecrease_strike: 1\n",
+      "Validation loss decreased (25.298651 --> 24.598866).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 22.082267 \tValidation Loss: 22.841432 \tdecrease_strike: 0\n",
+      "Validation loss decreased (24.598866 --> 22.841432).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 21.283431 \tValidation Loss: 22.895926 \tdecrease_strike: 0\n",
+      "Epoch: 11 \tTraining Loss: 20.493509 \tValidation Loss: 23.379660 \tdecrease_strike: 1\n",
+      "Epoch: 12 \tTraining Loss: 19.794733 \tValidation Loss: 22.451179 \tdecrease_strike: 2\n",
+      "Validation loss decreased (22.841432 --> 22.451179).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 19.088381 \tValidation Loss: 22.046485 \tdecrease_strike: 0\n",
+      "Validation loss decreased (22.451179 --> 22.046485).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 18.513720 \tValidation Loss: 21.796479 \tdecrease_strike: 0\n",
+      "Validation loss decreased (22.046485 --> 21.796479).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 17.809622 \tValidation Loss: 22.445786 \tdecrease_strike: 0\n",
+      "Epoch: 16 \tTraining Loss: 17.213774 \tValidation Loss: 22.369375 \tdecrease_strike: 1\n",
+      "Epoch: 17 \tTraining Loss: 16.673527 \tValidation Loss: 22.358099 \tdecrease_strike: 0\n",
+      "Epoch: 18 \tTraining Loss: 16.130441 \tValidation Loss: 24.032481 \tdecrease_strike: 0\n",
+      "Epoch: 19 \tTraining Loss: 15.595850 \tValidation Loss: 22.184795 \tdecrease_strike: 1\n",
+      "Epoch: 20 \tTraining Loss: 15.089283 \tValidation Loss: 22.874229 \tdecrease_strike: 0\n",
+      "Epoch: 21 \tTraining Loss: 14.625514 \tValidation Loss: 23.936723 \tdecrease_strike: 1\n",
+      "Epoch: 22 \tTraining Loss: 14.168319 \tValidation Loss: 23.305284 \tdecrease_strike: 2\n",
+      "Epoch: 23 \tTraining Loss: 13.738828 \tValidation Loss: 23.111639 \tdecrease_strike: 0\n",
+      "Epoch: 24 \tTraining Loss: 13.270323 \tValidation Loss: 24.003016 \tdecrease_strike: 0\n",
+      "Epoch: 25 \tTraining Loss: 12.833328 \tValidation Loss: 24.911660 \tdecrease_strike: 1\n",
+      "Epoch: 26 \tTraining Loss: 12.490507 \tValidation Loss: 24.893355 \tdecrease_strike: 2\n",
+      "Epoch: 27 \tTraining Loss: 12.070481 \tValidation Loss: 25.417588 \tdecrease_strike: 0\n",
+      "Epoch: 28 \tTraining Loss: 11.700278 \tValidation Loss: 25.747951 \tdecrease_strike: 1\n",
+      "Epoch: 29 \tTraining Loss: 11.223761 \tValidation Loss: 26.745619 \tdecrease_strike: 2\n",
+      "model:  int8  \t Size (KB): 75.338\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import torch.quantization\n",
+    "\n",
+    "# On redéfinit le modèle avec les features de QAT\n",
+    "class QuantizedNet(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(QuantizedNet, self).__init__()\n",
+    "        self.quant = torch.quantization.QuantStub()\n",
+    "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
+    "        self.pool = nn.MaxPool2d(2, 2)\n",
+    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
+    "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
+    "        self.fc2 = nn.Linear(120, 84)\n",
+    "        self.fc3 = nn.Linear(84, 10)\n",
+    "        self.dequant = torch.quantization.DeQuantStub()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.quant(x)\n",
+    "        x = self.pool(F.relu(self.conv1(x)))\n",
+    "        x = self.pool(F.relu(self.conv2(x)))\n",
+    "        x = x.view(-1, 16 * 5 * 5)\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.fc3(x)\n",
+    "        x = self.dequant(x)\n",
+    "        return x\n",
+    "\n",
+    "model_qat = QuantizedNet()\n",
+    "model_qat.qconfig = torch.quantization.get_default_qat_qconfig('fbgemm')\n",
+    "model_qat = torch.quantization.prepare_qat(model_qat)\n",
+    "\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.SGD(model_qat.parameters(), lr=0.01)\n",
+    "valid_loss_list_qat, train_loss_list_qat = training(model_qat, \"model_qat\", criterion, optimizer)\n",
+    "\n",
+    "model_qat.cpu()\n",
+    "model_qat.eval()\n",
+    "model_qat_quantized = torch.quantization.convert(model_qat)\n",
+    "\n",
+    "size_qat = print_size_of_model(model_qat_quantized, \"int8\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "TJkjv0tOsTRU",
+   "metadata": {
+    "id": "TJkjv0tOsTRU"
+   },
+   "source": [
+    "On remarque que le modèle QAT permet un leger gain de place. ~ 1kb"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "201470f9",
+   "metadata": {
+    "id": "201470f9"
+   },
+   "source": [
+    "## Exercise 3: working with pre-trained models.\n",
+    "\n",
+    "PyTorch offers several pre-trained models https://pytorch.org/vision/0.8/models.html        \n",
+    "We will use ResNet50 trained on ImageNet dataset (https://www.image-net.org/index.php). Use the following code with the files `imagenet-simple-labels.json` that contains the imagenet labels and the image dog.png that we will use as test.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "HmgPmyWa1wVJ",
+   "metadata": {
+    "id": "HmgPmyWa1wVJ"
+   },
+   "source": [
+    "On choisit maintenant de travailler avec des pre trained. En effet dans la majorité des cas on se contente d'utiliser des modèle pré entrainé, au vu des très fortes performances nécéssaire pour entrainer un modèle avec un grand training_set."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b4d13080",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 547
+    },
+    "collapsed": true,
+    "id": "b4d13080",
+    "outputId": "1c56a7e2-3e6c-474d-c0fc-dc8ad37c8e4e"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n",
+      "Downloading: \"https://download.pytorch.org/models/resnet50-0676ba61.pth\" to /root/.cache/torch/hub/checkpoints/resnet50-0676ba61.pth\n",
+      "100%|██████████| 97.8M/97.8M [00:00<00:00, 116MB/s]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predicted class is: Golden Retriever\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import json\n",
+    "from PIL import Image\n",
+    "\n",
+    "# Choose an image to pass through the model\n",
+    "test_image = \"images/dog.png\"\n",
+    "\n",
+    "# Configure matplotlib for pretty inline plots\n",
+    "#%matplotlib inline\n",
+    "#%config InlineBackend.figure_format = 'retina'\n",
+    "\n",
+    "# Prepare the labels\n",
+    "with open(\"imagenet-simple-labels.json\") as f:\n",
+    "    labels = json.load(f)\n",
+    "\n",
+    "# First prepare the transformations: resize the image to what the model was trained on and convert it to a tensor\n",
+    "data_transform = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.Resize((224, 224)),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ]\n",
+    ")\n",
+    "# Load the image\n",
+    "\n",
+    "image = Image.open(test_image)\n",
+    "plt.imshow(image), plt.xticks([]), plt.yticks([])\n",
+    "\n",
+    "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
+    "# image = data_transform(image).unsqueeze(0).cuda()\n",
+    "image = data_transform(image).unsqueeze(0)\n",
+    "\n",
+    "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n",
+    "model = models.resnet50(pretrained=True)\n",
+    "# Send the model to the GPU\n",
+    "# model.cuda()\n",
+    "# Set layers such as dropout and batchnorm in evaluation mode\n",
+    "model.eval()\n",
+    "\n",
+    "# Get the 1000-dimensional model output\n",
+    "out = model(image)\n",
+    "# Find the predicted class\n",
+    "print(\"Predicted class is: {}\".format(labels[out.argmax()]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "Kj-pNCSq2Prk",
+   "metadata": {
+    "id": "Kj-pNCSq2Prk"
+   },
+   "source": [
+    "On note que le modèle resnet50 arrive a déterminer que l'on a a faire a un chien il arrive même a déterminer la race précise de celui ci."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "184cfceb",
+   "metadata": {
+    "id": "184cfceb"
+   },
+   "source": [
+    "Experiments:\n",
+    "\n",
+    "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n",
+    "\n",
+    "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n",
+    "\n",
+    "Experiment with other pre-trained CNN models.\n",
+    "\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bgcss05R2hfC",
+   "metadata": {
+    "id": "bgcss05R2hfC"
+   },
+   "source": [
+    "On se propose maintenant de determiner les performances de ce modèle pré entrainé en le testant sur différent objets. Pour cela on va choisir différentes images que l'on va placer dans le folder images. On note que l'on cherche a choisir des images cohérentes, c'est a dire des images représentant des objets que le modèles est suceptible de connaitre, des images d'objets labélisé dans le training_set\n",
+    "\n",
+    "On choisit ici des images de:\n",
+    "-Panda roux\n",
+    "-Chat siamois\n",
+    "-Tasse\n",
+    "-Vélo\n",
+    "-Bus\n",
+    "-Ordinateur portable\n",
+    "-Ballon de basketball\n",
+    "-Pomme\n",
+    "-Guitare acoustique"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "RCh1nGY2YOJC",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "RCh1nGY2YOJC",
+    "outputId": "1ecc4309-e4bf-4361-ac35-10fac94b9e55"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['chat-siamois.jpg', 'dog.png', 'pc.jpg', 'guitar.jpg', 'bus.jpg', 'ballon.jpg', 'pomme.jpg', 'tasses.jpeg']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# We start by testing the model for different images\n",
+    "import os\n",
+    "images = []\n",
+    "for filename in os.listdir('images'):\n",
+    "    if filename.lower().endswith(('.jpg', '.jpeg','.png')) and filename != \"poulpe.jpg\":\n",
+    "        images.append(filename)\n",
+    "print(images)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "-jky8cuDarXr",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "-jky8cuDarXr",
+    "outputId": "7fcc4ad4-eea2-4c65-a8f0-45e21c09c0fe"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "  warnings.warn(\n",
+      "/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-------------------------\n",
+      "Predicted class is: Siamese cat for chat-siamois.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: Golden Retriever for dog.png\n",
+      "-------------------------\n",
+      "Predicted class is: desk for pc.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: acoustic guitar for guitar.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: trolleybus for bus.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: basketball for ballon.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: Granny Smith for pomme.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: cup for tasses.jpeg\n"
+     ]
+    }
+   ],
+   "source": [
+    "import json\n",
+    "from PIL import Image\n",
+    "\n",
+    "def test_model(model, test_image):\n",
+    "  with open(\"imagenet-simple-labels.json\") as f:\n",
+    "    labels = json.load(f)\n",
+    "\n",
+    "  data_transform = transforms.Compose(\n",
+    "    [\n",
+    "        transforms.Resize((224, 224)),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ]\n",
+    "  )\n",
+    "\n",
+    "  print(f\"-------------------------\")\n",
+    "  image = Image.open(test_image)\n",
+    "\n",
+    "  # Now apply the transformation, expand the batch dimension, and send the image to the GPU\n",
+    "  # image = data_transform(image).unsqueeze(0).cuda()\n",
+    "  image = data_transform(image).unsqueeze(0)\n",
+    "\n",
+    "  # Send the model to the GPU\n",
+    "  # model.cuda()\n",
+    "  # Set layers such as dropout and batchnorm in evaluation mode\n",
+    "  model.eval()\n",
+    "\n",
+    "  # Get the 1000-dimensional model output\n",
+    "  out = model(image)\n",
+    "  # Find the predicted class\n",
+    "  print(f\"Predicted class is: {labels[out.argmax()]} for {images[i]}\")\n",
+    "\n",
+    "model = models.resnet50(pretrained=True)\n",
+    "t_start = time.time()\n",
+    "for i in range(len(images)):\n",
+    "    test_model(model, f\"images/{images[i]}\")\n",
+    "t_end = time.time()\n",
+    "diff = t_end - t_start"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "PhBtLDsI9z1z",
+   "metadata": {
+    "id": "PhBtLDsI9z1z"
+   },
+   "source": [
+    "On remarque que notre modèle restnet est très performant, il ne rate la classification que pour une image, il reconnait un bureau et non un PC (on note tout de même qu'il y a un bureau sur l'image même si il n'est pas le centre de celle ci)\n",
+    "\n",
+    "on décide ensuite de quantizé le modèle."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "80Gt8_9GdHyN",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "80Gt8_9GdHyN",
+    "outputId": "def72b48-9fb0-4111-a248-4f569ba7f0b1"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "model quantizé\n",
+      "model:  int8  \t Size (KB): 96379.996\n",
+      "model:  fp32  \t Size (KB): 102523.238\n",
+      "Le modèle quantizé est 5.99% plus léger que le modèle non quantizé\n",
+      "Performances of the quantize model\n",
+      "-------------------------\n",
+      "Predicted class is: Siamese cat for chat-siamois.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: Golden Retriever for dog.png\n",
+      "-------------------------\n",
+      "Predicted class is: desk for pc.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: acoustic guitar for guitar.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: trolleybus for bus.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: basketball for ballon.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: Granny Smith for pomme.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: cup for tasses.jpeg\n",
+      "Modèle : 2.07s\n",
+      "Modèle quantizé : 2.02s\n"
+     ]
+    }
+   ],
+   "source": [
+    "# We quantize the model now\n",
+    "model = models.resnet50(pretrained=True)\n",
+    "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n",
+    "\n",
+    "print(\"model quantizé\")\n",
+    "size_qaunt = print_size_of_model(quantized_model, \"int8\")\n",
+    "size = print_size_of_model(model, \"fp32\")\n",
+    "reduction = ((size - size_qaunt) / size) * 100\n",
+    "\n",
+    "print(f\"Le modèle quantizé est {reduction:.2f}% plus léger que le modèle non quantizé\")\n",
+    "\n",
+    "print(\"Performances of the quantize model\")\n",
+    "t_start = time.time()\n",
+    "for i in range(len(images)):\n",
+    "    test_model(quantized_model, f\"images/{images[i]}\")\n",
+    "t_end = time.time()\n",
+    "diff_quant = t_end - t_start\n",
+    "\n",
+    "print(f\"Modèle : {diff:.2f}s\")\n",
+    "print(f\"Modèle quantizé : {diff_quant:.2f}s\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "BnAU0-VqBhtC",
+   "metadata": {
+    "id": "BnAU0-VqBhtC"
+   },
+   "source": [
+    "On a une réduction assez minimale de la taille, et de la vitesse d'éxecution. Cependant on note que le modèle quantizé reste tout de même capable de reconnaitre aussi bien chaque image.\n",
+    "\n",
+    "On note tout de même que ces faibles gains peuvent s'averer énorme pour un très grand nombre d'inférences"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ivJ8RlNZfNuT",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "ivJ8RlNZfNuT",
+    "outputId": "dd0ec8fb-3416-432b-d1aa-2d238ad2e7bf"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-------------------------\n",
+      "Predicted class is: Siamese cat for chat-siamois.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: Golden Retriever for dog.png\n",
+      "-------------------------\n",
+      "Predicted class is: desktop computer for pc.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: acoustic guitar for guitar.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: passenger car for bus.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: basketball for ballon.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: banana for pomme.jpg\n",
+      "-------------------------\n",
+      "Predicted class is: coffeemaker for tasses.jpeg\n"
+     ]
+    }
+   ],
+   "source": [
+    "# On utilise mtn un autre pre trained model entrainé sur le même dataset as resnet\n",
+    "\n",
+    "model = models.efficientnet_b3(pretrained=True)\n",
+    "\n",
+    "for i in range(len(images)):\n",
+    "    test_model(model, f\"images/{images[i]}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5d57da4b",
+   "metadata": {
+    "id": "5d57da4b"
+   },
+   "source": [
+    "## Exercise 4: Transfer Learning\n",
+    "    \n",
+    "    \n",
+    "For this work, we will use a pre-trained model (ResNet18) as a descriptor extractor and will refine the classification by training only the last fully connected layer of the network. Thus, the output layer of the pre-trained network will be replaced by a layer adapted to the new classes to be recognized which will be in our case ants and bees.\n",
+    "Download and unzip in your working directory the dataset available at the address :\n",
+    "    \n",
+    "https://download.pytorch.org/tutorial/hymenoptera_data.zip\n",
+    "    \n",
+    "Execute the following code in order to display some images of the dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6CMbfRLujq96",
+   "metadata": {
+    "id": "6CMbfRLujq96"
+   },
+   "outputs": [],
+   "source": [
+    "import urllib.request\n",
+    "import zipfile\n",
+    "\n",
+    "# Download the dataset\n",
+    "url = \"https://download.pytorch.org/tutorial/hymenoptera_data.zip\"\n",
+    "urllib.request.urlretrieve(url, \"hymenoptera_data.zip\")\n",
+    "\n",
+    "# Extract the dataset\n",
+    "with zipfile.ZipFile(\"hymenoptera_data.zip\", \"r\") as zip_ref:\n",
+    "    zip_ref.extractall()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cek-xho2Wh3i",
+   "metadata": {
+    "id": "cek-xho2Wh3i"
+   },
+   "source": [
+    "On choisit dans la cellule ci dessous de rajouter un ensemble de test qui permettera de tester nos modèles , il n'y en avait pas.\n",
+    "\n",
+    "Pour cela on prend 20 images de l'ensemble de validation , evidement on les enléve de cet ensemble"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "be2d31f5",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 224
+    },
+    "id": "be2d31f5",
+    "outputId": "b2e1e654-d73f-4984-c02f-108332198853"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of the datasets: {'train': 244, 'val': 133, 'test': 20}\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import torchvision\n",
+    "from torchvision import datasets, transforms\n",
+    "from torch.utils.data import Subset\n",
+    "\n",
+    "data_transforms = {\n",
+    "    \"train\": transforms.Compose([\n",
+    "        transforms.RandomResizedCrop(224),\n",
+    "        transforms.RandomHorizontalFlip(),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ]),\n",
+    "    \"val\": transforms.Compose([\n",
+    "        transforms.Resize(256),\n",
+    "        transforms.CenterCrop(224),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ])\n",
+    "}\n",
+    "\n",
+    "data_dir = \"hymenoptera_data\"\n",
+    "val_dataset = datasets.ImageFolder(os.path.join(data_dir, 'val'), data_transforms['val'])\n",
+    "\n",
+    "# Création des ensembles validation et test\n",
+    "test_indices = list(range(20))  # 20 premières images pour le test\n",
+    "val_indices = list(range(20, len(val_dataset)))  # reste pour validation\n",
+    "\n",
+    "val_subset = Subset(val_dataset, val_indices)\n",
+    "test_subset = Subset(val_dataset, test_indices)\n",
+    "\n",
+    "image_datasets = {\n",
+    "    'train': datasets.ImageFolder(os.path.join(data_dir, 'train'), data_transforms['train']),\n",
+    "    'val': val_subset,\n",
+    "    'test': test_subset\n",
+    "}\n",
+    "\n",
+    "dataloaders = {x: torch.utils.data.DataLoader(\n",
+    "    image_datasets[x], batch_size=4, shuffle=True, num_workers=0)\n",
+    "    for x in ['train', 'val', 'test']\n",
+    "}\n",
+    "\n",
+    "dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val', 'test']}\n",
+    "print(f\"Size of the datasets: {dataset_sizes}\")\n",
+    "class_names = image_datasets['train'].classes\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "def imshow(inp, title=None):\n",
+    "    inp = inp.numpy().transpose((1, 2, 0))\n",
+    "    mean = np.array([0.485, 0.456, 0.406])\n",
+    "    std = np.array([0.229, 0.224, 0.225])\n",
+    "    inp = std * inp + mean\n",
+    "    inp = np.clip(inp, 0, 1)\n",
+    "    plt.imshow(inp)\n",
+    "    if title is not None:\n",
+    "        plt.title(title)\n",
+    "    plt.pause(0.001)\n",
+    "    plt.show()\n",
+    "\n",
+    "inputs, classes = next(iter(dataloaders['train']))\n",
+    "out = torchvision.utils.make_grid(inputs)\n",
+    "imshow(out, title=[class_names[x] for x in classes])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bbd48800",
+   "metadata": {
+    "id": "bbd48800"
+   },
+   "source": [
+    "Now, execute the following code which uses a pre-trained model ResNet18 having replaced the output layer for the ants/bees classification and performs the model training by only changing the weights of this output layer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "572d824c",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "572d824c",
+    "outputId": "11c36d46-0678-46cb-f48e-defc24a16d27"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Size of the dataset: {'train': 244, 'val': 133, 'test': 20}\n",
+      "Epoch 1/10\n",
+      "----------\n",
+      "train Loss: 0.7277 Acc: 0.6270\n",
+      "val Loss: 0.2321 Acc: 0.9323\n",
+      "\n",
+      "Epoch 2/10\n",
+      "----------\n",
+      "train Loss: 0.5347 Acc: 0.7459\n",
+      "val Loss: 0.1800 Acc: 0.9549\n",
+      "\n",
+      "Epoch 3/10\n",
+      "----------\n",
+      "train Loss: 0.4361 Acc: 0.7992\n",
+      "val Loss: 0.1486 Acc: 0.9549\n",
+      "\n",
+      "Epoch 4/10\n",
+      "----------\n",
+      "train Loss: 0.4583 Acc: 0.7582\n",
+      "val Loss: 0.1377 Acc: 0.9474\n",
+      "\n",
+      "Epoch 5/10\n",
+      "----------\n",
+      "train Loss: 0.5540 Acc: 0.7869\n",
+      "val Loss: 0.1426 Acc: 0.9549\n",
+      "\n",
+      "Epoch 6/10\n",
+      "----------\n",
+      "train Loss: 0.4347 Acc: 0.7992\n",
+      "val Loss: 0.1402 Acc: 0.9624\n",
+      "\n",
+      "Epoch 7/10\n",
+      "----------\n",
+      "train Loss: 0.3505 Acc: 0.8566\n",
+      "val Loss: 0.1555 Acc: 0.9474\n",
+      "\n",
+      "Epoch 8/10\n",
+      "----------\n",
+      "train Loss: 0.3757 Acc: 0.8484\n",
+      "val Loss: 0.1468 Acc: 0.9624\n",
+      "\n",
+      "Epoch 9/10\n",
+      "----------\n",
+      "train Loss: 0.3214 Acc: 0.8525\n",
+      "val Loss: 0.1748 Acc: 0.9323\n",
+      "\n",
+      "Epoch 10/10\n",
+      "----------\n",
+      "train Loss: 0.2823 Acc: 0.8566\n",
+      "val Loss: 0.1468 Acc: 0.9624\n",
+      "\n",
+      "Training complete in 6m 14s\n",
+      "Best val Acc: 0.962406\n"
+     ]
+    }
+   ],
+   "source": [
+    "import copy\n",
+    "import os\n",
+    "import time\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "import torchvision\n",
+    "from torch.optim import lr_scheduler\n",
+    "from torchvision import datasets, transforms\n",
+    "\n",
+    "data_transforms = {\n",
+    "    \"train\": transforms.Compose([\n",
+    "        transforms.RandomResizedCrop(224),\n",
+    "        transforms.RandomHorizontalFlip(),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ]),\n",
+    "    \"val\": transforms.Compose([\n",
+    "        transforms.Resize(256),\n",
+    "        transforms.CenterCrop(224),\n",
+    "        transforms.ToTensor(),\n",
+    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
+    "    ])\n",
+    "}\n",
+    "\n",
+    "data_dir = \"hymenoptera_data\"\n",
+    "val_dataset = datasets.ImageFolder(os.path.join(data_dir, 'val'), data_transforms['val'])\n",
+    "\n",
+    "# Création des ensembles validation et test\n",
+    "test_indices = list(range(20))  # 20 premières images pour le test\n",
+    "val_indices = list(range(20, len(val_dataset)))  # reste pour validation\n",
+    "\n",
+    "val_subset = Subset(val_dataset, val_indices)\n",
+    "test_subset = Subset(val_dataset, test_indices)\n",
+    "\n",
+    "image_datasets = {\n",
+    "    'train': datasets.ImageFolder(os.path.join(data_dir, 'train'), data_transforms['train']),\n",
+    "    'val': val_subset,\n",
+    "    'test': test_subset\n",
+    "}\n",
+    "\n",
+    "data_dir = \"hymenoptera_data\"\n",
+    "\n",
+    "dataloaders = {\n",
+    "    x: torch.utils.data.DataLoader(\n",
+    "        image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n",
+    "    )\n",
+    "    for x in [\"train\", \"val\"]\n",
+    "}\n",
+    "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\", \"test\"]}\n",
+    "print(f\"Size of the dataset: {dataset_sizes}\")\n",
+    "class_names = image_datasets[\"train\"].classes\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "# Helper function for displaying images\n",
+    "def imshow(inp, title=None):\n",
+    "    \"\"\"Imshow for Tensor.\"\"\"\n",
+    "    inp = inp.numpy().transpose((1, 2, 0))\n",
+    "    mean = np.array([0.485, 0.456, 0.406])\n",
+    "    std = np.array([0.229, 0.224, 0.225])\n",
+    "\n",
+    "    # Un-normalize the images\n",
+    "    inp = std * inp + mean\n",
+    "    # Clip just in case\n",
+    "    inp = np.clip(inp, 0, 1)\n",
+    "    plt.imshow(inp)\n",
+    "    if title is not None:\n",
+    "        plt.title(title)\n",
+    "    plt.pause(0.001)  # pause a bit so that plots are updated\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "# Get a batch of training data\n",
+    "# inputs, classes = next(iter(dataloaders['train']))\n",
+    "\n",
+    "# Make a grid from batch\n",
+    "# out = torchvision.utils.make_grid(inputs)\n",
+    "\n",
+    "# imshow(out, title=[class_names[x] for x in classes])\n",
+    "# training\n",
+    "\n",
+    "\n",
+    "def train_model(model, criterion, optimizer, scheduler, num_epochs=25):\n",
+    "    since = time.time()\n",
+    "\n",
+    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
+    "    best_acc = 0.0\n",
+    "\n",
+    "    epoch_time = []  # we'll keep track of the time needed for each epoch\n",
+    "\n",
+    "    for epoch in range(num_epochs):\n",
+    "        epoch_start = time.time()\n",
+    "        print(\"Epoch {}/{}\".format(epoch + 1, num_epochs))\n",
+    "        print(\"-\" * 10)\n",
+    "\n",
+    "        # Each epoch has a training and validation phase\n",
+    "        for phase in [\"train\", \"val\"]:\n",
+    "            if phase == \"train\":\n",
+    "                scheduler.step()\n",
+    "                model.train()  # Set model to training mode\n",
+    "            else:\n",
+    "                model.eval()  # Set model to evaluate mode\n",
+    "\n",
+    "            running_loss = 0.0\n",
+    "            running_corrects = 0\n",
+    "\n",
+    "            # Iterate over data.\n",
+    "            for inputs, labels in dataloaders[phase]:\n",
+    "                inputs = inputs.to(device)\n",
+    "                labels = labels.to(device)\n",
+    "\n",
+    "                # zero the parameter gradients\n",
+    "                optimizer.zero_grad()\n",
+    "\n",
+    "                # Forward\n",
+    "                # Track history if only in training phase\n",
+    "                with torch.set_grad_enabled(phase == \"train\"):\n",
+    "                    outputs = model(inputs)\n",
+    "                    _, preds = torch.max(outputs, 1)\n",
+    "                    loss = criterion(outputs, labels)\n",
+    "\n",
+    "                    # backward + optimize only if in training phase\n",
+    "                    if phase == \"train\":\n",
+    "                        loss.backward()\n",
+    "                        optimizer.step()\n",
+    "\n",
+    "                # Statistics\n",
+    "                running_loss += loss.item() * inputs.size(0)\n",
+    "                running_corrects += torch.sum(preds == labels.data)\n",
+    "\n",
+    "            epoch_loss = running_loss / dataset_sizes[phase]\n",
+    "            epoch_acc = running_corrects.double() / dataset_sizes[phase]\n",
+    "\n",
+    "            print(\"{} Loss: {:.4f} Acc: {:.4f}\".format(phase, epoch_loss, epoch_acc))\n",
+    "\n",
+    "            # Deep copy the model\n",
+    "            if phase == \"val\" and epoch_acc > best_acc:\n",
+    "                best_acc = epoch_acc\n",
+    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
+    "\n",
+    "        # Add the epoch time\n",
+    "        t_epoch = time.time() - epoch_start\n",
+    "        epoch_time.append(t_epoch)\n",
+    "        print()\n",
+    "\n",
+    "    time_elapsed = time.time() - since\n",
+    "    print(\n",
+    "        \"Training complete in {:.0f}m {:.0f}s\".format(\n",
+    "            time_elapsed // 60, time_elapsed % 60\n",
+    "        )\n",
+    "    )\n",
+    "    print(\"Best val Acc: {:4f}\".format(best_acc))\n",
+    "\n",
+    "    # Load best model weights\n",
+    "    model.load_state_dict(best_model_wts)\n",
+    "    return model, epoch_time\n",
+    "\n",
+    "\n",
+    "# Download a pre-trained ResNet18 model and freeze its weights\n",
+    "model = torchvision.models.resnet18(pretrained=True)\n",
+    "for param in model.parameters():\n",
+    "    param.requires_grad = False\n",
+    "\n",
+    "# Replace the final fully connected layer\n",
+    "# Parameters of newly constructed modules have requires_grad=True by default\n",
+    "num_ftrs = model.fc.in_features\n",
+    "model.fc = nn.Linear(num_ftrs, 2)\n",
+    "# Send the model to the GPU\n",
+    "model = model.to(device)\n",
+    "# Set the loss function\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "\n",
+    "# Observe that only the parameters of the final layer are being optimized\n",
+    "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n",
+    "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n",
+    "model, epoch_time = train_model(\n",
+    "    model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "VKrlJgX_fYPT",
+   "metadata": {
+    "id": "VKrlJgX_fYPT"
+   },
+   "source": [
+    "On a une bonne précision avec 96.24% en validation, on note égalmement une diminution régulière de la loss (0.73 à 0.28), et pas de surapprentissage significatif malgré le faible volume de données d'entraînement.\n",
+    "\n",
+    "On exploite bien les caractéristiques générales déjà apprises par le réseau tout en l'adaptant à la tâche spécifique. Grace au pré entrainement on peut avec très peu de donné créer un \"expert\", on illustre bien le transfert de données"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8UTdE8Lok-8P",
+   "metadata": {
+    "id": "8UTdE8Lok-8P"
+   },
+   "source": [
+    "Experiments:\n",
+    "Study the code and the results obtained.\n",
+    "\n",
+    "Modify the code and add an \"eval_model\" function to allow\n",
+    "the evaluation of the model on a test set (different from the learning and validation sets used during the learning phase). Study the results obtained.\n",
+    "\n",
+    "Now modify the code to replace the current classification layer with a set of two layers using a \"relu\" activation function for the middle layer, and the \"dropout\" mechanism for both layers. Renew the experiments and study the results obtained.\n",
+    "\n",
+    "Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "hqI1VwLLUoOH",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "hqI1VwLLUoOH",
+    "outputId": "b4108a1d-c554-4d4a-f514-cc0ad1475f4e"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 0.4259 Acc: 0.9500\n",
+      "\n",
+      "Test Accuracy (Overall): 95.00% (19/20)\n"
+     ]
+    }
+   ],
+   "source": [
+    "dataloaders = {\n",
+    "    x: torch.utils.data.DataLoader(\n",
+    "        image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n",
+    "    )\n",
+    "    for x in [\"train\", \"val\", \"test\"]  # Added \"test\" here\n",
+    "}\n",
+    "\n",
+    "def eval_model(model, dataloader, criterion, device):\n",
+    "    model.eval()\n",
+    "    running_loss = 0.0\n",
+    "    running_corrects = 0\n",
+    "\n",
+    "    for inputs, labels in dataloader:\n",
+    "        if device == 'cuda':\n",
+    "            inputs, labels = inputs.cuda(), labels.cuda()\n",
+    "\n",
+    "        output = model(inputs)\n",
+    "        loss = criterion(output, labels)\n",
+    "        running_loss += loss.item() * inputs.size(0)\n",
+    "\n",
+    "        _, preds = torch.max(output, 1)\n",
+    "        running_corrects += torch.sum(preds == labels.data)\n",
+    "\n",
+    "    epoch_loss = running_loss / len(dataloader.dataset)\n",
+    "    epoch_acc = running_corrects.double() / len(dataloader.dataset)\n",
+    "\n",
+    "    print(f'Test Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')\n",
+    "    print(f'\\nTest Accuracy (Overall): {100 * epoch_acc:.2f}% ({running_corrects}/{len(dataloader.dataset)})')\n",
+    "\n",
+    "    return epoch_loss, epoch_acc\n",
+    "\n",
+    "# Test the model\n",
+    "test_loss, test_acc = eval_model(model, dataloaders['test'], criterion, device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6KbMOxw_gB0f",
+   "metadata": {
+    "id": "6KbMOxw_gB0f"
+   },
+   "source": [
+    "Le modèle est aussi très bon sur des données non vus, on note tout de même que seulement 20 images pour le test est surement trop faible mais on a bien creer un modele robuste capable de reconnaitre des photos assez techniques d'abeilles et de fourmis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "qIcip1weabAp",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "qIcip1weabAp",
+    "outputId": "88f7c650-a65b-4704-d420-69104d6a92ed"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10\n",
+      "----------\n",
+      "train Loss: 0.7111 Acc: 0.5820\n",
+      "val Loss: 0.5263 Acc: 0.7293\n",
+      "\n",
+      "Epoch 2/10\n",
+      "----------\n",
+      "train Loss: 0.5914 Acc: 0.7008\n",
+      "val Loss: 0.6603 Acc: 0.5789\n",
+      "\n",
+      "Epoch 3/10\n",
+      "----------\n",
+      "train Loss: 0.5744 Acc: 0.7254\n",
+      "val Loss: 0.4083 Acc: 0.8195\n",
+      "\n",
+      "Epoch 4/10\n",
+      "----------\n",
+      "train Loss: 0.5968 Acc: 0.6721\n",
+      "val Loss: 0.2257 Acc: 0.9248\n",
+      "\n",
+      "Epoch 5/10\n",
+      "----------\n",
+      "train Loss: 0.5254 Acc: 0.7418\n",
+      "val Loss: 0.2284 Acc: 0.9474\n",
+      "\n",
+      "Epoch 6/10\n",
+      "----------\n",
+      "train Loss: 0.5449 Acc: 0.6803\n",
+      "val Loss: 0.2261 Acc: 0.9248\n",
+      "\n",
+      "Epoch 7/10\n",
+      "----------\n",
+      "train Loss: 0.5140 Acc: 0.7377\n",
+      "val Loss: 0.2079 Acc: 0.9474\n",
+      "\n",
+      "Epoch 8/10\n",
+      "----------\n",
+      "train Loss: 0.5525 Acc: 0.6885\n",
+      "val Loss: 0.2059 Acc: 0.9398\n",
+      "\n",
+      "Epoch 9/10\n",
+      "----------\n",
+      "train Loss: 0.4439 Acc: 0.7664\n",
+      "val Loss: 0.2141 Acc: 0.9398\n",
+      "\n",
+      "Epoch 10/10\n",
+      "----------\n",
+      "train Loss: 0.4431 Acc: 0.7787\n",
+      "val Loss: 0.1953 Acc: 0.9398\n",
+      "\n",
+      "Training complete in 6m 9s\n",
+      "Best val Acc: 0.947368\n",
+      "Test Loss: 0.2221 Acc: 0.9500\n",
+      "\n",
+      "Test Accuracy (Overall): 95.00% (19/20)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Chargement et gel du ResNet18 pré-entraîné\n",
+    "model_dropout = torchvision.models.resnet18(pretrained=True)\n",
+    "for param in model_dropout.parameters():\n",
+    "    param.requires_grad = False\n",
+    "\n",
+    "# On modifie la couche finale, on choisit encore des dropout de 0,5 comme pour l'exercice 1\n",
+    "# Et on choisit 512 sortie/entrés pour les Linear , en effet d'apres internet 1024 serait une limite d'overfitting\n",
+    "# et 256 une limite de compléxité (trop peu précis en dessous)\n",
+    "num_ftrs = model_dropout.fc.in_features\n",
+    "model_dropout.fc = nn.Sequential(\n",
+    "    nn.Linear(num_ftrs, 512),\n",
+    "    nn.ReLU(),\n",
+    "    nn.Dropout(0.5),\n",
+    "    nn.Linear(512, 2),\n",
+    "    nn.Dropout(0.5)\n",
+    ")\n",
+    "\n",
+    "# Configuration et entraînement\n",
+    "model_dropout = model_dropout.to(device)\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer_conv = optim.SGD(model_dropout.fc.parameters(), lr=0.001, momentum=0.9)\n",
+    "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n",
+    "\n",
+    "# Entraînement et évaluation\n",
+    "model_dropout, epoch_time = train_model(model_dropout, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10)\n",
+    "test_loss, test_acc = eval_model(model_dropout, dataloaders['test'], criterion, device)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "JLxxKyxFc21p",
+   "metadata": {
+    "id": "JLxxKyxFc21p"
+   },
+   "source": [
+    "On a rajouter un dropout et une architecture plus complexe à la couche finale. Les performances restent très bonne 94.74% en validation et 95% en test mais l'apprentissage est plus lent et la précision d'entraînement plus faible (77.87% avec / 85.66% sans).\n",
+    "\n",
+    "Le dropout combat efficacement l'overfitting en mais on perd un peu de capacité d'apprentissage, on ne peut le montrer la ( a cause d'un ensemble test trop faible ) mais on devrait observer une meilleure généralisation.\n",
+    "\n",
+    "On peut aussi questionner les valeur du nombre de sorties/entrées et le drop out qui mériteraient d'être affinés\n",
+    "\n",
+    "\n",
+    "\n",
+    "On réalise maintenant la quantification , de deux maniere différente , d'abord dynamiquement:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "_CgZ7gizb35W",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "_CgZ7gizb35W",
+    "outputId": "cbf3f980-c9fd-454d-a5ec-2aeba0c5830f"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 0.2214 Acc: 0.9500\n",
+      "\n",
+      "Test Accuracy (Overall): 95.00% (19/20)\n",
+      "model:  Original  \t Size (KB): 45831.61\n",
+      "model:  Quantized  \t Size (KB): 45043.622\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "45043622"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Quantification du modèle\n",
+    "model_quantized = torch.quantization.quantize_dynamic(\n",
+    "    model_dropout,\n",
+    "    dtype=torch.qint8\n",
+    ")\n",
+    "\n",
+    "# Évaluation performances\n",
+    "test_loss_quant, test_acc_quant = eval_model(model_quantized, dataloaders['test'], criterion, device)\n",
+    "\n",
+    "# Comparaison tailles\n",
+    "print_size_of_model(model_dropout, \"Original\")\n",
+    "print_size_of_model(model_quantized, \"Quantized\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "Emi9xhXAiOY3",
+   "metadata": {
+    "id": "Emi9xhXAiOY3"
+   },
+   "source": [
+    "On a toujours de bon résultat, cependant on note une très faible réduction de la taille, on va donc éssayer la quantization \"aware\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "96xMFn7Qc_HL",
+   "metadata": {
+    "id": "96xMFn7Qc_HL"
+   },
+   "source": [
+    "Ensuite on réalise la quantification \"aware\" QAT"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "tEVrLkiiiDvB",
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "tEVrLkiiiDvB",
+    "outputId": "12893cf1-c900-4a3f-b439-6c80c3e8cfe7"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/5\n",
+      "----------\n",
+      "train Loss: 0.5042 Acc: 0.7090\n",
+      "val Loss: 0.2422 Acc: 0.9474\n",
+      "\n",
+      "Epoch 2/5\n",
+      "----------\n",
+      "train Loss: 0.4781 Acc: 0.7500\n",
+      "val Loss: 0.2324 Acc: 0.9474\n",
+      "\n",
+      "Epoch 3/5\n",
+      "----------\n",
+      "train Loss: 0.5305 Acc: 0.7336\n",
+      "val Loss: 0.2463 Acc: 0.9474\n",
+      "\n",
+      "Epoch 4/5\n",
+      "----------\n",
+      "train Loss: 0.4709 Acc: 0.7746\n",
+      "val Loss: 0.2391 Acc: 0.9549\n",
+      "\n",
+      "Epoch 5/5\n",
+      "----------\n",
+      "train Loss: 0.4835 Acc: 0.7213\n",
+      "val Loss: 0.2582 Acc: 0.9398\n",
+      "\n",
+      "Training complete in 6m 21s\n",
+      "Best val Acc: 0.954887\n",
+      "model:  Original  \t Size (KB): 45831.61\n",
+      "model:  Dynamic Quantization  \t Size (KB): 45043.622\n",
+      "model:  QAT  \t Size (KB): 11660.218\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "11660218"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Préparation modèle pour QAT\n",
+    "model_qat = copy.deepcopy(model_dropout)\n",
+    "model_qat.train()  # Passage en mode entraînement\n",
+    "model_qat.qconfig = torch.quantization.get_default_qat_qconfig('fbgemm')\n",
+    "model_qat_prepared = torch.quantization.prepare_qat(model_qat)\n",
+    "\n",
+    "# Configuration\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.SGD(model_qat_prepared.parameters(), lr=0.0001, momentum=0.9)\n",
+    "scheduler = lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)\n",
+    "\n",
+    "# Entraînement QAT\n",
+    "model_qat_prepared, _ = train_model(model_qat_prepared, criterion, optimizer, scheduler, num_epochs=5)\n",
+    "\n",
+    "# Conversion finale\n",
+    "model_qat_prepared.eval()\n",
+    "model_qat_quantized = torch.quantization.convert(model_qat_prepared)\n",
+    "\n",
+    "# Comparaison tailles\n",
+    "print_size_of_model(model_dropout, \"Original\")\n",
+    "print_size_of_model(model_quantized, \"Dynamic Quantization\")\n",
+    "print_size_of_model(model_qat_quantized, \"QAT\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "SE3pYakQj-V2",
+   "metadata": {
+    "id": "SE3pYakQj-V2"
+   },
+   "source": [
+    "La QAT ne permet pas non plus une meilleur quantization , le modèle est surement trop petit pour etre efficacement quantizé"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04a263f0",
+   "metadata": {
+    "id": "04a263f0"
+   },
+   "source": [
+    "## Optional\n",
+    "    \n",
+    "Try this at home!!\n",
+    "\n",
+    "\n",
+    "Pytorch offers a framework to export a given CNN to your selfphone (either android or iOS). Have a look at the tutorial https://pytorch.org/mobile/home/\n",
+    "\n",
+    "The Exercise consists in deploying the CNN of Exercise 4 in your phone and then test it on live.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe954ce4",
+   "metadata": {
+    "id": "fe954ce4"
+   },
+   "source": [
+    "## Author\n",
+    "\n",
+    "Alberto BOSIO - Ph. D."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "9e3efbebb05da2d4a1968abe9a0645745f54b63feb7a85a514e4da0495be97eb"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
-- 
GitLab