From 014d91dd18c225942665d87b4420ce501ead5dab Mon Sep 17 00:00:00 2001
From: Sucio <esteban.cosserat@gmail.com>
Date: Fri, 17 Nov 2023 16:32:41 +0100
Subject: [PATCH] exercice1

---
 TD2 Deep Learning.ipynb            | 381 ++++++++++++-----------------
 result/comparaison_loss_models.png | Bin 0 -> 18366 bytes
 2 files changed, 156 insertions(+), 225 deletions(-)
 create mode 100644 result/comparaison_loss_models.png

diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index beeedea..8818c87 100644
--- a/TD2 Deep Learning.ipynb	
+++ b/TD2 Deep Learning.ipynb	
@@ -33,7 +33,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 70,
+   "execution_count": 2,
    "id": "330a42f5",
    "metadata": {},
    "outputs": [
@@ -53,7 +53,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -72,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 72,
+   "execution_count": 4,
    "id": "b1950f0a",
    "metadata": {},
    "outputs": [
@@ -80,40 +80,34 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([[ 1.1058e+00,  1.7336e+00,  1.6643e+00,  4.8814e-01,  1.0503e+00,\n",
-      "          3.3081e-01,  4.2909e-01,  2.5513e-01,  4.4685e-01,  1.2261e+00],\n",
-      "        [ 1.6754e+00,  2.5322e-01, -3.2846e-01,  8.9585e-01, -1.3316e+00,\n",
-      "          2.3624e-01,  5.5837e-01,  9.2219e-01,  5.8599e-01,  8.2756e-01],\n",
-      "        [-5.0919e-04,  5.2701e-01,  1.6103e+00, -1.1456e+00, -3.3717e-01,\n",
-      "         -1.9402e-01,  8.6480e-01, -1.5003e+00,  8.3813e-01, -1.2842e-01],\n",
-      "        [ 2.1325e+00,  4.6389e-02,  3.8270e-01, -4.7796e-01,  6.9516e-01,\n",
-      "          4.3799e-01,  1.4166e+00, -9.7244e-01, -4.0094e-02, -2.5280e+00],\n",
-      "        [-1.2872e+00, -3.9930e-01, -8.1700e-01, -1.0437e+00, -1.0481e+00,\n",
-      "          1.7232e+00, -1.6563e+00, -4.3769e-01,  1.3422e+00, -7.3623e-01],\n",
-      "        [-7.6558e-01, -8.4420e-01,  1.0399e-01, -2.7014e-01, -2.8180e-02,\n",
-      "         -9.6759e-01, -1.1035e-01,  6.1477e-01, -9.9411e-02, -1.2770e+00],\n",
-      "        [ 1.7107e-01, -1.4533e+00, -1.0981e-01,  9.6294e-01,  1.8770e-01,\n",
-      "          2.1585e-01,  8.4826e-01,  8.2598e-01,  5.2848e-01, -6.2572e-01],\n",
-      "        [-6.8073e-01,  1.5341e+00,  5.4558e-01,  1.1158e+00,  9.1971e-01,\n",
-      "         -1.0714e+00,  1.1650e-01,  5.2230e-01, -9.3863e-01,  5.0782e-01],\n",
-      "        [-8.9026e-02,  1.3079e-01, -1.3377e+00,  7.9199e-01,  1.4043e+00,\n",
-      "         -7.5685e-01,  8.6716e-01,  6.6349e-01, -4.2035e-01, -8.4952e-01],\n",
-      "        [ 3.0876e-01,  1.6299e+00,  1.0647e+00, -6.7523e-01, -2.7187e-01,\n",
-      "          6.6396e-01,  3.1289e-01, -1.8232e-01, -6.1341e-01, -3.0799e-01],\n",
-      "        [ 1.5986e-01,  4.0908e-01, -1.9692e-02,  1.2336e+00,  1.0539e-01,\n",
-      "          1.4811e+00, -1.7229e+00,  5.4524e-01,  3.1768e-01, -6.7840e-01],\n",
-      "        [-1.5905e-01, -1.8926e-01,  3.9945e-01,  2.6893e-01,  2.3556e-01,\n",
-      "          1.1111e+00,  4.4930e-01, -2.0415e-02,  9.0348e-01,  6.3381e-02],\n",
-      "        [-1.3243e+00,  6.9054e-01,  2.4535e-01,  1.2984e+00, -6.0229e-01,\n",
-      "         -8.0071e-01,  4.5005e-02,  1.3536e+00,  5.6984e-01, -1.2901e+00],\n",
-      "        [ 5.6000e-01,  1.6408e-01,  1.2537e+00, -1.4064e+00,  1.0504e+00,\n",
-      "          5.6275e-01, -1.2924e-01, -4.2453e-01,  1.2955e+00, -1.0917e-01]])\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
+      "tensor([[-1.8074e-01,  1.5241e+00, -1.3546e-01, -1.2838e+00,  2.2640e-01,\n",
+      "         -1.2553e-01, -1.6809e+00,  3.9784e-01, -9.4289e-02,  3.5530e-01],\n",
+      "        [-2.2709e-01,  7.5171e-01, -1.8169e+00,  6.3701e-01, -7.9855e-01,\n",
+      "          1.5751e+00, -9.2336e-01, -1.8218e-01, -6.2022e-02, -2.6735e+00],\n",
+      "        [-2.3175e-01,  1.2065e-01,  9.2158e-01,  4.0761e-01,  5.0920e-01,\n",
+      "         -2.0830e-01,  5.9477e-01, -2.4526e+00,  1.5291e+00,  1.2228e-01],\n",
+      "        [ 6.3699e-02,  8.3339e-01, -2.4348e-01, -2.7755e+00, -3.5887e-02,\n",
+      "          4.2460e-01,  1.1398e-01, -8.2430e-01, -6.5116e-01, -1.5914e+00],\n",
+      "        [ 1.8005e+00,  1.0883e+00,  1.3797e+00, -1.8554e-01,  9.3593e-02,\n",
+      "         -4.3051e-01,  2.5463e-01,  2.0544e+00, -2.0729e-01, -1.1623e+00],\n",
+      "        [-2.8985e-01,  2.0965e+00,  9.4812e-01,  5.9547e-01, -1.7109e+00,\n",
+      "         -4.6174e-01,  4.5153e-01, -6.9997e-01, -1.5717e+00,  1.0125e+00],\n",
+      "        [-4.8650e-01,  4.6680e-01,  1.5609e+00,  4.5947e-01,  5.7850e-01,\n",
+      "         -2.8709e-01, -2.5730e-01,  1.0270e+00, -1.7424e+00,  1.7485e+00],\n",
+      "        [ 1.1762e+00,  5.2229e-01, -3.9036e-01,  1.1959e+00, -1.7538e+00,\n",
+      "         -4.4158e-01, -7.4067e-01,  3.9571e-01,  2.0077e+00, -8.1235e-01],\n",
+      "        [-1.6999e+00, -4.1551e-02,  1.3648e+00, -1.2220e+00, -2.0506e-01,\n",
+      "          7.1548e-01,  3.5882e-01, -1.5645e-01, -5.0942e-01, -6.1326e-02],\n",
+      "        [ 1.6581e+00, -8.4809e-01,  4.7475e-01, -2.2561e+00,  3.8582e-02,\n",
+      "         -1.0277e+00, -6.0917e-01,  1.5007e+00,  1.9578e+00,  2.0218e-01],\n",
+      "        [ 1.4928e+00,  2.2087e-01,  5.0907e-01, -1.5857e+00, -8.4575e-01,\n",
+      "          8.6924e-01, -8.6839e-01,  6.0105e-01, -3.6015e-01, -6.4565e-01],\n",
+      "        [ 9.0478e-01, -2.6878e-01, -2.1540e-02,  1.2220e+00,  8.8916e-02,\n",
+      "          7.9812e-01, -1.0435e+00, -4.6728e-01, -1.9995e+00,  1.3223e+00],\n",
+      "        [-8.4984e-01, -3.3195e-01,  1.2790e+00,  2.2619e-02, -1.0025e+00,\n",
+      "         -1.9617e-01,  2.2083e-01,  1.0495e-03, -2.6835e+00, -9.3611e-01],\n",
+      "        [ 1.7703e-01, -1.7832e+00,  2.5483e+00, -2.5165e+00, -2.1459e-01,\n",
+      "         -1.1852e+00,  3.9559e-01, -1.2278e+00,  1.0694e-01,  4.8980e-02]])\n",
       "AlexNet(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
@@ -183,7 +177,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 73,
+   "execution_count": 5,
    "id": "6e18f2fd",
    "metadata": {},
    "outputs": [
@@ -217,7 +211,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": 6,
    "id": "462666a2",
    "metadata": {},
    "outputs": [
@@ -298,7 +292,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": 7,
    "id": "317bf070",
    "metadata": {},
    "outputs": [
@@ -362,7 +356,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 76,
+   "execution_count": 8,
    "id": "4b53f229",
    "metadata": {},
    "outputs": [
@@ -370,25 +364,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch: 0 \tTraining Loss: 45.068168 \tValidation Loss: 41.658336\n",
-      "Validation loss decreased (inf --> 41.658336).  Saving model ...\n",
-      "Epoch: 1 \tTraining Loss: 36.543189 \tValidation Loss: 33.181536\n",
-      "Validation loss decreased (41.658336 --> 33.181536).  Saving model ...\n",
-      "Epoch: 2 \tTraining Loss: 31.468431 \tValidation Loss: 29.895601\n",
-      "Validation loss decreased (33.181536 --> 29.895601).  Saving model ...\n",
-      "Epoch: 3 \tTraining Loss: 28.879008 \tValidation Loss: 27.669525\n",
-      "Validation loss decreased (29.895601 --> 27.669525).  Saving model ...\n",
-      "Epoch: 4 \tTraining Loss: 26.925435 \tValidation Loss: 26.301845\n",
-      "Validation loss decreased (27.669525 --> 26.301845).  Saving model ...\n",
-      "Epoch: 5 \tTraining Loss: 25.447193 \tValidation Loss: 25.830709\n",
-      "Validation loss decreased (26.301845 --> 25.830709).  Saving model ...\n",
-      "Epoch: 6 \tTraining Loss: 24.231406 \tValidation Loss: 24.478850\n",
-      "Validation loss decreased (25.830709 --> 24.478850).  Saving model ...\n",
-      "Epoch: 7 \tTraining Loss: 23.158099 \tValidation Loss: 25.051581\n",
-      "Epoch: 8 \tTraining Loss: 22.216344 \tValidation Loss: 23.490295\n",
-      "Validation loss decreased (24.478850 --> 23.490295).  Saving model ...\n",
-      "Epoch: 9 \tTraining Loss: 21.386869 \tValidation Loss: 22.800535\n",
-      "Validation loss decreased (23.490295 --> 22.800535).  Saving model ...\n"
+      "Couldn't find program: 'false'\n"
      ]
     }
    ],
@@ -398,8 +374,8 @@
     "criterion = nn.CrossEntropyLoss()  # specify loss function\n",
     "optimizer = optim.SGD(model.parameters(), lr=0.01)  # specify optimizer\n",
     "\n",
-    "n_epochs = 10  # number of epochs to train the model\n",
-    "train_loss_list = []  # list to store loss to visualize\n",
+    "n_epochs = 20  # number of epochs to train the model\n",
+    "train_loss_list_Net = []  # list to store loss to visualize\n",
     "valid_loss_min = np.Inf  # track change in validation loss\n",
     "\n",
     "for epoch in range(n_epochs):\n",
@@ -442,7 +418,7 @@
     "    # 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",
+    "    train_loss_list_Net.append(train_loss)\n",
     "\n",
     "    # Print training/validation statistics\n",
     "    print(\n",
@@ -472,25 +448,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 77,
+   "execution_count": 10,
    "id": "d39df818",
    "metadata": {},
    "outputs": [
     {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Couldn't find program: 'false'\n"
+     ]
     }
    ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
-    "plt.plot(range(n_epochs), train_loss_list)\n",
+    "plt.plot(range(n_epochs), train_loss_list_Net)\n",
     "plt.xlabel(\"Epoch\")\n",
     "plt.ylabel(\"Loss\")\n",
     "plt.title(\"Performance of Model 1\")\n",
@@ -507,7 +480,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 78,
+   "execution_count": 12,
    "id": "e93efdfc",
    "metadata": {},
    "outputs": [
@@ -533,12 +506,12 @@
     }
    ],
    "source": [
-    "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
+    "model.load_state_dict(torch.load(\"model_cifar.pt\"))\n",
     "\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",
+    "class_correct_NET = list(0.0 for i in range(10))\n",
+    "class_total_NET = list(0.0 for i in range(10))\n",
     "\n",
     "import torch.optim as optim\n",
     "\n",
@@ -570,22 +543,22 @@
     "    # 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",
+    "        class_correct_NET[label] += correct[i].item()\n",
+    "        class_total_NET[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",
+    "    if class_total_NET[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",
+    "                100 * class_correct_NET[i] / class_total_NET[i],\n",
+    "                np.sum(class_correct_NET[i]),\n",
+    "                np.sum(class_total_NET[i]),\n",
     "            )\n",
     "        )\n",
     "    else:\n",
@@ -594,9 +567,9 @@
     "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",
+    "        100.0 * np.sum(class_correct_NET) / np.sum(class_total_NET),\n",
+    "        np.sum(class_correct_NET),\n",
+    "        np.sum(class_total_NET),\n",
     "    )\n",
     ")"
    ]
@@ -620,7 +593,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 79,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -652,49 +625,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "newNet(\n",
-      "  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1))\n",
-      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
-      "  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n",
-      "  (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1))\n",
-      "  (fc1): Linear(in_features=256, 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",
-      "  (dropout): Dropout(p=0.5, inplace=False)\n",
-      ")\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Epoch: 0 \tTraining Loss: 45.997170 \tValidation Loss: 45.813581\n",
-      "Validation loss decreased (inf --> 45.813581).  Saving model ...\n",
-      "Epoch: 1 \tTraining Loss: 43.447996 \tValidation Loss: 39.434123\n",
-      "Validation loss decreased (45.813581 --> 39.434123).  Saving model ...\n",
-      "Epoch: 2 \tTraining Loss: 37.817678 \tValidation Loss: 33.835315\n",
-      "Validation loss decreased (39.434123 --> 33.835315).  Saving model ...\n",
-      "Epoch: 3 \tTraining Loss: 34.411652 \tValidation Loss: 32.083492\n",
-      "Validation loss decreased (33.835315 --> 32.083492).  Saving model ...\n",
-      "Epoch: 4 \tTraining Loss: 32.522201 \tValidation Loss: 29.788260\n",
-      "Validation loss decreased (32.083492 --> 29.788260).  Saving model ...\n",
-      "Epoch: 5 \tTraining Loss: 30.807354 \tValidation Loss: 28.055189\n",
-      "Validation loss decreased (29.788260 --> 28.055189).  Saving model ...\n",
-      "Epoch: 6 \tTraining Loss: 29.412794 \tValidation Loss: 27.665930\n",
-      "Validation loss decreased (28.055189 --> 27.665930).  Saving model ...\n",
-      "Epoch: 7 \tTraining Loss: 28.139727 \tValidation Loss: 25.605682\n",
-      "Validation loss decreased (27.665930 --> 25.605682).  Saving model ...\n",
-      "Epoch: 8 \tTraining Loss: 27.044169 \tValidation Loss: 25.173172\n",
-      "Validation loss decreased (25.605682 --> 25.173172).  Saving model ...\n",
-      "Epoch: 9 \tTraining Loss: 25.927621 \tValidation Loss: 23.948350\n",
-      "Validation loss decreased (25.173172 --> 23.948350).  Saving model ...\n"
+      "Couldn't find program: 'false'\n"
      ]
     }
    ],
@@ -712,8 +650,8 @@
     "    criterion = nn.CrossEntropyLoss()  # specify loss function\n",
     "    optimizer = optim.SGD(model.parameters(), lr=0.01)  # specify optimizer\n",
     "\n",
-    "    n_epochs = 10  # number of epochs to train the model\n",
-    "    train_loss_list = []  # list to store loss to visualize\n",
+    "    n_epochs = 20  # number of epochs to train the model\n",
+    "    train_loss_list_newNet = []  # list to store loss to visualize\n",
     "    valid_loss_min = np.Inf  # track change in validation loss\n",
     "\n",
     "    for epoch in range(n_epochs):\n",
@@ -756,7 +694,7 @@
     "        # 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",
+    "        train_loss_list_newNet.append(train_loss)\n",
     "\n",
     "        # Print training/validation statistics\n",
     "        print(\n",
@@ -778,37 +716,91 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Test Loss: 23.851512\n",
-      "\n",
-      "Test Accuracy of airplane: 53% (537/1000)\n",
-      "Test Accuracy of automobile: 65% (658/1000)\n",
-      "Test Accuracy of  bird: 41% (413/1000)\n",
-      "Test Accuracy of   cat: 43% (439/1000)\n",
-      "Test Accuracy of  deer: 33% (338/1000)\n",
-      "Test Accuracy of   dog: 39% (395/1000)\n",
-      "Test Accuracy of  frog: 82% (826/1000)\n",
-      "Test Accuracy of horse: 57% (575/1000)\n",
-      "Test Accuracy of  ship: 76% (769/1000)\n",
-      "Test Accuracy of truck: 76% (762/1000)\n",
-      "\n",
-      "Test Accuracy (Overall): 57% (5712/10000)\n"
+      "Couldn't find program: 'false'\n"
      ]
     }
    ],
    "source": [
-    "model.load_state_dict(torch.load(\"./my_model_cifar.pt\"))\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "plt.plot(range(n_epochs), train_loss_list_Net,label='Net')\n",
+    "plt.plot(range(n_epochs), train_loss_list_newNet,label='newNet')\n",
+    "plt.xlabel(\"Epoch\")\n",
+    "plt.ylabel(\"Loss\")\n",
+    "plt.title(\"Performance of Model 1\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdwAAAGFCAYAAABXIkLKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACAaUlEQVR4nOzdd3hUZdrH8e+ZnplMeu8dQiAQei8KCAhYsGLX3VVfu7vuuta1oau7rmsva18LiCgqKr0J0nsJgZAQSO89k8zMef84JAsCSglp3J/rmkuZzJx5ZiaZ3zzl3I+iqqqKEEIIIc4qXXs3QAghhDgXSOAKIYQQbUACVwghhGgDErhCCCFEG5DAFUIIIdqABK4QQgjRBiRwhRBCiDYggSuEEEK0AQlcIYQQog1I4AohhBBtQAJXCCGEaAMSuEIIIUQbkMAVQggh2oAErhBCCNEGJHCFEEKINiCBK4QQQrQBCVzRJTidTqqrq1suNTU1NDQ04Ha7z+i4LpeLl156if79+zNgwABWrVrVSi3umlRVJTMzk9tuu42UlBQmTJhAfX39Ubdxu93U1dVRXV2N0+k85v41NTXU1NQc87NTUVBQwLBhw1i9evVJ3b6wsJC0tDSWL19+wts0Nja2tLuuru6Mf7fEuUcCV3QJy5YtIyYmhp49e9KvXz+GDRvG1VdfzerVq8/og3HlypXMmDGDq6++mueee47u3bu3Yqu7HofDwQcffMCuXbt4+OGHeeSRRzCZTEfd5uDBg1x++eV4e3sze/ZsVFVt+VlpaSmxsbGkpKSwaNGi026Hy+WiuLiYxsbGk759UVHRr95+xowZTJgwgfj4eC699FIOHTp02u0T5yZDezdAiNZiNBp5/vnniY6OpqCggFdffZU777yTb7/9lsjIyFM6VnNIb9u2DavVyr333oterz/lNqmqitvtRqfToSjKKd+/s6muriY7O5sLLriASy+9FIvFcsLbRkRE8Pnnn3PFFVe0vDY//PADOp0ODw+Po4K4I3A4HIwcOZKoqChKSkrauzmiE5LAFV2GTqejZ8+epKSkANDU1MTdd9/Njh07iIyMZNu2bcyePZvc3FzCwsK4/PLLSUlJQa/Xs2nTJr766isuuugivv/+e2pqajAajfzwww+UlpZyww030Lt3b2666Sa8vb2ZNWsWq1evRlVVBgwYwPTp0zGbzQC89tprNDY2kpqayrfffktycjIDBw7ko48+YurUqaxZs4asrCwGDBjAtddey+7du/niiy8oKytj0qRJTJ48Gb1ej9vtZsGCBfz0008UFBTg5eXF1KlTGT16dMtzfvzxx4mKiiIwMJD58+djNBq55pprGDBgAKAFfnl5OZ999hnbt29Hp9ORmprKddddh81mw+VysWjRIn788UdqampITk5m+vTpBAcHn/ALwv79+5k9ezZ79uwhMDCQqVOnMmDAAJqamnj22WdZsWIFO3fuZPfu3Vx88cVcdtllxz3OpEmT+PHHH8nMzCQxMRGXy8XMmTOZMGECW7dubbmdqqpkZ2czc+ZM9u3bh7+/PxdffDGDBw9GURRUVaWsrIyPPvqI3bt3Ex0dzeTJk496rOah7lmzZrF//358fX257LLLGDRo0En/fj366KOYTCbee+895syZc9L3E6KZDCmLLqe5V+lwOFAUBb1ez6pVq7jtttvYvXs3YWFhbN68md/97ndkZ2ejqiqHDh1i9uzZ/P73v6ewsJCwsDAiIyMJCQnBbDbTu3dv4uLiMBqN/P3vf+fRRx9tmSN++umn+dvf/tbSI1u1ahXvvPMOTz75JB4eHnh5eVFUVMS7777LjBkzOHjwIIqi8NRTT/HXv/6VV199FZfLRUlJCY899ljLvKPL5eKNN96grKyM8PBwsrKyuP3221myZEnLc/3+++95+eWXeffdd/Hx8WHTpk3cfffd5OfnA1BfX89NN93E66+/jtlsxtvbm++++46CggLcbjfvvvsuf/zjH2loaMDf358vvviCe+6555h51+bXdf/+/TzwwAPMmjWLwMBA0tPTue2221i7di06nY7Y2Fh8fHwICwujV69ehISEnPB96tmzJ3FxcXz33XeoqsqOHTtIT0/niiuuOOoxS0pKuO222/jmm2/w8/Nj586d3HHHHSxatAhVVXG5XPz1r3/lP//5D2azmT179vDHP/7xqMc6dOgQ1113HatWrSI0NJT9+/dz6623snz58pPuSVut1nNilEKcRaoQXcDChQvV4OBg9fPPP1dXr16tfvzxx2pKSoo6cuRINTs7W73pppvUu+++W62qqlIdDoeal5enXnDBBeoDDzygut1ude7cuWpISIj67LPPqg6HQ3U6narL5VKfeeYZNS4uTnW5XKrL5VLT09PVqKgo9YUXXlCbmppUp9Opvvnmm2p4eLi6fv16VVVV9eqrr1b9/f3VjRs3thxn+fLlqqenp/rEE0+ojY2NalNTkzp9+nQ1IiJCnT17tup0OtWKigp10KBB6hNPPKG63W7V7XarNTU1alNTk9rU1KQ2NDSol156qXrDDTeoLpdLVVVV7du3r5qWlqZmZmaqTqdTLSgoUKOjo9WPPvpIVVVVfeWVV9TIyEh17dq1qtPpVJ1Op9rY2Ki6XC51x44d6ogRI9RPP/1Ura+vVx0Oh7p69Wo1KSlJ/eGHH455jZ1Op/rWW2+pPXv2VLdv3646nU41Ly9Pveqqq9Srr75ara2tVQ8dOqROmzZN/fvf/67W1dWpbrf7mONkZ2erkyZNUl9//XX1jTfeUMeOHatWV1erM2bMUC+55BJ1x44dau/evdXvv/9edbvd6htvvKH26tVLXbNmjep0OtWqqip18uTJ6g033KCWl5era9euVUNCQtTPPvtMdTqdalNTk/r73/9eTUxMVJcuXaq63W71D3/4g3rRRRep5eXlqsPhUGtra9UrrrhCvf7669WGhgY1NzdXDQsLUxcsWPCrv2fNr8EFF1ygHjhw4Ex/bcU5RoaURZfR1NTEiy++iM1mw2QyMXz4cO666y6qq6tJT0+nf//+fPrppy29lMbGRtavX9/Sw/Hw8GDSpEkYjcaW2yiKctRl48aNOBwOpk+fjsGg/flcddVVPPHEE2zYsIH+/fsDkJSURFpa2lHH8fHxYdiwYRiNRlRVJTU1lX379tG7d2/0ej0mk4m4uDhKS0txuVzo9XrKy8vZvn07JSUl1NfXo6oqubm51NfXY7PZ0Ov1pKSkEBcXB4C/vz8REREUFBQAsHjxYtLS0hg4cGDL69Q8F713715KSkrYv38/H330Uctr0tTUxNq1a5kwYcJRr29tbS27du1iyJAhhIeHo9frCQ0NZciQIbz99ts0NTW1zFUrinJS89YTJkzggw8+YP78+axatYorr7wSne7ogbfly5fTrVs3+vbti16vx2q1cuWVV/LWW2+Rn5/PihUr8PHxYfz48ej1elRV5brrrmPZsmUtvxeLFy+mb9++zJo1C9B6zjqdjkOHDlFUVHRa8/NCnCoJXNFlmEwmZsyYQVJSEmazGT8/P/R6PRs3bqS2tpacnJyjTjXp3r07ERERLaHg7e2N2Wz+1ZCoqqpCVVUCAgJarrPb7ZjNZqqrq1uuCw4OPua+er0eu93e8m+LxYLZbMZqtQJaKFssFhobG3G5XJSXl3P//fdTXl5OREQEFouFoqIijEYjTU1NLffx9fU96nHMZjMNDQ0AlJeXk5SUdNznUldXR21tLenp6eTm5rZcP2HCBHr16nXM7Z1OJzU1Nfj5+WE0Gluu9/Lyor6+/rRWg/v5+ZGamsobb7yBy+Vi2LBhx6wUrqysJDQ0tOUxdTodAQEB1NfX43A4KC8vx2Aw4O3t3XKfoKCglv+vra2ltraWoqIitmzZ0nK9r68vAwYMwGKxtLyeQpxNEriiy1AUhZCQkGNWJHt4eODp6ckll1zClClTjupBHdmzOZkemY+PD4qiUFhY2PI4lZWVNDQ04OPjc9zjAi296FOZA1y2bBkbN27ks88+Iy4uDr1ez1NPPcXmzZuPed4nEhgYSG5uLqqqttyuuS1WqxW73c4999xDQkLCUfdrXgB2JKPRiJeXF6WlpTQ2NrYcp6KiApvNdkzP9GSYzWbGjRvHjTfeyHXXXYe/v3/L/HMzPz8/ysvLaWpqwmg04na7KSgowGazYbFYCAgIoKmpifLy8pYvQkcew2az4enpybBhw3jggQeOOrbBYMDDw4PCwsJTbrsQp0oWTYkuLyoqit69e/PZZ59RX1+PyWRq+eCuqak5pWMNGjQIu93OO++801Jk45133sFisTBkyJAT3u90Fts4HA70ej0BAQFYrVZqamqYN2/eKR1j0qRJbN26lYULF1JTU0NtbS0VFRW4XC6Sk5MJDAxk7ty5qKqKyWTCYDBQX19/3B6fzWajd+/erFmzhoyMDOrq6sjMzGT58uUMGjTomPNtT4Zer2f48OE899xz/OEPfzhqBKDZ+PHjycjIYPny5S091U8++YTk5GTCw8M5//zzqa6uZs6cOdTU1FBVVcXbb7/dcn+j0cjkyZNZuHAhhYWFGI1GjEYjLpeL6urqkx5Odjgc1NbW0tjYiNPpbBkhkAIY4mRJD1d0eXa7nd///vc8+uijXH311fTs2RPQ5jAvu+wy/vCHP5z0sWJjY7n33nt5/fXX2bNnD3q9nq1bt/J///d/LcdtLaNGjcLX15dbb72V7t27s2/fPqKiok6pAtPVV1/NypUr+dOf/kS/fv2w2Wzk5OTw8ssvk5SUxO23384LL7zA9u3biYyMpK6ujt27d/P666/Tp0+fo46l0+k477zzWLFiBXfddRf9+vXjwIED1NbW8sgjj/zqObe/JjQ0lLvuuuuEP588eTI//PADjz32GL169SIrKwun08n111+P3W4nJSWF6dOn8+qrr7Jq1SocDgcul6vl/oqi8Je//IXf/e533HzzzaSmpqIoCgcPHiQtLY0nn3zypNr54Ycfsnr1ajIyMjhw4ACPPvoogYGBPPjgg0RFRZ3WcxfnFglc0SU0B2FgYOBxf56WlsYrr7zCkiVLyM3NxWw2M2rUKEaMGAFoi5xuueUW/Pz8jrrfsGHDjgmSW2+9ldjYWLZt24aqqlx11VVHLTC6+OKLj/rAB4iMjOSuu+4iLCys5bqBAwdis9laenUGg4HJkydjMBjQ6/VERETw+uuvs2zZMpqamrjwwgux2+3s2bOnZcj3pptuIjo6uuWYOp2Oa6+9ltjYWEAbsv3Xv/7FDz/8QGZmJnq9njFjxhASEoKiKFx22WXExcWxatUqKisrsdvtTJs27YTzvpGRkTzxxBMsWrSIAwcO0KNHD0aPHk2PHj1QFAVPT0+mTZtGRETECXuO3t7eXHXVVXTr1u24PX9/f39+//vfEx8f3zJH/Y9//IMFCxZw8OBBevTowZgxY1rmmXU6HQ8//DC9e/cmOzub0NBQxo0bx5w5c1pem+DgYN5+++2WdhuNRoYNG9YyKuHp6ck999zT8rodj5+fH5GRkUdNWVgsltPq2Ytzk6KqHaycixBCCNEFyRyuEEII0QYkcIUQQog2IIErhBBCtAEJXCGEEKINdOlVyurhXUR0Ot1pnZQvhBBCgFZpzWg0YrfbT3sTiy69Srmmpobp06ezY8cOWbovhBDitKiqSm1tLddddx2PP/74aZ9z3qV7uM21V2fOnNmyR6oQQghxKlRVZc6cOS3Fbk5Xlw7cZhaLBQ8PD9nLUgghxClzu90txWbOJEdkYlMIIYRoA+dED1cIIbq6Lrwcp80drxfbGq+vBK4QQnRyqqricDhwOByye9EZ0Ol0mM3m4+6L3RpTkhK4QgjRydXV1VFcXIxOp8NgkI/10+V0OnG73QQGBmKz2Vr9+PLOCCFEJ+Z2uyktLcViseDv7y81B85A82tZUlKCh4dHq7+WErhCCNGJuVwumpqa8Pf3bzkVUpwevV6Pl5cX+fn5uFyuVg9c+SokhBBdgPRsW0fz63g2FqHJOySEEEK0AQlcIYQQrS4zM5NHH32Ujz/+mKamJgAKCgp4+umnKSsr+9X7vvnmmyxatKgtmtmmJHBPhuqGgh3Q1NDeLRFCiE6huLiYuXPn8sgjj1BcXAxAZWUl33zzDbW1taiqitvtxuVy4XK5cLvdqKqKqqosXryY7du3t1zfVUjgnoytM+G/l8KmD0BOLhdCdGDNoeU+i5eTnd9MSkoiKiqKf/3rX7hcrqN+VlJSwnPPPcewYcMYOnQoDz/8MKWlpXz66aesWrWKZ599luTkZP71r3+djZfplEnhi7YS0gs8fGH9u9B9CniHt3eLhBDiuNyqys+ZpZTUOM7K8c1GPeN7BKM/iUIQOp2Oe++9l6eeeoqrrroKT09PQFtZPWfOHPbt28c777yDyWTi2Wef5dVXX+XBBx/kyy+/ZODAgdx6662nvTNPa+uyhS+KioqYPXs2drudq666isLCQj7++GPKy8sBsFqtTJ06lb59+7ZNg4KSIXkKrHkDtnwKI+4H3envGCGEEGeLy63y6tJ9rNn/6/Okp0WFALuJMd2C0J/k+GiPHj2YNm0ar732GnfccQegFZj48ssvsVqtzJw5E1VVqa6uZtOmTTidTgwGAx4eHvj6+rb+c2hHHS5wGxsbmT9/Pm+++Sa9e/dm2rRpFBYWsmTJEiZNmkRUVBRms5mAgIC2a5ROD/1v1sI24wdInqyFsBBCdDAGnY4HJ3Snor7prBzfqNdh1J9ab+/666/n1ltvZcWKFYA2PFteXk6fPn1atk5NSUkhJCSkS59L3KECV1VVdu/ezZIlSxg/fjwVFRUtP/Py8qJ///6kpKRgsVhOOMzQPM7ePI/RaudS2UNh0O2w7BnY8yP4J4C+6/5iCCE6J0WB3pE+7d2Mo4SFhXHxxRfz2WefUVpaik6nIzExkYCAAC6++GL0en3LHK/JZMJkMtHY2Ijb7UZRlA6xtWqXm8MtKSnhxRdf5KqrriIrK4tNmzYB2hvQ0NDA448/jsVioWfPntxxxx1ER0cfc4xDhw6xY8cO3G43TU1NFBUVnXG7mlxuKuqa8Eyehse2zyD9W+g2AQK7a7/dQgjRQXSEcPolo9HI2LFj+fLLL8nOzsZoNHLzzTfz4osv4na7iYyMJD8/n8DAQG644Qb69OnDqlWriI+Pp3v37vTo0aO9n0LXmsOtr6/n5ZdfpmfPnowfP5633nqr5WdRUVHMmDEDPz8/iouLefHFF3nrrbd4/PHHWzYFbpaXl8eSJUtoamrC5XK1LEc/E1sPVvDZuhwm9wxgTN8bYPFTsG8x+MeD3nTGxxdCiK4mLCyMiy66CH9/fwCio6O577776NevH15eXowcORKr1crKlStJT08nJCSEfv36AXDddddhNptZv349Hh4eHSJwW0OHCdwDBw7wxRdfEBUVxdq1a8nMzKSiooLbb7+d999/n969ewMQHh7ONddcw5tvvklFRQXBwcFHHWfAgAEti6kaGxvJyso647ZV1jexcm8JRr2OMSPHwM6vYOP70PNSbai5A36jFEKI9hQVFcU111zT8m+j0cikSZOYNGlSy3VDhw5l6NChx9w3ODiYu+66q03a2ZY6TOCGhYXx9ttv09CgFZf49ttv2bdvH9OnT0dVVVwuF4qi4HK5KCwsxGQyHXcbKp1O11IL0+12t0p90Z5h3vhYjazNKqVh8lAsSRNhxd8Pr1j+4xkfXwghRMfWpeZw7XY7I0aMaPn3vn37qK+vZ+jQoaxevZqNGzeSkJBAbm4uH3/8Mbfccgt+fn5t0rYgLzNJwXZW7ytlW14tA5Mna/O4a9+G1CvBJ7JN2iGEEKJ9tMYcboepNNW8Eq35kpyczPDhwzEajfj4+FBSUsL3339PdnY2jz76KNdcc02bLQ5QFIWh8QE0utxszC4DvzhIngpNtbDuHXCdneX3Qgghuo4O08P9pTFjxrT8f69evejVq1c7tgaGxPvhVlW25VbS4HRjSb0Stn4GGT9CyiUQntau7RNCCNGxdZgebkcX6Wsl2t/GofJ6DpXXg2cQDLoNyrNg11xwnp0yakIIIboGCdyTpNcpjE4KoLCqgb2F1aig9WyDUmDvAijYLhsbCCGEOCEJ3FMwPDGQirpG9hZV43KrYLLB4NugPBsyFoBTtu8TQghxfBK4pyAh0JNAu4W9hTWU1zWBooPoYRA1GLbP0oJXerlCCHFWzZkzh8cee+yojewXLlzI3Llzf/X0HVVV2bFjBx9++CFOp7MtmnoUCdyTpCgKVrOevtE+ZBRWa1tfKYpW+KLHRVBfrp2XiwSuEEKcTfPmzeP555/n/fffb7lu+fLlzJ8//zfvu3v3bmbOnCmB29FZjHoGxPixv6SWvIp67ZuU3gAJ50FoH9j4AZRlt3MrhRDnNFVtm8tvWLFiBbfccguPPfYYAwcOZOLEiSxatAi3282hQ4e45ZZbSEtLY/z48cybN4+mpiZmzZrFI488QnV1NUVFRfTq1Yt3330XVVX58ssvj6pcdemll/Luu++yf//+Yx67qamJL7/8kvHjx9O7d2/uvPNOMjIyKCgo4E9/+hPLly8nJSWFG2+8kZqampN8WbtQ4YvOwKBTSAryxMtiZHNOOcMTAjAb9eAVoS2gyt8Mq16CC/8hNZaFEO1DVSF/izbqdjboTRA9FJRf3xO8qamJn3/+mSuuuIJPP/2UOXPm8O677xITE8Mf//hHhg0bxkMPPcSuXbt46KGHSEhIICgoiLy8PEpKSsjIyKCyspL09HQaGhpYvHgxPXv2bDn+gAED8PHx4Y033uDpp58+6rEXL17MzJkzeeCBB4iLi+O9997jjTfe4OGHH+aJJ57gk08+4cMPP8TT0xObzXZST7tLbV7QGSiKQpCXhfhAG+uyy2l0ubXAVRRtj9xtn8PehZC7SZvXFUKItuZ2wsJHIfun1j+2inZK5L3btX3Cf0N0dDRXXnklCQkJjBkzhg0bNrB06VK2bdvG6NGj+f777wFwuVwsWbKE888/H4fDQWlpKatWrWLy5Mk4nU4OHDjA+vXrmT59esuxFUXh97//PQ8//HDLznLwv6BvbGxkx44dpKenU1tby/bt26moqMBms2E0GvHz8zvhNq9niwTuKQqym4kP8mTuljzKahvxNBu0bz62ABh0K8y5FbZ+DiG9tFXMQgjRlnR6GH4/9Ln27BzfaNGm0k6Cr69vy45uBoP2WXno0CGMRiMm0/9GAW+99Vb69+9PaGgoNpuNffv2sWLFCv7yl7+wdOlSli9fjsPhoE+fPkcdPzExkaFDhzJ37lzq6+sBcDgclJeX4+HhgcFgQKfTkZCQQJ8+fdqsHPCJSOCeIpvZQFKwHYCNB8qJ8rP+74dJF0B4f8haofVyY4bLTkJCiLal6CB+zG/f7swe5ORudZzPv4iICNxuNxdeeCGhoaGANj9qMBjQ6/UkJCTw3XffUVFRwciRI1m7di1ff/01vXr1wmq1HnUsDw8PJkyYwNNPP019fT3x8fFYLBYCAwPR6/VMnz4du93eMv9qNBoxGo0tG+I0X99WZYJl0dQpUhSFbiF2AjzNLN79i83tDR4w4j6oyoP078BR3T6NFEKcuxRFC92zejn9gOrXrx8TJkzg3nvv5ZtvvuGHH37g73//O+np6SiKQs+ePVm1ahWDBw/GarUSFxfHhg0bGDx48HGDMTU1lb59+7JmzRqampowGAxMnDiRvXv38tprr7Fo0SI+/fRTPvzwQyoqKoiNjaWqqopvv/2WnTt34nK5TqrdsmiqnSQGeRJkN7Mxp4xahxNPi1H7gaJAWF9IHA+7v9MWUkUOkl6uEOKcExoayogRI7DbtRFBPz8/Ro0ahb+/P3//+9/55JNPWLZsmdaJ6daNsLAwQAvQq6++mvPPPx9FUejXrx833ngj48aNazn2sGHDiIiIQFEUTCYTl19+OdXV1SQnJwNaqD/99NN8/fXXfPXVVwQEBDBmzBisViuJiYncfPPNLF26lEOHDhEfH3/crV5/qTV6wYraGrHdQTkcDi6//HKeeeYZevbs2WrDBm63ykNfbee7bfm8c30/hsQHHPFDF+z6Br7/k7aQauILYJAVy0KIs6OpqYmcnBzCwsLw8PBo7+Z0eg0NDeTm5hIZGdkyz+x2u5k9ezbbtm3jb3/720kF9PHIkPJp0OkUBsT4oVNgzf7So4cadHptyXzUYNg+G4rT26+hQgghOgwJ3NM0MNYPg17HuqwyGp3uo3/oGaQNJxs9YOU/ZL9cIYQQErinK8LXg7gAG4VVDvYV/6JSiaJo87ihabB/OWStbJ9GCiGE6DAkcE+ToiiMSgqkvK6R3flVx97A4gUDf6+dhL75Y6ivaPM2CiG6PkVRUBSFpiYZSWsNza+jTtf68SirlM/AyKRAXlqcwe78appcboz6X7xBcSO1c3EProEDq6DbJFmxLIRoVXq9HqvVSmlpKTqdDqPR2GbnlXYlqqrS1NREaWkpVqsVvf63K2mdKgncMxAXaCPc24P9xbUUVzsI8/nFCkG9GYb/ET6aCunztIVUHn4SukKIVqMoCoGBgRQWFpKfn9/ezen0rFYrQUFBZ+VLiwTuGTAZdAyJ92dtVhm5FfWEeluOfpMUBYJ7QM9LtRrLKZdAwvmcbJUWIYQ4GTqdjtDQUFwu10kXchDH0uv1J+zZSuGLdmbQ6RgU68/cLXnklNbSN8oX/S+z1GSFXpdD5hKtxnLUYDB5Si9XCNFqmr/oGwyG0z5HVPy61ujxyqKpM6BTIDHYEy8PIzvzqmhoOs43S0UHob0hfizsXaDVWBZCCHHOkcA9A4qi4OdppnuInS0HK6h1OI8/7ODhC90v1FYu//QiuN3H3kYIIUSXJoF7hnytRlLCvNmVV0VJjeP4N1IUiB8NkYPh4DrI+EHbJFoIIcQ5QwL3DHkY9SQGeWLU61ifXc4JY9ToAf1uAKMNNrwL9eVt2UwhhBDtTAL3DCmKQkygjVAfCysyin+94xo1WFulnL8VMuZLL1cIIc4hEritIMbfRqi3BxsOlFPb6DzxDfUmGHo3OB3afrnV+RK6QghxjpDAbQW+ViPdQuw4nC42ZP/GUHFAAqRdC9krIXsVqLKASgghzgUSuK1AURTSIn2wmgys3Fv86zfWm6D3dLD4wrbPobZYerlCCHEOkMBtJakRPthMejYdKKfu14aVFQX846HnJZCzBrJWwImXWgkhhOgiJHBbSYi3hYQgT4qqHewtrPn1G5tskDQRvCNh1cvQWNs2jRRCCNFuJHBbiV6nMDwhgFqHk62HKn697qaiQFgaxJ8HZfu0ko8yrCyEEF2aBG4rGp4UgMPpZtuhSppcvxGgeqO2eMoeDmvfhsrctmmkEEKIdiGB24pi/W1E+HiQU1ZHfmX9r99YUSAoWdtJqDoPtn4KLtlAWgghuioJ3Fak1+kYlhhAbnk9B0rrfvsOigL9bwJbIOz5EYr3nP1GCiGEaBcdLnBVVSUzM5Nrr72We++9l4aGBlwuF0uWLOGSSy5h8ODBPPPMM1RVVbV3U4+hU2BEQiCFVQ1kldTicp/EvKw9BAbfDoU7tD1znSeoxyyEEKJT61CBq6oqNTU1zJkzh/T0dCoqKnC73ezatYsXXniB8ePH8/LLL/Pzzz/z73//G6fzV06/aSdJIZ4EeJrZmVdJVcPJDBErkDwFQlNhx2wozZQFVEII0QV1qMAFWLx4MXl5eUydOhWDwYDb7Wbbtm0EBQVxxRVXMGDAAO655x7Wr19Pfn7+Mfd3u900NTW1XNxtuBWeoih4mg30jvRmZ14VlXUnEbiKArYA6HMNlGdrJR/dHe+LhBBCiDNjaO8GHGnXrl189tlnPPLII6xcuZKcnBycTieZmZmEhYXh4+ODoiiEh4cDUFJSQmRk5FHHWLt2LZ9//jlNTU24XC527NjRps/B02IgNcKbFRklFFQ1EO1vRVGUX7+T3gRxoyC8H2x8H3pO04pjCCGE6DI6TA+3qqqKp556iuuuu46UlJSW61VVxeFwYDAY0Om05up0OnQ63XGHlKOiopgyZQoXX3wxU6dOJSQkpM2eA4BJryMxyI7JoGNzTvnJzeMC+ERB90ngqIV178iwshBCdDEdJnAPHDhAeno6d999N0lJSTz++OPMmjWLMWPG4OfnR01NDY2NjS0B7HQ6sdlsxxwnLCyM888/n3HjxnH++ecTGBjYps9DURQifa1E+1v5aV8pzpMNXJ0BUi6FwG6wfRbkb5PQFUKILqTDBG63bt349ttvWbJkCYsWLeLuu+9m0qRJzJw5k969e5Odnc2OHTuoqKhgyZIlBAQEEBYWdsxxFEU55tLWwnw9iPG3sSWnnKr6Uzi31jMIBtyirVRe9zY0/ca5vEIIITqNDjOHazKZjpqP9ff3x9PTk8jISHx9fenRowf//ve/8fLyoqCggNtuuw0fH5/2a/Cv8LIYSAzyZMGuAjYcKGdSr9CTv3P3KbDpY237vpw1ED9GW1glhBCiU+swgftLkyZNYtiwYZjNZjw8PLj77rtJT0+nrq6OyMhIunXr1t5NPCFFUUgJ88Lbw8jyjOJTC1yTFYbfBzOvhfRvITwNPHzPXmOFEEK0iQ4buDExMUf9Ozg4mODg4PZpzGnoEeaFr9XEmv2lNDS5sBj1J3/nyIGQNB72/KDN68YMl16uEEJ0ch1mDrerCfaykBjkSWV9E9sOVZ78HRUFzJ7Q90ZwNcKWz6CxRhZQCSFEJyeBe5YoisLQ+ACcLpUNB8pO8c46rfJU0gTY8x3kbTkrbRRCCNF2JHDPoiHx/rhVla0HK3A0uU7tzlY/6D4ZTHZY9RK4ZSchIYTozCRwz6JIPyuxATZyy+s5WH4SuwcdSdFB7EhtPjdnjbaxgQwrCyFEu1Bb4fNXAvcs0ikwMimQwmoHGQU1p/6GmWzaeblGD/j5NWg4hblgIYQQraY1ajpI4J5lIxIDqKxrYm9R9cmXeWymKBA1FBLHQdFu2P0tuE9xaFoIIUSHIIF7liUEeRJoN7O3qIbyusZTP4BOB0PuBJ0edn8DVbmt30ghhBBnnQTuWaQoClajgb5RPuwtrKG42nF68wABSdD7asj5GbJXyfZ9QgjRCUngnmUWo46BsX5kldRwqLye05p21xm0wLUFwdbPoKZIFlAJIUQbkkVTnYBep5AUbMfTYmTrwQoane5TP4iigG8MpF4BB9fCviVwetEthBDiNMiiqU5AURSCvMwkBHmy/kAZjtMJXNBqLCeOB/9EWPMa1J1iMQ0hhBDtSgK3DQR6aoG7I7eKirrG0x+aCE7RQrc8Wyv5KIQQotOQwG0DNrOBpCBPANZnn0HP1GCGPtPBMwQ2vg/lB1qphUIIIc42Cdw2oCgK3ULsBNnNLE0vOrOD+cdD3+uhugA2fQguKfkohBCdgQRuG0kIshNkt7DxQDm1jjM4rUdRoO914B0OexdA4U5ZsSyEEJ2ABG4b8fc0kRBso7rByfbcMyzRaPXXimGUZkLGj9BU3zqNFEIIcdZI4LYRnaLQP9oPvU7h58zSMz+nK3EchPaBnXO0RVTSyxVCiA5NArcNDYjxw2TQsTarjEbXaZ4eBNqwsmeQNpdbcQi2z9Y2qxdCCHFWSOGLTibC14O4ABtFVQ72FdWc2cF0BogeCjHDtcVTB1ZLL1cIIc4SKXzRySiKwoikQMrrG9mZV3XmB/SO0BZQGcyw6HFtAZUQQogOSQK3jY1KCqS63snuvCqazmRYGbQdhBLGweA7oCQDlj0LVfmt01AhhBCtSgK3jcUHehLtb2VnfhU5ZXVnPi9gtMDA30HPKyBzCax9AxzVMrwshBCtSOZwOyGzQcdl/SPYlVfFlpxyTnVP+uPSm2Dc4xA1GDb/F3bMAXeThK4QQrQSmcPthPQ6hdFJgfjbTCzcVURlfStUilIU8PCFMQ+DdyT89C848POZH1cIIUSrkcBtY4qiEOlnZXS3QH7aV8K+oupWGapA0UFoKgy7WztFaOFj2vm5QgghOgQJ3HbgaTYwPCEAm1nP7I2HWmdYGbSh5e4XQr8boHQvzH8Y6stlaFkIIc6QzOF2UoqikBblS2q4N99ty+dQeV3rHVxvhmH3QPfJsH8ZrHwRGs/wnF8hhDjHyRxuJ+bvaWJkUiAGncIna3Jwt1YvVFHAYIFxT0B4X9g2E3Z+DU5H6xxfCCHEaZHAbSeKojC2RzCh3hYWpxeSU9aKvVwAz2A471GwBcLqlyF3owwtCyFEO5LAbUchXhYm9gqlsMrBgp2FrbN4qpmi03q4Q++Ghir48SGoLZHQFUKIdiKB244UReHqgVHodbB8TxEFlQ2t+wA6A/S46H+LqL67TyuKIYQQos1J4LazQE8zl/aNIL2gmg0HylpvLhe0+VyjBQb/H3S7UKtEtfoVCV0hhGgHErjtTFHgoj7hqKj8tLekdQph/JKHD5z3sHae7uaPYfd3sohKCCHamARuO1MUhVh/K6OSAlmeUczB1qivfDw+UTD2STBaYdVLkL9N5nOFEKINdajA/frrrxk/fjypqamMGjWKt956i4aGBrZu3cqgQYOIjY0lISGBAQMGMHfu3PZubquxexgZ1yOEukYX83cW4Gy1Shi/EN4XxvxVWzw1/yGoKZbQFUKIk9AaHSFDK7Sj1URHR/PMM88QEhJCeno69957L926dcNutxMREcE///lPkpOT0el0WK3W9m5uq1GAXuHepEX58OXGQ1w3OJoQb49WfhBF286v2yQoydROFVr4KEx6HizerftYQgjRxbRG4YsOFbhpaWmA9k3CZDLh5+dHZWUldrudiooKFixYQGZmJr169aJ3797t3NrWoygKYT4eDInzZ312OfO2F3DL8Niz8UBgsmmrlsv2we5vICBBW1RlsrX+4wkhhGjRoYaUVVVly5YtXHfdddxyyy306dOHoUOH4u3tzbBhw/D29mbv3r088sgjLFy48LjHcDqd1NfXU1dXR319PS6Xq42fxenR6xTGdA8i1NvCzPU5VNadhcVTzbxCYdSDENgN1v9HW0Tldp69xxNCCNGxAhcgMjKSG264gdGjR7N582by8vKIiYnhgQce4I477uCBBx5g9OjRzJw5k5qaY2sEf/PNNwwZMoS+ffsyaNAgli9f3g7P4vQkBNkZGh9AfmUDi3a3ciGMX/KPhwtfBLcKq/4NuZtlPlcIIc6iDhe4fn5+jB07lvvvv59+/frxwQcfYDAYsNvtWCwWvLy86N+/P8XFxVRVVR1z/8mTJ7N8+XLWrl3LypUrGTFiRDs8i9Oj1ylcNTASnaLwzdZcqhvOYq9TUbTThCbMgOo8WPYsVB6U0BVCiOPocrsF7d69m6KiIqqrq9m/fz85OTkEBARQVFTE/v37qaysJCcnh3nz5hEZGYmXl9cxxzCZTHh7e7dcjEZjOzyT05cc4sWQeH8yCmtYm1V6dnu5OgMkjocBv4ODa2VnISGEOIEut2jqq6++IjMzE1VVcblchISEcMUVV7B9+3Y++OAD9Ho9qqpiNBq59dZb8fT0bO8mtzpFgeuHRHPLniJW7SthSJw/npaz+KXB4gX9boTSfbD9C+183aF3anvrCiGEaDUdKnBvuOEGSktLcTqdmM1mgoOD8ff3JygoiKCgIBobGzEajS3/7qpSwrzpH+3H6sxSskvrSAnzapVvVyfkFQ6jH4KidFj7lrbTUO8rQdFr3wCEEEKcsQ4VuBEREURERBxzvbe3N7169WqHFrU9RVHwNBu4tF84f5m9jTX7S0kKtmMynMXgUxQISISLXoOZ18DSGVoPt8dFoDdK6AohRCvoUHO4QqPXKfSO8CE1woe5W3KpqGs8u3O5oIVqeJoWuiYrLH4Cdn8L7s5xWpUQQnR0ErgdVJiPB8MTA9hXVMOa/aVt86CKDmJHwNi/aYUwFj0OO7+S0BVCiFYggdtBmQ06hsb7E+rtwYerD+A6W/WVf0lvgoSxcP7j2r8XPwnbZ0voCiHEGZLA7aAURaF3pA+9IrzZXVDF6sw26uUCGMyQNB6mvgJNdbD0Gdg1F1xOOU9XCCFOkwRuB2bS67g4LRyTQcdn63NwONuwl6kzQNxouPRt7d+L/gbp87QSkBK6QohzTJcrfCGOpigKg2P96R5sZ9vBSrYerGjrBkDsSLjgGa3Xu+gxSP8ekMAVQpxbWuPUTAncDs7DpOfawdEUVztYvLuIRqe7bRugN0LiOBjziPbvRY8dXkjVxu0QQohOTgK3ExjZLZCYACvrssrIKqk5+6cI/ZLBAt0nwoS/Q0MVLH5K29rP7ZLhZSGEOEkSuJ2AzWTgmkFRpBdUsfFAedutWD6S3gRJF2hzuk112pzunh9kTlcIIU6SBG4noFNgeEIg4T5W5u8spKy2DQphHI+iQPwYmPiCds7uoschYwEypyuEEL9NArcTUBSFEG8L5ycHsfFAObvyj92WsM3oDFpP97yHtSHlhY9oq5dVmdMVQohfI4HbSVhNeobE++NjNfLFhoPtM6zczGiB7hfC2Me1Od1Ff4Pdh0NXhpeFEOK4JHA7CUVRSIvyoVe4Nwt3F5JZ1M771hoskDxVK45RV3p4Tne+LKQSQogTkMDtRLw9TJyfHITVZODDn9uw3OOJ6PTQbQJM/he4HNqc7r7FMrwshBDHIYHbyYxOCiLaz8qKvcXsL27nXi5oi6e6TYTzHgVXIyx4GPYulF6uEEL8ggRuJ+PvaWJK7zDKahv5fnt++6xW/iWDBXpMgdF/BUeVtpBqzw8SukIIcQQJ3E5GURSm9Y3AatKzKrOUnLK69m6SxmiFnpfCxOehuvDw8PIimdMVQojDJHA7IW+rkasGRrGnoJp1WWXtP5fbTG+EHhfBlH9DQyUseEQLXVeThK4Q4pwngdsJKcDk1FDMBh0r95ZQXtfY3k36H0WB7pO1TeybGuCHv8CW/0JjbXu3TAgh2pUEbiekKArhPh6MTQ5m1b4S9he3Q33lX2MwQY+LYfxTYLJptZeXPguVue3dMiGEaDcSuJ2UzWxgTPdAVODHHQU0ujrYqTgmq7Z6+dJ3IKgHbHgXvv8TFKVLgQwhxDlJAreTUoCe4d4MiPFl9qZDbM6pwN3RQkxvhKBkuPoz6H01ZP8Es2+CrBXaKURCCHEOkcDtpBRFIdjLwkV9wrGbjTz81XZ25FZ2rKFl0OZ0LV4w7gkY/aA2l/vl72DzJ1qFKiGEOEdI4HZiOkXh/OQgbhsdT2GVg3/M38O+9i75eCIWL+h/E0x4FnwitVKQy5+HsiwZXhZCnBMkcDs5s0HPZX3DuWV4LGv2l/HOyv0UVTd0vJ4uaOfqJk2Ai96AmOGw8UP4/gEo3CWhK4To8iRwuwCLUc/vRsRySVo432zN45M1B6hrdHXM0NXpIbAbTH0ZBt0Kh9bBZ1dB5lJwyryuEKLravXAdTqdNDQ04Ha7cblcFBQUkJWVhcPhaO2HEocpioKn2cAdY+IZGh/Af1ZmMXdLLs6OUhDjlxQFbAEw6s9aDWa9AWbfCOvfgdpi6e0KIbokQ2sfcOfOnRw4cICxY8dSVFTEjBkzqKysZNq0aVx66aUYDK3+kAItdCP8rNw5JoHSGgcvLszAx8PIhJ6h6HRKezfv+Ew26Hcj+ETDqn/BsuegZB8M+T/wj9c2RhBCiC6i1T/RNm/ezJ49e1BVlYULF+J0Ornwwgv55JNPaGhoaO2HE0fQKQq9I3344/hu6HUKLy3ey+rMko45tNxMb4TEcTDpn9DtQtjxBXx3L+Rulp6uEKJLafXAdTgcmEwmAFasWMHkyZOZNGkSpaWluFyu1n448Qt6ncKwhAAevbAHOaV1vLZ0HxmF1R07dBVFO193/FMw8FYo3AmzroNd30gdZiFEl9HqgRsZGcmGDRv4z3/+Q2ZmJkOGDKG4uBhPT090OhkibAt6ncKEXiHcNy6JbbmVvLpkHwWVHXTlcrPmed3RD8K4p8Bghm/vhpUvHp7X7WCVtIQQ4hS1+oTq0KFDOXDgAJs3b+aBBx4gNDSU3NxcJk+e3NLzFWefXlG4on8k+ZX1zN6YS4CnmT9d0A2buQPPoSuKNsScdq02r7vieVjzOlTkwNA7IbC7dhshhOiEWv3T1263c/PNN2sHNxjIyMigtraWq666SgK3DSmKgo/VyM3D4yiobOCLjYfw9zRx26h4DPoOPtKgKBA7HOxB8PPrsOtrKMuEUX+BuFGymEoI0Sm1+ifXsmXLeP3112loaCAjI4Prr7+eO++8k/fee4+mpqbWfjjxKxRFIcLXgz+O70aUnwfvr87my02HcHfU04WOpOggIAnOfxyG3KXN635zeIi5vlyb1+3IQ+RCiC6lNabkWj1ws7KyADCZTHzzzTecf/75fPjhhyxevPg3z8Wtqanh4MGDZGVlkZOTQ1VVFaqqoqoqtbW1LT8rKSnB7ZY5vZOhUxQSgjz5+7RUjDqFN5ftZ3lGccfZtP7XKDqw+sGI++HSt8FogZX/hNm3wKH14JJzu4UQbUNphemsVh9SVhSFhoYGampqWL16NXfddReRkZHU19f/ZkguXLiQ2bNnt9w2NjaWhx56CJPJxHvvvceSJUtQVRVfX1/uv/9+0tLSWrv5XZKiKPQM9+bxKSn87dudvLZ0HwGeJlLCvdF19DlRRQFFr5WEDEyGn1+F9O+0VcyD74AeF2m1mWWYWQjRwbX6p1S3bt3YtGkTf/7zn2lsbKRfv37k5OTg7e2NXq//1fv279+fZ555hnfffZdnn32Wn3/+mVWrVrFt2zaWLl3Kvffey1tvvUVkZCTvvPMONTUdtFB/B6QoCmO6B3HryHiySmr516IMiqocHXvl8pEUBXyj4fzH4IJnteHmpc/AD3+BjAXQVN/eLRRCiF/V6oHbr18/7rvvPsaMGcOLL76Ij48PNpuN22+/HbPZ/Kv3jYyMJDo6Gh8fH/R6PU6nE09PT7Zt20ZkZCSDBw8mLCyMSy65hJycHPLy8o45RlNTE7W1tS0Xp9PZ2k+x0zIbdEzrG84lfcNZm1XGcz/sxuF0d67QtXhBj6kw9RUYehccWAXz7teqVNWVybyuEKLDavXAtVgs9O3blwkTJuB0OsnMzCQ4OJixY8f+ZllHVVVZsWIFPXr0YOLEiUyePJm0tDTy8/Px8/PDarWiKAp2ux29Xk9VVdUxx5g7dy4DBw4kNTWV/v37s3z58tZ+ip2Woih4eRj5v9EJjEwMZP6uQl5cmIHD2cnmw3V67bShkQ/AlZ+AVwSsexs+mqoFsLNBglcI0apao2PS6nO4lZWVvP/++8yePRu3243b7SY0NJR7772XESNG/Oaw8qBBg/jxxx/ZvXs3zz77LKmpqRgMBhobG1FVFUVRWhZSHa+QxsUXX8ykSZNQVZXGxkauueaa1n6KnZqiKPjZTDw2pQcln23miw0HCffx4IoBkXgYf/296VAURSuOETcSAj6AtW/Bji/h8+kw4HfQZzr4xmrhLIQQZ6g1Fk21eg935cqVrF27lkcffZQ5c+bwySefMGLECP7973//Zi1lRVGwWCxER0czYcIE0tLSWLRoEVFRURQXF1NdrZUoLC4uBsDX1/eYYxgMBqxWKzabDavVKpslnECIl4VHJ/cgxNvCe6uyWJFRjNPVyXq6zbzC4LyHYdLzEDEQ1r0D390PO7+WuV0hRIfR6oGbl5dHnz59GD16NKGhoSQkJHD55ZdTWFj4m/Op3377Lbt27SIvL48lS5bw888/069fP1JTU8nNzeWHH34gPT2dd999l+TkZMLCwlq7+ecMRVFICfPmj+O6oarwrwUZpBd08JrLv0ZvgqSJcOE/Yfj92q5D8x+C+Q9D6f72bp0QQrR+4Pr6+rJ7926Ki4tpbGzE4XCwYcMGbDbbbw4nb926lVtuuYULLriAGTNmcO2113LFFVfQq1cvbrzxRt58800uv/xyvLy8uPvuu39zEZb4dToFRiYF8IeRcRTVOHhwzjZKazrRyuVfUhTwiYIht8MVH4B/Amz5FL64QdsIoale5naFEO2m1cdbR48ezYoVK7jqqqtITEykurqa3Nxcrr322t8MyIcffpiHHnqo5d9HjplffvnlXHbZZcdcL06foigY9Tou6xdBfmU9H6zK5sE523n64p4Ee1k65+usKGCwQMQAuPZL7bzdDe/D1/8Hva+CQbeBXwzoZKpBCNG2Wv1TJygoiOeff56ffvqJ/fv3Y7FY6N69O2+//TYOhwOj0XjC+yqK8qsf8p0yADo4RVGwGPX8YWQcJTWNfLs1j+d/3MP/jUkgLtDW8QtjnIiiaJWpht0DkQNh/buw9TPI3aiFbsL5YPWXzRCEEG3mrHzNt1qtjB8/vuXfubm5bNmyRfbD7cC8PUzcNzYJvU7h2y15lNc18sAF3UgO9ercX3T0RogZAX7xED1M231o/l8hexL0vQHC06S3K4RoE1IPT7QI9jJz/7gkrh8SzYYD5dw3ayvbcys775xuM0UB73DodwNc8TFED4fts2H2TbDkmf8VzOjsz1MI0aG1WuC63W4KCwuPeykpKZGKT52Aoij420zccV4Cd45JoLTGwR8+2sjC3YU4nK7OH7wGM4T0hItfh6n/Bg9f7fzd/4zVFlfVlYLbJcErhDhGhyp84XA4uPvuu4/bqMbGRlwu13ELVYiORVEUrCYDtwyPxcdq5PWlmTw+dyd3jEngoj5heJoNnXuIWVHA7AmpV2o93Y0fQvq3Wk3m3d9C3+sgeqgWxkIIcViH2i3IaDRy4403/uptLBZLaz2cOMsMeh2X94/E32bmlSV7eXnxXoqrG/j9iDhsnT10m3mHw+i/QNI4rUjGzrnw7T3azkS9LoPIwdrCKyGEaAWtFrgGg4GJEye21uFEB6A7vMOQj9XIPxbs4b1V2RRVO3hoUjJ2y4lXm3cqOj2E94eAbtBtEmx8H7Z+Dtk/acE76DZtl6Ku8AVDCNGuZIxX/Cq9TqFvtC/PXtKL/tG+fL05jz99sZWDZXW4u8pcZ/MuRNFDYMrLcNUn2pDy5o/gwwu1UpH1ldr8rhDinNQac7gSuOI36RSFmAAb/7yiNxN7hrBqXwkPfbWd7Ycqcbm7SOiCtom9yQqJ4+Ga2TDqr+DhDwsfhU+v0OZ6a4tB7aQ1p4UQp61Dbl4guiZtlyEzj09N4brB0ezOr+Kp73by097izr96+ZcUBWz+MOQOuPgNbVi5rhS+vQ9+fOjwhve/vhGHEEL8kgSuOCVeFgO3j07gjjEJHCyv54lvdzF3S27X6uk20+kgJAVGPwhTX4Yel8DeBfD9A9qq5ryt4JberhDi5EjgilOiKAp2i4GrB0bxyIU9qHY08ez36Xz0czYNTV3gXN3jMXpA1GAY/wRc8aG2unnb59qmCCv/CbUlMswsRBcnc7iiXTTXX56cGsrr1/TDZjbw0qK9vLk8k/K6pq4ZuooOzHaIHQXXz4WJfweTJ/z0InwwGXZ8BdWF4JYCL0J0RTKHK9qVoij0j/blX1f2oWe4N+/9lMXLi/dSUNmF5zcVRatY1fd6uOIjGHKnVov569vhmzth+5dQlS/VqoQQx5DAFWdEURR6hnvz6ORkRiUFMmvDQZ6Zt5t9RdXt3bSzS9GBfxyM/BNM+be2wKokA358EL67F7Z/AY217d1KIUQHItukiDOm1ykkBdt5+MJkPM0GvtycS1ldIw9O6E6vCG+gC2+taDBDeF8I6g49psLmT2D7LDi0AbZ9AUP+T9ulSH+4UEhXfR2EEL9JeriiVegUhWAvC09clMJtI+PYdqiSB+dsY9W+Ehpd7q45r9tMUcBkg9A+MOFZuOE7rR5z7nqYdT18dRvkb4WmOhlqFuIcJoErWo2iKJgMeu4Yk8ADF3Sjqt7JfbO28vHPByioaujaoQta8OqNEJoKl70PF78JcaMheyV8dJG2FeDB9eColuAV4hwkQ8qi1ZmNeq7oH0GIl4X3V2XxjwV72HKwgmsHRdMvxhej/hz4nqc3QNIFEDEAspbD7m+0UpEZP0LSRG34OaK/VstZCHFOkMAVZ4WHycDYHsEkBXvy6boc/rvmALvzq7h+SAyX94/Aw6jvuvO6zZorVqVcog0xH1wHG97TNkjY+yMkXgADbga/eJnbFeIccA50NUR70eu0Gsz3j+vGP6/og6rC339M54EvtlJQ2dA1q1Mdj6KAZzB0v1Abap7yEuhNsOkD+PhSWPmidiqR2ylDzUJ0UFL4QnR4iqLgYdIzsWcIb1zbl/O7B7FibwnXvruWH3cUUFXfRQtl/JKiaMPHHj7Q63K4ZQGMfggs3lq1qo8vhk3/hYoccDW1d2uFEL8ghS9Ep6EoCt1CvHjiop7cc34iAI/N3cErS/aSVVJ7boQuaMGrKFrVqiH/B5e/DyPu11Y5//AAzL0TNn6gndMr2wEK0aXIHK5oU342EzcOjaFnuDfvr8ri83UH2XKwgltHxXNe9yB059JcpqID/wQYehd0m6htjLDpY1j0hHZeb9xoSL0C/BNljleILkACV7Q5g17HwFg/4gJsfLYuh/dXZ/PQnO1cNSCSm4fH4u2hFYno8ouqmhnMEJyihW/yFNj1jdbL/fl1rWJV0kTofwv4xWrD0ufK6yJEFyNDyqJd6BSFQLuZu85L5PXpfQmym/nPT1ncO3MLm3PKaXKp584wczODWVuxPPxe+P0SOP9RMNpg66fw3niY90fI3wL15bItoBBtTBZNiU5NURR0OoUh8f68dV0/LusXwa68Ku6ftZWZ63Moq21s7ya2PUXRhpptAdrG99d/Dec/DpEDYc88+PgSWPCI9v9V+bItoBBtpDVG3GRIWbQ7RVEI8/HgT+O7kRblw3s/ZfP3H7ViGdcPiaFXuDc63Tk4jKoo4BkE/W/S5ngPbdAKZ2Qs0C7h/SBxPHSfBPaQ9m6tEOI3SOCKDkFRFLw8jExODSM13IfXl+1j7pY8duVXcduoeCb0DMGk150787pHUnTgFabN78YMh7TrYMds2D4bcn6GLf+FlEu10408gw7f5xx8nYTo4GRIWXQoRr2OuEAbz1zSi6cv7kl1QxN/nbOdp7/bRXG149wplnE8igIevhA1GCY8p83z9rkGKnNh2Qx4dxys+AdU5UJTvRTREKKDkR6u6HAURcFi1HN5/0gSgjx5e8V+vtyUy/bcSv4wMo7BcQH4Wo3naG/38HPWG8E/Hi54BgbcAls/h8wlsOolrYJV6lWQMBaCe4DZS3q8QnQAEriiw9LrFPpF+/K3qSnM3ZLLrPWHeOTrnYzvEczl/SNIi/Q9N+d2j6QoWvCO/gukXg77l0PGfFj/Duz4EmJHQPz5Wi1nW6AErxDtSAJXdGjNC6puHh7LgBg//rvmAN9ty2d9dhmX9g3nuiExeFmM7d3M9qczQEAS+CVouxTlbYHts7R53oz5ENhd2yyh5yVgD5XgFaIdSOCKTsFs0NMv2pekYDsjkwp5ZfFeXl+ayfI9xdw3Lol+0dq2f+fkMPORdDrwjgSvcIgfo5WIXP8upH8PuZtgzeva7kX9bwTvCG0TBRQJYCHagCyaEp2GoijYLQYuSQvnsz8M4aI+4Rwoq+P/PtnEvxZmsL+49txeVNWseaMEsx3C+sJFr2oLrAbfpq1i3vxfeGsUfHMP7F2kLbJyO9u71UJ0aK1R+KJD9XC3b9/Otm3bqKqqwsfHhyFDhhAVFYVOpyM9PZ3ly5dTX18PgJ+fH2PHjiUsLKydWy3aUnMPNtjLzN+m9mBUtwBmbTjERz8fYE1WGdMHRjG6WyABnmbp7cLhnqsC/nEw5mHoe4O2uCpzCRxYBXt+gMgBkDAOooZAYDcwWtq71UJ0OF2u8MWnn36KwWDAz8+Pn376ie+++45XX30VX19fNmzYwMyZM7nwwguxWq2YTCZ0Oumgn6sURcFk0DMuOYSUMG8W7Sri/VVZPD1vNysyirluSAx9o3ww6OV3pIWigE8k9L1e25u3YAdkrYDd38Cix7U54IgB0H2ydr6vwdTeLRaiS+lQgXvvvffi4eGB2WymuLiYSy+9lG3btjFq1CgAIiIimD59Or6+vuj1egyGY5t/ztXfPcfpdAoRvlamD4piRGIAry3dx487Clh/oJwr+0fyh5GxWE0G6e0eSVG00pFxo7SSkf1vgn0LtQ0TtnyqBXBgDxhwMyScr20dKPO8QpyxDhW4wcHBgBaaTU1NKIqCt7c3AGazmb179zJ16lQCAwO56KKLuPrqq/Hy8jrqGKWlpRw4cABVVWlsbKSioqKtn4ZoByaDVjBjxqW9OL9HEG8t389bKzJZml7EH8dri6psZgneoygKmKxg9IB+N0KvKyB7JWx4Hwq2wte3gW8MpF2vrXz2DNbCV15DIU5LhwrcZmVlZfznP/+hX79+dOvWDYABAwbwyiuvEBAQwJYtW3jzzTfx9fVl2rRp6PX6lvvu2LGDd999l8bGRtxuN5mZme31NEQbay6YMalnKD3DvPlkbQ4/7sjn3plbuDgtnEvSwkkJ80Z/rp+7+0vN87xmT61mc8I4yFkD6d/CwXWw5ClY+5ZWWjJuFAT31MJXpnSEOCUdLnBramp46623KCsr4/7778di0RZwxMTEEBMTA0BoaCg7d+5k27ZtXHjhhdhstpb7jxgxgqFDhwLgcDi4+uqr2/w5iPalKArR/jb+NL4bw+L9+WLjIb7ceIj12WVc3CecS/tG4GeT+ckT0hsgdrg23Fy6F3LWQuYi2PShtj9vWJpWUCNhPATEa7WehRC/qUMFrsvl4p///Cfp6en87W9/Iz4+Hjh2XtblclFfX49Od+x5l3q9vqXHq6qqLKw6h5kMOkYkBdIjzIvF6UW8sTSTfy/ey0/7Srh9VDz9Y3zRKYoMM5+IwQTBKdrK5e6ToDgDds7R5nizf4JNH0PMMOhzLYT01IpvgAw5C3ECHSpwn3zySWbNmsXzzz9PQ0MD27dvJzIyEg8PDxYuXEhDQwNRUVGsXbuW5cuX8+ijj+Lh4dHezRYdmE5RCPA0c3m/SEYlBvKvRXv5YUc+t/13I5N6hnLziBjCfayYDVI044R0Bm0I2TMYogfD8Pu14N30EWybBdtmQuQgGPA77b8mT63Ws7yeQhylQwVuYWEhMTExvP766y3X3XvvvYwZMwZFUfj++++pqKggKiqKp556iuHDh8uHpPhNiqKgVyDUx4MZl/TkvO6BfLI2h3nb85m/s4CrB0UxPiWY+EBPPIx6+Z06npZNE0zgGwXD7oF+N8GeeZA+Dwp3wqzrtfndntMgegj4J8jGCUIcoUMF7ptvvnnCn02ZMoUpU6a0YWtEV2TQ67ggJYQ+kb4szyhiwc5C3vspi/k7CxibHMz4lBBSz9UN70+FooCHN/SZrp23m7dZ2zghewUse1ar1xwzDGJHadsJSv1mITpW4ArRFhRFIcTbwuX9IxmeEMj67FI+XXeQD1Zns3BXIWO6BXH1oEhi/G3S2z0ZFi9t9XLUYCi/Uts4Yfc32paB6d9DYBLEnaf1fH2jJXjFOUsCV5yzdIpCmI+FKb3DGZ4YyJLdRby1IpP/rj3A/J0FXN4/gsv7RRJgN6GXxXe/zWDWqlX5x2uLrMqytHN698zTQnjtm9r1addr+/TqTdoKZwlgcY6QwBXntOb5XX+bicv7RzCxVwifrs3hq825vL4sk9kbD3HL8FhGdQsixMuCySDB+6sUBRSDtnFCSC+Y/E8YcT/smAPp38Hu72DbF9ocb+pVENZbG242eUrwii5PAlcI/leY3G4x8vuRcYxPCWbetnyWpBfx1He7mbslj8mpoYzqFkiUn02KZ5yM5oIaPpEw/B5Iu+bwxglLIXcjzL0DAhK1ed7IgRCaCj5RoOglfEWXJIErxC/oFIXYAE/+MDKecT1CWJFRzOxNB/nHgj3M257PBSkhXJIWjr+nub2b2rnYAqDX5ZA0AYrTtWHmfQsPn140U5vrDeurlZEM76+VnRSiC5HAFeIETAYd3ULsxAbYOD85iHnb8/nvmgO8tGgvc7fkcsPQGC5ICcHTrP0ZyQKrk6Ao2iKryIFaxaqUS6D8gFZGcuccyN2sVbPyi4eUi6HHRWAL/F81K3mNRScmE1JC/AaTQUdsgI07Ricw+7ahXNk/kqJqB49+vZMb31/Hwl2FlNU24nK727upnYveqPV6I/rB+Y/Bbavg0re0Xm55Fix+El4dCHPv1IaiawqhqQFkRzDRSUkPV4iToCgKigKRflYenpzMRWlhzN54iJ/2lnDXZ5sZnhDAhamh9Iv2JdzHQ/bhPVnNPVZFr/V8e1wE3SZB0W7Yu0DbRCF7Jez8SiszmTQeIgZpw8+ewaDT//rxhehAJHCFOEU6RSE1woeEIE+296pkSXoR83cW8OjcHfSJ8GFkUiAXpAQTLefxnh69UVtAFdILaosgbysc2gAHfoKV/wKrL4T2gYgBEDNCu63eJMPNosOTwBXiNFlNBgbG+pES7s3U3mEs3FXIFxsPsWXJXr7ekssFKSFc1jeCcF+t3reE7ylSFK0XmzhO250obTqU7D18etE82L8MNn8MAd20ueCE88Hqf/T9hehAJHCFOAOKouBpNtAjzIukEDuX94/g6825fLIuh3dW7GfWhoNckhbOVQMiCbJr5/FK8J4iRQGjB/jGaKcNxY6EUX+FvfNhy2dwcK027Gzx1vbyTb1CK6xhtErPV3QoErhCtAJFUTDqFcJ9rdxxXiJXDIjiiw0HWbirkI9+PsCsDQe5vF8kY5ODiQ/yxMtikOA9HYpOq2jlFQL9boA+10DeJq2UZM5aLYQ3f6wNM3e7UCuw4RsDniHafK+85qIdSeAKcRYE2s3cNiqeyamhLM8oZnlGMR//fIBvt+YxMimQ0d2CGBLvh6fZ2N5N7dz0Bu0Uo4j+UF0IuRvg4HrIXQ+rX4F1h1c9Rw7U5nxDeoGHrwSvaBcSuEKcJTqdQpS/jWsGWTk/OZitByuYuyWXb7bksSS9iF4R3lySFs7IxEBsZvlTPCOKDrxCwWuKNqxceQhKMiD7J8j4QZvv9QrTtgyMHqoV3wjq/r/ze4VoA/JXLsRZptMphHpbCPYKYWhCADtyK/lgVRYr95awdn8ZPcK8uGloDMMTA7AY9Fo5YumBnT6jRdtAwT8O4kZre/ceXAtbP4MDq+HgGljzulZ4I/UqbacjizfoDNLzFWeVBK4QbaB5kwQvi4Gh8f4MifNnU045H/2czYbscu74dBOpET7cMDSaflG+BNotGPWKBO/paq7jbLJqC66Sp2j79lYe1FY5p38PhTth7v+Bhx90mwDJF2khbQ3Q7iOvvWhlErhCtKHmAFUU6B/jR89wbzbnVPDjjnzW7C/lz7O30TvCh/OTgxgU609yqJfsUHSmWoprKNp+vEPugP43a3O92Su1RVd7foTN/9Xme2OGaef5BiVrC670Ms8uWocErhDtyGLUMyTenz6RPqQXVLFybzHzdxby0qK9RPvnMiDGjwtSQugb7YuHUaoqtRqjB8SNhJihUF0AxRnagqvMpbDmTa1n7BcPQT0garA27+sVDrIvsjgDErhCdAAeJj19In1IDvXi4rRwfs4s5eOfD/D5uoPM31lAaoQ3Vw2IYkRiAMbDZSNluLkV6AzgHaGFafRQSLsWyrIgczHs+ha2fAy7vtZWNof1hR5TtfOALV7AET1n0eWprVDDWwJXiA5CURQsRj2RvlYi+lu5uE84yzKK+WTtATYeqGBFRgndQ+zcODSGwfH++NlMmPRSSKNVKIq22MoQCvZQrVc76i9aWcndc7We7/6lsGcemDy1qlY9LtJOM7J4a0U2pK5zl9Yaf2cSuEJ0MIqioABmo54LUkIYmRjA+uwy5m3LZ1NOBQ99tYOEIE8uTA1lcKwficF2Oa2otRy5mYJOD1EDtUtDpVbPOXMpFGzVVjtvnw0+kdpK6MjB2oYKPjHg4SO9XnFc8lcqRAfnYTIwMimIQXH+7MitZHVmKcv3FPPvRRnM8bUyON6fUUmBDIjxwy4VrM4Oi7fWq40fo20TWLgbCrZr874Z82Hr59oCq+CeENZHK7IRlKLNBcv7IQ6TwBWikzAb9PSN8qVnuDdTUsPYcrCcLzYe4tO1OSzYWUj3UDsX9QljYs9QzAaZ5z0rFJ025GwP1eZy60qgKg/yt8LehdqQ85552qYLPtHabeLP01Y8601HHEfel3ORBK4QnYiiKJgNeqL9rUT6WRnXI4Rthyr4YFU267PLWJ9VxhvLMrl+SAxjk4Pxs5nkfN6zRW8Ae4gWrqGp0PtKqKvQKlvt/vZwD3gj/PQvbZg5ajDEjNIWZ9n8tQDWm7QQl/enw5NFU0Kco5oLadjMBobEB9A/xo/thyqZvfEQ67PLmPH9bt79KYuL+4QxulsQ0f5WvD2MErxng6KAYji84tkKA26BfjdC2X6tpGTOz9rK55y1WsENZwMEp0DE4RrQfnFgC9S2FjR7SrnJDkoWTQkhADDqdfSN9qVPpA878ypZsbeEVftKeGvFfr7YeIgRiQEMifNnQKwfwV4WdBK8Z5dODwGJ2qX/zdq8b0kGFO/R/luaCXsXwKYPtEpXgd0gIAn8Ew+XpYwHrwgwmH7zoUTnIYErRBei0yn0ivChe6gXF/YKZVdeFT/syOe7rfks2FVIQqAnI5MCmJwaRpSfVXq8bUGn1zZO8AqD2FHQVA+1RVoIVxzU5n9zN8C2L8Dl0Hq79hAtcENTIbwvhKZp5/7K+9WpSeAK0QUZ9TpiAmxE+VkZnhjAgdJaZm88xPfb89mRV8ln6w4yplsQ0wdFEhfoiVGvk15vW1AO13c2xWirmsP7Q7dJ4KyH+koo2KaVm8xaAQU7IHORNs9r9NBCN260tlraK/TwZguyx29nIoErRBem0ynYLQZ6hnvTM9yb20bH8/XmPL7bmsd32/L4ctMhhicEcPXASLqHeuFvM8siq7ak0x8OYKs2tOwXqxXUUF1QdgByVmuX/G2QvxmylsH8hyAkFZLGQ/Rw8A7XKmHJ/G+HJ4ErRBd3ZHiGentw26g4Lu8XwbKMIlbuLWFLTgW3/ncT/aN9Oa97EP2ifUkO9cIitZvb1pFfchQDBMRrl77XaYU3CndC3hatF1y6D9a8oa2ADuyu9ZTD+mhzxn6x4OEvdZ87IAlcIc4xiqIQYDczrW8E53cPJr2gitWZpSzaXciLCzOI8rOSFuXDuB7Bh4tpyG457c7irZ1OFDUEGmuhIkdbeFW0Ew6thx1fwOaPtWFqv1ht04XIARDWD2wBMuzcQUjgCnGOUhQFX5uJwXH+9In0ZVrfCNZllfH5+hy+3HiIRbuLSAr25JK0CCamBGM9XD5ShpvbkaJoQ8fBPbRiGoljtd5vXRkcXAf7FmplJzOXwmYvbW/f0D6QOA7iRmnnA8umC+1GAleIc5yiKHiYtGIaUX5WLk4LY11WGf9dk8PGA2U8+vUOXl60l+mDIxmXHEKg3YzNbECnSPi2K0XRFlMZPbTiG4HdIe0aLYBz1sCeH+DAKtj7o7bjkU4PMcMhaYJWhMMaoN3XYJaNF06CFL4QQrQaRVG0RbQ6PcMTAxkU58/O3Ermbc9nfXY5ry7J5D8rsxieEMDIpECSQ72I9LNiM+kleNubohzuseq0IeTkydD9wsObLqzXer0F27W53/kPaSucQ3tr876BydrCK1ugdvHwlQA+ji5X+GLt2rX8/PPPlJWVERAQwAUXXEBiYiI6nQ6Xy8W6detYsmQJbrebUaNGMWTIEIxGmV8S4mww6nX0ifKlV4QP+4trWH+gnI3ZZazLKuPHHQUkhdjpHeFD/2hfBsT6EeItBTU6FEXRhpATx0HCWKivgOJ07VK4A4p2a5su1JVqvV2fSPCJAu8o8I8Dv8MFOGxBsgCrlXSowJ09ezb+/v4kJCSwZcsW/vSnP/HBBx/g7+/Phg0bmDFjBkOHDsVoNPLPf/6TP//5zwwbNqy9my1El6bXKSQG24kP9GRCSjC5FQ1sPlDOvO35zNpwkO+35xPmY2FQrD8XpobSM9wbo14+oDsURQGrL0QPgahB4KjWgra+XCu+UbAd8rdo5//WlWlFNiw+WmB7RWjzwGF9tEIctkCZ/z1NHSpw//a3v2EwGNDr9UycOJHJkyezbds2hg8fzvz580lOTub//u//0Ol01NbWMn/+fPr06YPNZmvvpgvR5el0Cn42M75WE8khdi7pG87+klq+3pTL/F0FfL7+IF9sPERikCeX9g3n/O7BeFuNmAxSVKNDUXTaqmeLN6gqhKVBt4ngdoKrEUr3w8G1cGgdHNqo/TtrOaBo66384rU54IgBENYXrH6gN2qXLlyIo8vN4TYHp6qqlJaWoigKgYGBVFZWkpWVxQUXXIDdbken05GcnMyCBQuora09KnDdbjdutxsAp9PZKi+SEOJ/FEXBoFew63WkhnuTGu7NPWMTWZJexPydBewtrOGp73bzjwUZTEgJZkz3YBKDPAnxtmA26GS+tyNRFEDRFk5hBmxaKcnwvsDt4HZByR6t/GT+Vm0YurYYdn4NGz8AV5M27BzeDyIHQ0gKeIaAZ+DR2xF2AV1uDrdZYWEhb731FiNHjiQhIYGKigocDgdWqxXd4bkEs9mM0+nE5XIddd9t27bx/fff43Q6cTqd7N27tz2eghDnhOYPIR+riUvSwpnUK5T0girW7i9jy8EKlu0p5ustefQI9WJAjC/9ov3oFe5NoJdZer0d1ZHvi96g7WwUnAJ9pkNTA1Qc0M4BLtsP5dnaOcGH1sOOOVpvNyRVG34O7qmduuQTdbgMpbzfHS5wKysr+fe//42qqtx5552YzWYMBgMmk4n6+nrcbjc6nQ6Hw9Ey/Hwku91ObGwsLpcLp9OJ1Wptp2cixLlFURQsRj19In1JDfehpMZBZnENm3MqWLy7kHdXZfP1ljziAm30j/ZjVLdAeoV7Y9BJKclOw2jRdjYK7KYNRzsbtLng6kIoy9TOBc7+SdsJyRaoLcTyT4DoYdrFN/qcXgHdoQLX4XDw5JNPUlRUxNNPP01ERAQAXl5eREVFsX37diZPnoxOp2Pfvn2EhIQcE6hxcXHExsa2HO/LL79s8+chxLlOp1MI8rIQaDfTN9qXKwZEsq+omjmbclm0u4gtORV8svYA4T4ejO8RzHnJwcQG2A5voiDn93YKzecBe0eAV7jWq+02CRproGQvZPwIGfNh11ztnGCTp9bj7TYREseDPfjwnK+uU/R+u9wc7kMPPcTXX3/N008/zb59+8jMzKR79+6EhoYybtw4nnnmGd577z10Oh2rVq3iz3/+8zELprRzCbU3T6eT+SIh2pOiKJgNesyeevxtJgbG+FNa62Dx7iIW7Cwgs7iWt1fu55Ul+0gMtjM2OYiRSYGEeFnwthrxMMo5vp2ComjhafYEk00rxBEzDM5/TNv1KOMH2L8MindrRTl+fFCb8026QFs5bQ/VVkUbPTps+Ha5OVybzcbo0aNZtGhRy3U33ngjYWFhDB06lL/85S/MmzcPt9vNfffdx7Bhw+SPUYhOormwRqDdwlUDo7i8f6R2fm+2Nt+7r6iGD1Zn88byTHqFezMgxo+UMG8SgmxE+lmxmjrUx5U4kZbP5MOLsSL6aYuwht+vnf97cC3kbYaSfbDieVCB0F4QOUT7r1+8NvRs8uyw4Xu6OtRv8JNPPnnCn+n1esaMGcOYMWPasEVCiLOl+fzehCBPLkkL52B5PfuLa9ieW8nG7HI++jkbvU5HXKCNxCBPUiN86BftS2KQJ3qZ9+1cmvcBjhyoXRzV2sKr0r3a1oOHNsCa17SVzf7x2iYM/gnaEHRgsvZvg7nTB3CHClwhxLlHq+VsICnYTmKQJ6OSgiivayS/sp51+8uYv6uQrzfn8uOOAnysJmL8rYztEcyopEAifK3olP8dR3QSZvv/Cml0m6hVwarKh+wVsHchpM/73+3M9sObMPSGyEEQ0V+bN9YdEV+d5L2XwBVCdBjNGyl4mDwI9bbQJ9KXm4bHcqi8jgW7Clm0q5Bd+VVsyqnghR/30CPMiwk9QxidFIifzYTVbJBVz52JotOGjo02beFVeBoMuRMaqiB3o1YD+uC6w6ci7dNKUaou7bYRA7V54vC+YPUHg0VbRa0zdtgAlsAVQnRIiqKgV0Cv05MQZCchyM4fRsSxu6CKn/aWsulAOTlltfxzQQb/WLCHQbH+jEgMICXMiyg/K4F2M3qpAdw5NAekYtB6rp6B0G2CdnG7oTr/f+Uni3ZBVR7krIbdc/9XfCMkVStBGZAInkHaJg7WgMMVsDpGAEvgCiE6DYNeR69wH3qGeVPrcJJZXMuu/Eq2Hapk68FKnv8xHV+riZ7h3vQK9yY10pte4T74Wo3S6+2sdDptNyPvcG1Vs6tRC+DybCjL0gpwlGZqYbzray2wfaPBJ0ab+w1OhrjztPu3MwlcIUSnoygKnhYjvSN9SI3w5sJeTgoq68ksrmXVvhIWpxexbE8xgXYzYT4WBsT4MTY5mJRwL8yGc7fwQqenHF757BujXWJHacU36suhvgxqiqFwp7YKOm+zdi6wXxwEdJPAFUKIM6UoCl4eRuwWAwlBdkZ3D+LesYlszKng2615rM0qY3d+NZ+szSHS14MLeoYwsWcoYT4WTHqdrHjuzJqLbxg9wCsMglSIGa71gl1NUF2grYQOSDrjh+pyhS+EEOJ0NZ/n66HTYzHoGN8jmPE9gimpcbB8TzGL04vYV1TDf1Zm8fLivfSP9mVscjBpUb6E+lgI8DTLtoKdnaL8b+ci0HZECuzWSofuYoUvhBCiNRz54Rhot3BZ/0guSgtnf3Etm3LK2Xqwgl35VfxrUQYeJr12jm+ULylhXnQLsRNot6DXSa+30+tgIxcSuEKIc4JRr6NbiJ1uIXam9g4jp6yOzOIaNmaX89O+EpbvKSbE20K0n5UeYV4Mjfenf4wfdouxvZsuuggJXCHEOcdmNpAc6kW3YDtjugVx66h40guq+G5bHisyStiUU8GXm3Lxt5kYlhDAhJ4hpEZ4YzbopdCGOG0SuEKIc5ZOp2AzG7Ca9AR7BTIyKZDqeifrskr5cWcBG3PK+WZrHp+uzSHY28z4HsGM7hZEXIANbw8jNrNBgvccIYumhBCiFTSHpgJ4W42MSwlhbI9gCqsaWJ9dzobsMjIKq/luWz6frMkhLtCTgbF+9I3yJS7QRpSfFbtFwrcrk0VTQghxliiKQoi3B1N6ezCxZwh5lfVkFNawO6+KzTkVzN2Sy6wNB4kL9CQxyJNe4d70j/YlOcxLVjuL45LAFUKI32DQ64jysxHpa2VEYgAVtU0U1zhYn13Ggp2FzN9ZwMJdhfjZTET6eTA6KYjzk4OI9reia+49S+/3nCeBK4QQJ0lRFMwGPcHeeoK8zCSHenH1wCgKKxtYuqeI73cUsDu/mm0HK3lpUQbJoV5MSAlmWGIgIV4WLCY9ZoOuJYTFuUUCVwghTsORmytEB9i4MSCW64fEkFFYzU/7SlifXUZ2aR2vLM3kHwsz6B7ixaBYP/pF+xLpZyXYy4K3h1HO9z2HSOAKIUQr0ekUuod60T3Ui+kDo8gsqSE9v5r0girS86v5YuMhPlidTXygjaRgO91CvEgOtZMc6kWg3Sw93y5OAlcIIc4Cq9nQsrNRQ5OL4moHhVUOduVXsXpfCSv3lvDDjgICPM2EeFtICvZkSLw/g2L9CbKbZc63C5LAFUKIs0hRFDxMBqL8DUT6WekT5cO0fhFU1Tex9VAFi3YVsnJvCekFVczblo9BryMtyoex3YMZGu9PoJdW49kgmyx0ehK4QgjRRhRFwahXMOp12Ex6Qr1DmJASQl2ji0055azcW8KmA+VkFFSzZn8pqgopYV6MTApkQIwfIV4WfKxGvCxGFEVWPrclKXwhhBCd1JFhaTMbGJEYyIjEQGoanOzOr2RbbiXp+dVkFtfw7sosXl+6j6Rgbb63W4iduAAb0f42Qr0tmAw6Cd+zTApfCCFEF+NpMTAgVts4ocbhJL+ygYNldezKr2JLTgWLdxfy5aZDBNkthHpbiPSzkhLmRVqUD91DvLCZ5WO9o5J3RgghOiBFUbBbjNgtRhKDPBmeEEBto5OaBid7CqtZubeE1Zkl7NheycJdhVhNenxtJtIifRieEMDgeH98PIzoDu8T3HxM0X4kcIUQooNTFAWzUY/ZqMfXaiLSz8r53YNxulVyymr5ObOUn/aWsLugmkW7C/lmax4ut0rvSB+GJ2grn8N9PfA0G7CZDbIAq51I4AohRCfSstGCAiadQkKQnYQgO9cMjqak2sGO3Eq2HaokvaCa3Io6Plx9gFeW7CPKz0rvSB96hXkTG2gjzMeDMG8PbGa9hG8bkcAVQoguQKcoBHlZOM/LwnnJwdQ0OMkpq+VAWR1ZxbXsPjwH/N22fLwt2ilKMQE2EgM9SQ7zkuIbbUACVwghuiBPi4EeYd4kh3rR5FKpamiioq6RQ+X1bDhQztrMUuZtzUenU/D2MOJtNZIQ5MmQOD8GxvoTG2DDcETZSekFnzkJXCGE6MIURcFkUAjwNONvMxEX6MmwhABcYxKorGtiTZY2/7s+u4zV+0pYsacYt6oS5mNhcHwAoxIDSQn3wmYyYDbqMOnlFKTTJYErhBDnCEVRUACdXsGoB4u3nov6hHNRn3DqG53syq9iQ3Y5Ww9VcKisnkW7Cpm57iA2s57ekT70i/alV7g3IV4WAjzN+Fi1zRckgE+OBK4QQgg8TAb6RfvRL9qPRqebvIp69hXXsLdQK76xr6iWt1fsx+lyExtgIz7ITkKgjYQgTxKD7UT6WfEw6tv7aXRoErhCCCGOYjLoiAmwEe1v5bxuQVQ1NFFc7aC42sHu/Go2HChjfVYpP+7Ix8fDRKDdTJiPhZ7h3vSL9iUt0hdPi8TLL8krIoQQ4riUw0UzfKwmfKwmEoI8GRDrx5UDIqlrcrKvqIZVe0tYsbeYNfvLWLO/jPdXZWM16ekb5cuIxACGxGu7Hxn0Om34mXN3AZYErhBCiJNy1OYLZj2BnmaGxPlz//hu5FXUsy6rjLX7S9mZX8WWgxUsyyjC0eSme6idIXH+9I/xJdrfhq/VhLeHEfM5VgNaAlcIIcQpOzIo9QpE+lmJ9LNyad9wKuqa2F1Qxa68KvYV1ZBVUst3W/P5cHU2QV4WkkO9SAnzIj7QRpSfjSg/Kz5WY5cPXwlcIYQQrUZRFHxtJobGBzAkzp+GJhf5lQ3kVdSTXVLLzvwqth2sZPmeYjxMesK8LYT6eJAU7ElqhA+9wr0J8/FAr+t64duhAnf79u288sorbN++nTFjxvDAAw/g6+vLvn37+Mtf/sKePXtQFAWbzcadd97Jtdde295NFkIIcQKKouBhMhAX6ElsgI3Bcf7UNbqocTgpqnKwPruUVftKWZdVxurMEqwmA1aTnghfD3qFe9MnUgvgEG+Pw6cfgXLEsTubDhW4DQ0N9O7dm4CAAPLz83G5XAA4HA4UReHvf/87aWlp6HQ67HZ7O7dWCCHEyVIUBYNewctDh91iINTbQmqENzcNj6XO4WRDdjk/7Sthw4FyDpTWkVFYw6drc2hyqwTZzUcFcLivB1aTAQ+jDrNR32k2Y+hQgTtgwAAGDBjArFmzyM/PP+pnDoeDnTt3oqoqMTExBAQEHPcYbre7Jaibmppwu91nvd1CCCFO3pEbMOhQ8PIwcV5yMOclB+NwujhUVk9GUTV7C6vZX1xLUbWDzOIa1maVUlXvxMfDSHyQJ0nBdhKCPInw9cDf00yApwl/mxmLsWMuxupQgXsiNpuNXr16UV5eztKlS8nKyuJ3v/sdEydOPOZFXbt2LZ9//jlNTU24XC527NjRTq0WQghxqswGPfFBnsQHeTIhJYQml0pprYP8ygbyK+rJragnp6yOA6V1LN1TxOfrc/Aw6gnxthDqbSHM24MIX4/D5xFr5xJ7mg0dIoA7ReCGhYVx//33YzabcTgcfP7553z88ccMHDjwmJ5uVFQUU6ZMwe1209TUxNatW9up1UIIIc5Ecx3oUG8PQr09UCN9cKsqtQ4X1Q1NVDU4Kal2sKewmp15lezIrWLVvlIMOgW7xYDdYiTSz8rd5yfQL9qvvZ9O5whck8nUEqyenp4MHTqUefPmUVZWdkzghoWFERYWBmjD0G+++Wabt1cIIUTrUxQFvaLNA3t5GAlTVQixMyTeH5dbxelWqahrYldeJVsPVbA5p4LyukZspo4RdR2jFYe5XC7q6upoaGigqamJmpoabDYbTqeTyspKfH19qa+vZ9WqVdjtdry9vY85xpHDBlqVlPYfRhBCCNH6mj/fDXoFgx7MgM1sINzXg3EpIaiqSpPLja6DnGLUoQI3JyeHf/3rX+zZs4ecnByeeuopzjvvPLp3787bb7+N3W6nqamJgoICrr/+egIDA9u7yUIIIToobUi642yo0KEC18fHhwsuuIBx48a1XBcdHU1kZCTTp0+ntrYWk8lEZGQkcXFx6HS6dmytEEIIcfI6VOD6+vpy4YUXHvdno0aNauPWCCGEEK1HuohCCCFEG5DAFUIIIdqABK4QQgjRBiRwhRBCiN+gquoZH0MCVwghhPgNrVHTQQJXCCGEaAMSuEIIIUQb6FDn4Z5trTEGL4QQQpyOLh24qqqiqiq5ubl4enq2d3OEEEJ0Qm63m8LCwpZMOV1dOnDdbjfdunXjueeeO+PjbN68mdTUVIxGYyu1rm25XC42btxI//79O2VJTKfTyebNm+nXr1+nbH/zVpF9+/btlO0HqKyspKCggKSkpE65KUh5eTnFxcUkJiZ2yvaXlZVRVlZGfHx8p2y/qqocOHAAq9VKUFBQezfnlKmqypVXXnlGgauoXXicVVVV6urq0Ol0Z/QL2tDQwJgxY5g7d26n/EUBqKqqYvjw4axduxYPD4/2bs4pq6ioYPTo0fz888+dsv2lpaVccMEFrFy5slO2H+Cnn37i448/5tVXX+10XzxVVWXp0qV89dVXvPjii52y/fPnz2fRokU899xzGAydr6/kdDqZMWMGycnJXHbZZZ3uS4Pb7Uan02E2m0+77Z3vXTsFiqJgs9nO+DiqqqIoCmazGYvF0gota3uNjY2d+jlYLJaWX/bO2P7mP1KLxdIp26+qKiaTCb1ej9lsxmQytXeTTklz+w0GAxaLpVMG7pGvf2drP2iBq9frMRqNmM3mTjvScybOvWd8mgwGQ6f7RvZLnfFb8ZH0en2nfQ8URen0r7+iKOj1HWers1OlKEqn/pDv7K8/aH/Dnfk9OFOd+xOgjRiNRv785z936oVXFouFRx55pNP1TJp5eHjw8MMPd8pv9gA2m42//vWvnbb9APHx8UyfPr3Tfuh369aNK6+8stO2v0ePHnh5eXXa9ut0OiZNmoSfn1+n/eJ8prr0HK4QQgjRUZy7fXshhBCiDUngCiGEEG1A5nCP4HQ6KS8vp66uDoPBQGBg4HHnPBsbGykrK6OhoQGLxYKfn1+7z4263e6Wtrvd7pZ2HW/O0OFwUFxcTFNTU8t1QUFBrbKi+3S53W5KSkqora1tuc5msx33NCyHw0F5eTkNDQ14eHic8Hm2tbq6OoqLi3G73S3XmUwmAgICMJvNLdc1NDRQXFyM0+lsuS4kJKRdThdqbGyksrKS+vr6lt95o9GIqqo4nU7Kysqor6/HbDYTGBh4woVftbW1lJeX43K58PLyarO5xiPbbzQaCQgIwGAw4Ha7W9quqipWqxU/P7/jtqmuro6SkhJcLhegzTUGBQW12fvR0NBAeXk5jY2N2Gw2/Pz80Ol0x/yd6nQ6/Pz8sNvtxxxDVVWqqqqorKxEURR8fX2x2WxtMld6ZPs9PT3x9fVFp9NRU1NDcXHxUbe1WCwEBAQc8/daVVVFaWlpy78NBgPh4eFdboGVBO5hbrebtWvX8uqrr1JZWYnb7ebKK6/k2muvPeqXo7GxkXnz5vHJJ59QV1eHh4cH1157LZMnT27XD/26ujoee+wxCgoKWj7wr7/+eqZOnXrMh8z27du54YYbiIiIwGg0otPp+Otf/8qQIUPao+mA9oH9wAMPsGnTJqKjo1EUhWHDhvHggw8edTuHw8FXX33FrFmzaGhowGazcdNNNzFu3Lh2D9309HSee+456urqUFWVgwcP4u3tzTvvvEP37t1bbrdp0yauv/56EhMTW1ZtPvnkk/Tp06fN27xv3z5ef/11duzYgdPp5IMPPiAhIQGXy8XChQv5z3/+Q0NDA4qi8Ic//IEpU6Yc8yFYUVHBa6+9xurVq3G73URFRXHvvffSvXv3s/6Bn5GRwWuvvcbOnTvR6XS89957xMbGUlJSwoMPPkhFRQWgLXy87bbbOO+88445xrJly7jvvvuIjY3FYDBgt9t56KGH6NWr11lte7N169bxxhtvsGPHDkaOHMmMGTPw9vZm+/bt3HXXXZhMJux2O56entx0001ccMEFxxyjsLCQxx9/nJycHFRVpW/fvvz5z3/G29v7rL8Ha9as4c0332T79u2MGzeOp556CrvdzsaNG3nhhRcArfBOZmYmPXr04NVXXyUiIuKoY3z00UfMmDGDvn37AhAQEMBrr73Wrp2As0EC97CGhoaWD8ZbbrmF3bt38+CDD5KWlnbUB2FOTg6zZs1i0qRJTJw4kR9++IFPP/2UXr16kZCQ0G7tNxqNXHjhhSQnJ2Oz2ViwYAHPPfccQ4YMISQk5JjbWywW3nvvvZY/yCN7YO3Fw8OD3//+99x8880nPAUiMzOTL774gssuu4wxY8bw1Vdf8emnn5KSkkJ0dHQ7tPp/UlNTef/991FVlcbGRp555pmWAPolDw8PPv74YywWS8v5ue0hICCAa6+9lurqap544glA6y1VV1fz5ptvMn78eC699FJWrFjBc889R58+fY55nZcsWcLKlSt58sknCQwM5J///CdffPEFf/rTn7BarWe1/YGBgVx//fWUl5fz/PPPt1xvsVi44oor6NmzJ0ajkY8++ojnn3+ewYMHH7dNoaGhfPTRR1it1jZ/P6Kjo7nnnntYtGgR+fn5R/0sIiKCBx54gB49eqAoyglH0t5//30KCwt5+eWXqaur495772XRokVMmzbtrLc/JiaGe++9l++//56qqqqW64cNG0a/fv2A/32hTk5OJjg4+JhjKIpCWloan3/+OaD15jtrgZhf07X662egrq6Obdu2MXHiRCIiIhg9ejTR0dGsW7fuqNsdOnQIl8vFyJEjCQ0NZfTo0ej1erKzs9un4YeZzWYmTZpEbGwsQUFBDBw4kJqaGhobG497e4fDwV133cUdd9zBvHnzcDgcbdziYzU0NPDRRx/xu9/9jpdeeom6urpjbpOVlYXFYmHEiBGEhoYyZswYHA4Hubm57dDioxkMBmw2W8vpY2vWrGHkyJHH/eBoaGjgtttu46677mLBggUnfJ/OtqCgIAYPHkxMTMxR1+fm5lJUVMSkSZMICwtj8uTJWCwWtm7detTt3G43GzdupF+/fvTu3ZuYmBhGjx7Nrl27jpoeOFuCg4MZMmTIUV8CFEXB29ubiRMnEhkZSUhICGlpaZSVlZ2wLF9JSQm33nor9913H8uXLz9quP9si46OZvDgwccNooKCAh566CHuvPNOvvnmm5Zh7yO5XC5+/PFHLr/8chITE0lNTWXYsGHMnz+/LZpPTEwMgwcPPmb6x2Aw4Onpic1mo6amhj179jBixIgTjkTt2LGDm266iUcffZSMjIwuudmM9HAPKysrw+12ExgYCGh/tKGhoRQWFh51u9raWnQ6XctQh4eHByaTierq6jZv84nU19fz/PPPM2LEiGOGbkDrFTzyyCOEhYWRlZXFq6++Sn19PdOnT2+3YVmj0cill17KFVdcgV6v56233uK2227j/fffP2pYqbq6GpPJ1NIDsdls6HS6NvlwPxXff/89er2e0aNHHzOkFxISwhNPPEFkZCR79uzhH//4B06nk0svvbTDnGOZm5vbMv8MtMzvFhUVHXU7h8NBWVkZKSkpLSVU/fz8qK6ubtPQOpHmuc1XX32VyZMnH7d3GxMTw6OPPkp4eDhbt27l6aefRlVVJk6c2K5ziCEhIdx1110EBweTm5vLa6+9RmlpKbfffvtRvyc1NTVUVFS0fGlSFIXIyEg2btzYTi0/1syZM4mIiGDAgAHH/Xnv3r154YUXCA4O5scff+SWW27hq6++Ou7oUGcmgXuYXq9HVdWjFrw01848UvO/m799Ne8e0VEm98vKynjppZeoqqrizTffPG67oqKiWn6RR4wYgdPpZPHixUyZMgU/P7+2bjKgDQFOmTKl5d9paWlMmjSJjRs3MnLkyJbrdTrdUTt2NL9fHeX1B22e/7///S9TpkzBx8fnmJ/HxsYSGxsLaMNudXV1fP/990ycOLHDFFcxGAzH/D24XK5jvhDodDp0Ot1RPa/j/d20B1VVKSgoYMaMGQQHB/PAAw8cdz4zOTmZ5ORkAAYPHkxVVRULFy5k9OjR7TqHGBERweWXXw5oz8VisfDZZ58xbdo0QkNDW27X/EXnyC84Lperw1Q2q62t5csvv+RPf/rTCYfEhw0b1vL/gwcPZufOnXzzzTfceeedbdXMNtH+fxUdhK+vLxaLpWVo0u12k52dfUwP0W6343K5WuYqampqaGhowNvbu83bfCRVVSktLeW1116joKCAF154AV9f3+PeVlGUlgtovfTGxsajPlzbw5HtMplMmEwm6uvrj7qNt7c3DQ0NLcPN1dXVuFyu467cbC8bN24kKyuLadOmHfcD/sjnqSgKHh4eOByOdn/9jxQZGUlTU1PLnKLD4SA/P5+wsLCjbmc0GgkKCiInJweXy4WqqhQWFuLt7d2uK/dVVSUvL69lo4JnnnnmhPOyR74XzXOHDQ0NHeL9OLJtNpsNl8t11NkFoI3yhISEkJ6eDmjPfd++fcTFxbVHk48xf/583G4348ePP+ECriOfp16vx2q1dqhRw9YigXuY1Wpl0KBBzJo1i927d/Pf//6XkpISRowYwZIlS/jggw9wOp3ExMRgsVj4+uuv2bdvH19++SVGo7FdF0yBNif40ksvsXv3bm6++WbsdjtVVVUt33o/+eQTvvrqKwC2bt3K6tWrycvLY926dcyZM4fk5OSzvsDl19TV1fH111+TlZVFZmYmL730Enq9nh49ejB//nw++ugj3G43SUlJuN3uo15/Ly+vDjP0pKoqM2fOZNiwYS29WIAPPviA7777DtACee3ateTl5bF69Wq+/fZb+vTp0y4L1xobGzl48CCHDh3C4XBw6NAhCgsLCQ4OJjY2ls8//5yMjAzefPNNzGZzyyrSN954gyVLlqDT6Rg2bBgbNmxg6dKlbN26lXnz5tG/f/826a03NjaSk5NDbm4uDQ0NLe2vqKjg2WefpaKigptuugmDwdDy5Qzg1VdfZdmyZQCsXbuWtWvXkp+fz7Jly5g/fz59+vRps4VT9fX1ZGVlUVJSQlVVFQcOHKCkpIR9+/axdOlS8vLy2LRpE++99x4JCQkEBATgdDp5/vnn2bZtGzqdjmnTpvHf//6XdevWsXjxYlatWsXUqVPbtP2lpaUt7S8rKwO092fmzJlMnToVf3//lvs0NjbywgsvsGPHDgC++eYbdu3axaFDh5g1axY7d+48amSry1CFqqqq6na71T179qg33nij2rNnT3XMmDHq4sWLVZfLpb7yyivqTTfdpDY0NKhOp1NdvXq1Om3aNDUlJUWdNm2a+vPPP6sul6td219SUqL6+fmpAQEBanx8vJqYmKiOHj1a3bhxo6qqqnr77berDz30kKqqqjpv3jx1woQJakpKijp8+HD1b3/7m3rw4EHV7Xa3W/vLy8vVadOmqb1791b79eunXnPNNermzZtVl8ulPv/88+rvfvc7tampSXU6neqyZcvUqVOnqikpKepVV12lbtiwod1f/2ZZWVnqsGHD1OXLlx/1et50003qE088oaqqqn755Zfq2LFj1ZSUFHXEiBHqM888o+bn57fL67937151xIgRalRUlGq329WoqCj1pptuUmtra9WNGze2/J5feOGF6saNG1vaeMkll6gvv/yyqqqq2tDQoL7//vvqkCFD1NTUVPXPf/6zeujQoTZ5PhkZGeqQIUPUyMhI1cvLS42KilJvueUWdc2aNaq3t7caHBysJiQkqImJierEiRPVrKwsVVVVdfLkyerrr7+uqqqqfvzxx+rIkSPVlJQUdcyYMeqLL76oFhcXt9n7sWbNGjU+Pl4NDg5W/fz81NjYWPWJJ55Qly9fro4ZM0ZNSUlRhw0bpj722GMtr2tDQ4M6fPhw9dtvv1VVVVVra2vVxx9/XE1LS1MHDBigvvrqq2pdXV2bPIdVq1apcXFxanBwsOrv76/GxcWpzz77rKqqqrpx40a1X79+akZGxlH3qaurU0eMGKH+8MMPqqqq6kMPPaT2799fTU1NVSdNmqTOnDlTbWhoOOttb2tSS/kI6uG5QfXwdnzNl+ahpeZ/n+h27d324w2BNc/vHDnX+cv2A+3+HI5s05Ht6Syvf7NftqtZR339j/d7c2RbTvQ6/3LuvL3ek19r/4mu/62/hyPfk7bwa8/hRH8Tv2zvL/9+mt+X9nwPjnxtf/n78Mvr3W73Mc+zrdrfliRwhRBCiDYgc7hCCCFEG5DAFUIIIdqABK4QQgjRBiRwhRBCiDYggSuEOGnr1q3j22+/paGhob2bIkSn0zFqfwkhTlteXh4zZsxoqTQE4Ofnxz333HNUybzWsGnTppaiBO21w5EQnZUErhCdXF1dHfn5+Vx//fX0798f0Gohh4aGUl1djdFopKmpCbfbjdlsxmw2t5z76HA4cDgcLVvSmUymlvM6GxoaaGxsRFVVTCbTUbseNW/sbjQasVgsHWbTBSE6MglcIboAk8lEdHR0SxH+ZsOGDaN///7k5uaSl5dH//79efTRRwkMDGTv3r289NJLbNu2DYPBwOjRo7nzzjsJCAggKyuLf/7zn2zfvh2dTkf//v1bNhM/cOAATzzxBNu3bycoKIg///nPDBw4sENsWCBERyaBK0QXUFlZyZw5c9i2bRsA/v7+nHfeeaiqyq5du3jxxRdRVZUHH3yQb775hquuuorPPvsMRVF4//33qaio4Pnnn+f777/n2muv5dlnn6WpqYk33ngDHx8fDh482PJYWVlZ3Hbbbfz1r3/llVde4euvv6ZXr17turOOEJ2BBK4QXUBzKb3mXmZzSU9FUZgyZQqpqakAjB07lkWLFjFhwgT279/PZZddRmJiIk1NTYwYMYLt27dTUlLCsmXLePvtt0lJSQEgPDy85bH69+/P4MGD8fX1ZdCgQcybN4/a2loJXCF+gwSuEF2A3W5n8uTJjBgxAqBlmzPgqD157XY79fX1LVvpNe9QpNfr8fT0xOFwtGwBd7y9fAE8PT3R6/+/vTtGVRwKwzD8xZt0IWCR2kYUCbgAQcwKLGy0E7S3UpehvatwA3a2FiKotaUSxUTQRryFkGIYpptzncz7lKmS6uXnnJzzJcuyZNu2ns/nR1xlB3w6Fl2AjPj1nl3pfUj8crlUHMe6Xq9arVYKgkCu68rzPO33e91uN51OJ63XaxUKBfm+r1KppMVioSRJ9Hg8dLlc9Ltj17N2uDzwNzHhAhkQx7Hm87k2m42k9yaqMAwlvTc5TadTxXGsw+GgwWCgfD6vZrOp2WymKIp0v98VRZH6/b5s29Z4PNZkMtH5fE4n3dFo9ENfB2QDwQX+cb7vq9fr6Xg8ps8cx0nXcdvttjzPU5Ik6nQ6KpfLyuVyajQa8jxP2+1WjuOo2+2qUqnIsiyFYSjXdbXb7fR6vVQsFiVJ9XpdQRCkvwhVq9V0WgbwZ1zPB2RYrVbTcDhUq9X66VcB/nus4QIZ5vs+J0IBH4IJFwAAA5hwAQAwgOACAGAAwQUAwACCCwCAAQQXAAADCC4AAAYQXAAADCC4AAAYQHABADCA4AIAYADBBQDAAIILAIABBBcAAAMILgAABhBcAAAMILgAABhAcAEAMOAbaUv2Jq1t27wAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.image as mpimg\n",
+    "\n",
+    "# Chemin vers l'image\n",
+    "image_path = \"result/comparaison_loss_models.png\"\n",
+    "\n",
+    "# Charger l'image avec Matplotlib\n",
+    "img = mpimg.imread(image_path)\n",
     "\n",
+    "# Afficher l'image\n",
+    "plt.imshow(img)\n",
+    "plt.axis('off')  # Masquer les axes\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "RuntimeError",
+     "evalue": "Attempting to deserialize object on a CUDA device but torch.cuda.is_available() is False. If you are running on a CPU-only machine, please use torch.load with map_location=torch.device('cpu') to map your storages to the CPU.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "\u001b[1;32mc:\\Users\\Utilisateur\\Documents\\GitHub\\image-classification\\TD2 Deep Learning.ipynb Cell 26\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X32sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m model\u001b[39m.\u001b[39mload_state_dict(torch\u001b[39m.\u001b[39mload(\u001b[39m\"\u001b[39m\u001b[39mmy_model_cifar.pt\u001b[39m\u001b[39m\"\u001b[39m))\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X32sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m \u001b[39m# track test loss\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X32sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m test_loss \u001b[39m=\u001b[39m \u001b[39m0.0\u001b[39m\n",
+      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\serialization.py:1014\u001b[0m, in \u001b[0;36mload\u001b[1;34m(f, map_location, pickle_module, weights_only, mmap, **pickle_load_args)\u001b[0m\n\u001b[0;32m   1012\u001b[0m             \u001b[39mexcept\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m \u001b[39mas\u001b[39;00m e:\n\u001b[0;32m   1013\u001b[0m                 \u001b[39mraise\u001b[39;00m pickle\u001b[39m.\u001b[39mUnpicklingError(UNSAFE_MESSAGE \u001b[39m+\u001b[39m \u001b[39mstr\u001b[39m(e)) \u001b[39mfrom\u001b[39;00m \u001b[39mNone\u001b[39;00m\n\u001b[1;32m-> 1014\u001b[0m         \u001b[39mreturn\u001b[39;00m _load(opened_zipfile,\n\u001b[0;32m   1015\u001b[0m                      map_location,\n\u001b[0;32m   1016\u001b[0m                      pickle_module,\n\u001b[0;32m   1017\u001b[0m                      overall_storage\u001b[39m=\u001b[39moverall_storage,\n\u001b[0;32m   1018\u001b[0m                      \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mpickle_load_args)\n\u001b[0;32m   1019\u001b[0m \u001b[39mif\u001b[39;00m mmap:\n\u001b[0;32m   1020\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\u001b[39m\"\u001b[39m\u001b[39mmmap can only be used with files saved with \u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[0;32m   1021\u001b[0m                        \u001b[39m\"\u001b[39m\u001b[39m`torch.save(_use_new_zipfile_serialization=True), \u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m   1022\u001b[0m                        \u001b[39m\"\u001b[39m\u001b[39mplease torch.save your checkpoint with this option in order to use mmap.\u001b[39m\u001b[39m\"\u001b[39m)\n",
+      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\serialization.py:1422\u001b[0m, in \u001b[0;36m_load\u001b[1;34m(zip_file, map_location, pickle_module, pickle_file, overall_storage, **pickle_load_args)\u001b[0m\n\u001b[0;32m   1420\u001b[0m unpickler \u001b[39m=\u001b[39m UnpicklerWrapper(data_file, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mpickle_load_args)\n\u001b[0;32m   1421\u001b[0m unpickler\u001b[39m.\u001b[39mpersistent_load \u001b[39m=\u001b[39m persistent_load\n\u001b[1;32m-> 1422\u001b[0m result \u001b[39m=\u001b[39m unpickler\u001b[39m.\u001b[39mload()\n\u001b[0;32m   1424\u001b[0m torch\u001b[39m.\u001b[39m_utils\u001b[39m.\u001b[39m_validate_loaded_sparse_tensors()\n\u001b[0;32m   1425\u001b[0m torch\u001b[39m.\u001b[39m_C\u001b[39m.\u001b[39m_log_api_usage_metadata(\n\u001b[0;32m   1426\u001b[0m     \u001b[39m\"\u001b[39m\u001b[39mtorch.load.metadata\u001b[39m\u001b[39m\"\u001b[39m, {\u001b[39m\"\u001b[39m\u001b[39mserialization_id\u001b[39m\u001b[39m\"\u001b[39m: zip_file\u001b[39m.\u001b[39mserialization_id()}\n\u001b[0;32m   1427\u001b[0m )\n",
+      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\serialization.py:1392\u001b[0m, in \u001b[0;36m_load.<locals>.persistent_load\u001b[1;34m(saved_id)\u001b[0m\n\u001b[0;32m   1390\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m   1391\u001b[0m     nbytes \u001b[39m=\u001b[39m numel \u001b[39m*\u001b[39m torch\u001b[39m.\u001b[39m_utils\u001b[39m.\u001b[39m_element_size(dtype)\n\u001b[1;32m-> 1392\u001b[0m     typed_storage \u001b[39m=\u001b[39m load_tensor(dtype, nbytes, key, _maybe_decode_ascii(location))\n\u001b[0;32m   1394\u001b[0m \u001b[39mreturn\u001b[39;00m typed_storage\n",
+      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\serialization.py:1366\u001b[0m, in \u001b[0;36m_load.<locals>.load_tensor\u001b[1;34m(dtype, numel, key, location)\u001b[0m\n\u001b[0;32m   1361\u001b[0m         storage\u001b[39m.\u001b[39mbyteswap(dtype)\n\u001b[0;32m   1363\u001b[0m \u001b[39m# TODO: Once we decide to break serialization FC, we can\u001b[39;00m\n\u001b[0;32m   1364\u001b[0m \u001b[39m# stop wrapping with TypedStorage\u001b[39;00m\n\u001b[0;32m   1365\u001b[0m typed_storage \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mstorage\u001b[39m.\u001b[39mTypedStorage(\n\u001b[1;32m-> 1366\u001b[0m     wrap_storage\u001b[39m=\u001b[39mrestore_location(storage, location),\n\u001b[0;32m   1367\u001b[0m     dtype\u001b[39m=\u001b[39mdtype,\n\u001b[0;32m   1368\u001b[0m     _internal\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m   1370\u001b[0m \u001b[39mif\u001b[39;00m typed_storage\u001b[39m.\u001b[39m_data_ptr() \u001b[39m!=\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[0;32m   1371\u001b[0m     loaded_storages[key] \u001b[39m=\u001b[39m typed_storage\n",
+      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\serialization.py:381\u001b[0m, in \u001b[0;36mdefault_restore_location\u001b[1;34m(storage, location)\u001b[0m\n\u001b[0;32m    379\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mdefault_restore_location\u001b[39m(storage, location):\n\u001b[0;32m    380\u001b[0m     \u001b[39mfor\u001b[39;00m _, _, fn \u001b[39min\u001b[39;00m _package_registry:\n\u001b[1;32m--> 381\u001b[0m         result \u001b[39m=\u001b[39m fn(storage, location)\n\u001b[0;32m    382\u001b[0m         \u001b[39mif\u001b[39;00m result \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m    383\u001b[0m             \u001b[39mreturn\u001b[39;00m result\n",
+      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\serialization.py:274\u001b[0m, in \u001b[0;36m_cuda_deserialize\u001b[1;34m(obj, location)\u001b[0m\n\u001b[0;32m    272\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_cuda_deserialize\u001b[39m(obj, location):\n\u001b[0;32m    273\u001b[0m     \u001b[39mif\u001b[39;00m location\u001b[39m.\u001b[39mstartswith(\u001b[39m'\u001b[39m\u001b[39mcuda\u001b[39m\u001b[39m'\u001b[39m):\n\u001b[1;32m--> 274\u001b[0m         device \u001b[39m=\u001b[39m validate_cuda_device(location)\n\u001b[0;32m    275\u001b[0m         \u001b[39mif\u001b[39;00m \u001b[39mgetattr\u001b[39m(obj, \u001b[39m\"\u001b[39m\u001b[39m_torch_load_uninitialized\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39mFalse\u001b[39;00m):\n\u001b[0;32m    276\u001b[0m             \u001b[39mwith\u001b[39;00m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39mdevice(device):\n",
+      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\serialization.py:258\u001b[0m, in \u001b[0;36mvalidate_cuda_device\u001b[1;34m(location)\u001b[0m\n\u001b[0;32m    255\u001b[0m device \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39m_utils\u001b[39m.\u001b[39m_get_device_index(location, \u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m    257\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39mis_available():\n\u001b[1;32m--> 258\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39mAttempting to deserialize object on a CUDA \u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m    259\u001b[0m                        \u001b[39m'\u001b[39m\u001b[39mdevice but torch.cuda.is_available() is False. \u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m    260\u001b[0m                        \u001b[39m'\u001b[39m\u001b[39mIf you are running on a CPU-only machine, \u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m    261\u001b[0m                        \u001b[39m'\u001b[39m\u001b[39mplease use torch.load with map_location=torch.device(\u001b[39m\u001b[39m\\'\u001b[39;00m\u001b[39mcpu\u001b[39m\u001b[39m\\'\u001b[39;00m\u001b[39m) \u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m    262\u001b[0m                        \u001b[39m'\u001b[39m\u001b[39mto map your storages to the CPU.\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m    263\u001b[0m device_count \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mcuda\u001b[39m.\u001b[39mdevice_count()\n\u001b[0;32m    264\u001b[0m \u001b[39mif\u001b[39;00m device \u001b[39m>\u001b[39m\u001b[39m=\u001b[39m device_count:\n",
+      "\u001b[1;31mRuntimeError\u001b[0m: Attempting to deserialize object on a CUDA device but torch.cuda.is_available() is False. If you are running on a CPU-only machine, please use torch.load with map_location=torch.device('cpu') to map your storages to the CPU."
+     ]
+    }
+   ],
+   "source": [
+    "model.load_state_dict(torch.load(\"my_model_cifar.pt\"))\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",
+    "class_correct_newNET = list(0.0 for i in range(10))\n",
+    "class_total_newNET = list(0.0 for i in range(10))\n",
     "\n",
     "import torch.optim as optim\n",
     "\n",
@@ -840,22 +832,22 @@
     "    # 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",
+    "        class_correct_newNET[label] += correct[i].item()\n",
+    "        class_total_newNET[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",
+    "    if class_total_newNET[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",
+    "                100 * class_correct_newNET[i] / class_total_newNET[i],\n",
+    "                np.sum(class_correct_newNET[i]),\n",
+    "                np.sum(class_total_newNET[i]),\n",
     "            )\n",
     "        )\n",
     "    else:\n",
@@ -864,100 +856,39 @@
     "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",
+    "        100.0 * np.sum(class_correct_newNET) / np.sum(class_total_newNET),\n",
+    "        np.sum(class_correct_newNET),\n",
+    "        np.sum(class_total_newNET),\n",
     "    )\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 82,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
-     "ename": "RuntimeError",
-     "evalue": "Error(s) in loading state_dict for newNet:\n\tMissing key(s) in state_dict: \"conv3.weight\", \"conv3.bias\". \n\tsize mismatch for conv1.weight: copying a param with shape torch.Size([6, 3, 5, 5]) from checkpoint, the shape in current model is torch.Size([16, 3, 3, 3]).\n\tsize mismatch for conv1.bias: copying a param with shape torch.Size([6]) from checkpoint, the shape in current model is torch.Size([16]).\n\tsize mismatch for conv2.weight: copying a param with shape torch.Size([16, 6, 5, 5]) from checkpoint, the shape in current model is torch.Size([32, 16, 3, 3]).\n\tsize mismatch for conv2.bias: copying a param with shape torch.Size([16]) from checkpoint, the shape in current model is torch.Size([32]).\n\tsize mismatch for fc1.weight: copying a param with shape torch.Size([120, 400]) from checkpoint, the shape in current model is torch.Size([512, 256]).\n\tsize mismatch for fc1.bias: copying a param with shape torch.Size([120]) from checkpoint, the shape in current model is torch.Size([512]).\n\tsize mismatch for fc2.weight: copying a param with shape torch.Size([84, 120]) from checkpoint, the shape in current model is torch.Size([64, 512]).\n\tsize mismatch for fc2.bias: copying a param with shape torch.Size([84]) from checkpoint, the shape in current model is torch.Size([64]).\n\tsize mismatch for fc3.weight: copying a param with shape torch.Size([10, 84]) from checkpoint, the shape in current model is torch.Size([10, 64]).",
+     "ename": "NameError",
+     "evalue": "name 'class_correct_newNET' is not defined",
      "output_type": "error",
      "traceback": [
       "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
-      "\u001b[1;32mc:\\Users\\Utilisateur\\Documents\\GitHub\\image-classification\\TD2 Deep Learning.ipynb Cell 25\u001b[0m line \u001b[0;36m1\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X56sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m model1 \u001b[39m=\u001b[39m newNet()  \u001b[39m# Remplacez Net par le type de modèle que vous utilisez\u001b[39;00m\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X56sZmlsZQ%3D%3D?line=11'>12</a>\u001b[0m model2 \u001b[39m=\u001b[39m newNet()  \u001b[39m# Assurez-vous que les deux modèles ont la même architecture\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X56sZmlsZQ%3D%3D?line=13'>14</a>\u001b[0m model1\u001b[39m.\u001b[39mload_state_dict(torch\u001b[39m.\u001b[39mload(model_path1))\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X56sZmlsZQ%3D%3D?line=14'>15</a>\u001b[0m model2\u001b[39m.\u001b[39mload_state_dict(torch\u001b[39m.\u001b[39mload(model_path2))\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X56sZmlsZQ%3D%3D?line=16'>17</a>\u001b[0m \u001b[39m# Mettez les modèles en mode évaluation\u001b[39;00m\n",
-      "File \u001b[1;32mc:\\Users\\Utilisateur\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\module.py:2152\u001b[0m, in \u001b[0;36mModule.load_state_dict\u001b[1;34m(self, state_dict, strict, assign)\u001b[0m\n\u001b[0;32m   2147\u001b[0m         error_msgs\u001b[39m.\u001b[39minsert(\n\u001b[0;32m   2148\u001b[0m             \u001b[39m0\u001b[39m, \u001b[39m'\u001b[39m\u001b[39mMissing key(s) in state_dict: \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m. \u001b[39m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[0;32m   2149\u001b[0m                 \u001b[39m'\u001b[39m\u001b[39m, \u001b[39m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mjoin(\u001b[39mf\u001b[39m\u001b[39m'\u001b[39m\u001b[39m\"\u001b[39m\u001b[39m{\u001b[39;00mk\u001b[39m}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m'\u001b[39m \u001b[39mfor\u001b[39;00m k \u001b[39min\u001b[39;00m missing_keys)))\n\u001b[0;32m   2151\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(error_msgs) \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m:\n\u001b[1;32m-> 2152\u001b[0m     \u001b[39mraise\u001b[39;00m \u001b[39mRuntimeError\u001b[39;00m(\u001b[39m'\u001b[39m\u001b[39mError(s) in loading state_dict for \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m:\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m\\t\u001b[39;00m\u001b[39m{}\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mformat(\n\u001b[0;32m   2153\u001b[0m                        \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__class__\u001b[39m\u001b[39m.\u001b[39m\u001b[39m__name__\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m\\t\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mjoin(error_msgs)))\n\u001b[0;32m   2154\u001b[0m \u001b[39mreturn\u001b[39;00m _IncompatibleKeys(missing_keys, unexpected_keys)\n",
-      "\u001b[1;31mRuntimeError\u001b[0m: Error(s) in loading state_dict for newNet:\n\tMissing key(s) in state_dict: \"conv3.weight\", \"conv3.bias\". \n\tsize mismatch for conv1.weight: copying a param with shape torch.Size([6, 3, 5, 5]) from checkpoint, the shape in current model is torch.Size([16, 3, 3, 3]).\n\tsize mismatch for conv1.bias: copying a param with shape torch.Size([6]) from checkpoint, the shape in current model is torch.Size([16]).\n\tsize mismatch for conv2.weight: copying a param with shape torch.Size([16, 6, 5, 5]) from checkpoint, the shape in current model is torch.Size([32, 16, 3, 3]).\n\tsize mismatch for conv2.bias: copying a param with shape torch.Size([16]) from checkpoint, the shape in current model is torch.Size([32]).\n\tsize mismatch for fc1.weight: copying a param with shape torch.Size([120, 400]) from checkpoint, the shape in current model is torch.Size([512, 256]).\n\tsize mismatch for fc1.bias: copying a param with shape torch.Size([120]) from checkpoint, the shape in current model is torch.Size([512]).\n\tsize mismatch for fc2.weight: copying a param with shape torch.Size([84, 120]) from checkpoint, the shape in current model is torch.Size([64, 512]).\n\tsize mismatch for fc2.bias: copying a param with shape torch.Size([84]) from checkpoint, the shape in current model is torch.Size([64]).\n\tsize mismatch for fc3.weight: copying a param with shape torch.Size([10, 84]) from checkpoint, the shape in current model is torch.Size([10, 64])."
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32mc:\\Users\\Utilisateur\\Documents\\GitHub\\image-classification\\TD2 Deep Learning.ipynb Cell 27\u001b[0m line \u001b[0;36m8\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39m# Plotting\u001b[39;00m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m labels \u001b[39m=\u001b[39m [\u001b[39m\"\u001b[39m\u001b[39mModel 1\u001b[39m\u001b[39m\"\u001b[39m, \u001b[39m\"\u001b[39m\u001b[39mModel 2\u001b[39m\u001b[39m\"\u001b[39m]\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m accuracy_overall \u001b[39m=\u001b[39m [\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m     \u001b[39m100.0\u001b[39m \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39msum(class_correct_NET) \u001b[39m/\u001b[39m np\u001b[39m.\u001b[39msum(class_total_NET),\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m     \u001b[39m100.0\u001b[39m \u001b[39m*\u001b[39m np\u001b[39m.\u001b[39msum(class_correct_newNET) \u001b[39m/\u001b[39m np\u001b[39m.\u001b[39msum(class_total_newNET),\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=8'>9</a>\u001b[0m ]\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m plt\u001b[39m.\u001b[39mbar(labels, accuracy_overall)\n\u001b[0;32m     <a href='vscode-notebook-cell:/c%3A/Users/Utilisateur/Documents/GitHub/image-classification/TD2%20Deep%20Learning.ipynb#X33sZmlsZQ%3D%3D?line=11'>12</a>\u001b[0m plt\u001b[39m.\u001b[39mxlabel(\u001b[39m\"\u001b[39m\u001b[39mModels\u001b[39m\u001b[39m\"\u001b[39m)\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'class_correct_newNET' is not defined"
      ]
     }
    ],
    "source": [
-    "import torch\n",
-    "import torch.nn as nn\n",
-    "import torch.optim as optim\n",
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
     "\n",
-    "# Charger les modèles\n",
-    "model_path1 = \"./model_cifar.pt\"\n",
-    "model_path2 = \"./my_model_cifar.pt\"\n",
-    "\n",
-    "model1 = Net()  # Remplacez Net par le type de modèle que vous utilisez\n",
-    "model2 = newNet()  # Assurez-vous que les deux modèles ont la même architecture\n",
-    "\n",
-    "model1.load_state_dict(torch.load(model_path1))\n",
-    "model2.load_state_dict(torch.load(model_path2))\n",
-    "\n",
-    "# Mettez les modèles en mode évaluation\n",
-    "model1.eval()\n",
-    "model2.eval()\n",
-    "\n",
-    "# Initialiser les variables pour le suivi des performances\n",
-    "test_loss = [0.0, 0.0]  # Liste pour stocker les pertes de test pour chaque modèle\n",
-    "class_correct = [list(0.0 for i in range(10)), list(0.0 for i in range(10))]\n",
-    "class_total = [list(0.0 for i in range(10)), list(0.0 for i in range(10))]\n",
-    "\n",
-    "# Définir le critère et l'optimiseur\n",
-    "criterion = nn.CrossEntropyLoss()\n",
-    "\n",
-    "# Boucle sur le jeu de données de test\n",
-    "for model_num, model in enumerate([model1, model2]):\n",
-    "    for data, target in test_loader:\n",
-    "        if train_on_gpu:\n",
-    "            data, target = data.cuda(), target.cuda()\n",
-    "        output = model(data)\n",
-    "        loss = criterion(output, target)\n",
-    "        test_loss[model_num] += loss.item() * data.size(0)\n",
-    "\n",
-    "        _, pred = torch.max(output, 1)\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",
-    "\n",
-    "        for i in range(batch_size):\n",
-    "            label = target.data[i]\n",
-    "            class_correct[model_num][label] += correct[i].item()\n",
-    "            class_total[model_num][label] += 1\n",
-    "\n",
-    "    test_loss[model_num] = test_loss[model_num] / len(test_loader)\n",
-    "\n",
-    "# Afficher les performances de chaque modèle\n",
-    "for model_num, model in enumerate([\"Model 1\", \"Model 2\"]):\n",
-    "    print(f\"\\n{model} Test Loss: {test_loss[model_num]:.6f}\\n\")\n",
-    "    for i in range(10):\n",
-    "        if class_total[model_num][i] > 0:\n",
-    "            print(\n",
-    "                f\"Test Accuracy of {classes[i]}: {100 * class_correct[model_num][i] / class_total[model_num][i]:.2f}%\"\n",
-    "            )\n",
-    "        else:\n",
-    "            print(f\"Test Accuracy of {classes[i]}: N/A (no training examples)\")\n",
-    "\n",
     "# Plotting\n",
     "labels = [\"Model 1\", \"Model 2\"]\n",
     "accuracy_overall = [\n",
-    "    100.0 * np.sum(class_correct[0]) / np.sum(class_total[0]),\n",
-    "    100.0 * np.sum(class_correct[1]) / np.sum(class_total[1]),\n",
+    "    100.0 * np.sum(class_correct_NET) / np.sum(class_total_NET),\n",
+    "    100.0 * np.sum(class_correct_newNET) / np.sum(class_total_newNET),\n",
     "]\n",
     "\n",
     "plt.bar(labels, accuracy_overall)\n",
@@ -969,7 +900,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -987,7 +918,7 @@
     "model_path1 = \"./model_cifar.pt\"\n",
     "model_path2 = \"./my_model_cifar.pt\"\n",
     "\n",
-    "model1 = newNet()  # Remplacez Net par le type de modèle que vous utilisez\n",
+    "model1 = Net()  # Remplacez Net par le type de modèle que vous utilisez\n",
     "model1.load_state_dict(torch.load(model_path1))\n",
     "\n",
     "\n",
diff --git a/result/comparaison_loss_models.png b/result/comparaison_loss_models.png
new file mode 100644
index 0000000000000000000000000000000000000000..f3507aeab18f8210449bdad028ceb1fc7974f7e9
GIT binary patch
literal 18366
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

literal 0
HcmV?d00001

-- 
GitLab