CIFAR10PyTorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "073a7575",
   "metadata": {},
   "source": [
    "## Environment Setup\n",
    "Let's first setup our environment\n",
    "- Install all required libraries\n",
    "- Initialise some constants\n",
    "- Import the CIFAR10 dataset (in my case I already have it installed)\n",
    "The CIFAR10 dataset is images so we have to apply a transform to turn the images into tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f5d8c57f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "from torch.utils.data.dataloader import DataLoader\n",
    "\n",
    "NUM_CLASSES = 10\n",
    "BATCH_SIZE = 10\n",
    "IMAGE_DIM = 32\n",
    "NUM_CHANNELS = 3\n",
    "KERNEL_SIZE = 3\n",
    "\n",
    "transform = torchvision.transforms.Compose(\n",
    "    [torchvision.transforms.ToTensor(), \n",
    "     torchvision.transforms.Normalize((0.49139968, 0.48215827 ,0.44653124), (0.24703233, 0.24348505, 0.26158768))])\n",
    "training_dataset = torchvision.datasets.CIFAR10('./data', train=True, transform=transform)\n",
    "testing_dataset = torchvision.datasets.CIFAR10('./data', train=False, transform=transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10f25cc4",
   "metadata": {},
   "source": [
    "## Setting up the Network Class\n",
    "Now onto the main part: Defining our network class\n",
    "I like to encapsulate and abstract everything into classes so I decided to keep everything (including the training loop) in the network class. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a34aed05",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        #Define Layers\n",
    "        self.network = nn.Sequential(\n",
    "            nn.Conv2d(3, 32, (3,3), padding='same'),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d((2,2)),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.Conv2d(32, 64, (3,3), padding='same'),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d((2,2)),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.Conv2d(64, 128, (3,3), padding='same'),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d((2,2)),\n",
    "            nn.Dropout(0.1),\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(2048, 64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64, NUM_CLASSES),\n",
    "            nn.Softmax(-1)\n",
    "        )\n",
    "        self.training_losses = []\n",
    "        self.validation_losses = []\n",
    "    \n",
    "    def __forward(self, input):\n",
    "        output = self.network.forward(input)\n",
    "        return output\n",
    "\n",
    "    def __accuracy(self, testing_data_loader):\n",
    "        #Get accuracy on test dataset (just percentage of correct responses)\n",
    "        for idx, batch in enumerate(testing_data_loader):\n",
    "            correct = 0\n",
    "            total = 0\n",
    "            inputs, labels = batch\n",
    "            preds = self.__forward(inputs)\n",
    "            for pred, label in zip(preds, labels):\n",
    "                if torch.argmax(pred) == label:\n",
    "                    correct += 1\n",
    "                total += 1\n",
    "            return (100 * correct / total)\n",
    "        \n",
    "    def predict(self, input):\n",
    "        return(self.__forward(input))\n",
    "    \n",
    "    def train_network(self, training_data_loader, testing_data_loader, epochs, lr, device=\"cpu\"):\n",
    "\n",
    "        optimizer = torch.optim.SGD(self.parameters(), lr=lr, momentum=0.9)\n",
    "        loss_fn = nn.CrossEntropyLoss()\n",
    "\n",
    "        #Iterate for epochs\n",
    "        for epoch in range(epochs):\n",
    "            print(f\"Epoch Number {epoch}\")\n",
    "\n",
    "            #Set model in train mode\n",
    "            self.train()\n",
    "\n",
    "            total_loss = 0\n",
    "            #Go through every loss\n",
    "            for idx, batch in enumerate(training_data_loader):\n",
    "                #Reset gradients\n",
    "                optimizer.zero_grad()\n",
    "\n",
    "                inputs, labels = batch\n",
    "                inputs = inputs.to(device).to(torch.float32)\n",
    "                labels = labels.to(device)\n",
    "                \n",
    "                #Get predictions and calculate loss\n",
    "                preds = self.__forward(inputs)\n",
    "                loss = loss_fn(preds, labels)\n",
    "\n",
    "                #Calculate loss gradients by backpropagating\n",
    "                loss.backward()\n",
    "\n",
    "                #Update model weights and biases\n",
    "                optimizer.step()\n",
    "\n",
    "                total_loss += loss.item()\n",
    "                \n",
    "            #Get validation loss\n",
    "            self.eval()\n",
    "            with torch.no_grad():\n",
    "                val_input, val_target = next(iter(test_data_loader))\n",
    "                val_output = self.__forward(val_input)\n",
    "                val_loss = loss_fn(val_output, val_target)\n",
    "                print(f\"Loss: {round((total_loss/BATCH_SIZE), 2)}  Val Loss: {round(val_loss.item(), 2)}\")\n",
    "\n",
    "                #Get and print accuracy\n",
    "                accuracy = self.__accuracy(testing_data_loader)\n",
    "                print(f\"Accuracy {round(accuracy, 2)}%\")\n",
    "\n",
    "                #Append val and train loss to list to use to plot later\n",
    "                self.training_losses.append(total_loss/BATCH_SIZE)\n",
    "                self.validation_losses.append(val_loss.item())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a25d6370",
   "metadata": {},
   "source": [
    "## Dataloaders :)\n",
    "Create PyTorch dataloaders from our train and test datasets. The dataloaders make it so much easier to handle batches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fb9278b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_DATASET_LEN = 10000\n",
    "\n",
    "train_data_loader = DataLoader(training_dataset, BATCH_SIZE, True, num_workers=2)\n",
    "test_data_loader = DataLoader(testing_dataset, TEST_DATASET_LEN, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1b8befc",
   "metadata": {},
   "source": [
    "## Start Training!\n",
    "We can declare an instance of our network and begin training with just one line of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a921ccb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch Number 0\n",
      "Loss: 1133.39  Val Loss: 2.18\n",
      "Accuracy 27.04%\n",
      "Epoch Number 1\n",
      "Loss: 1075.0  Val Loss: 2.11\n",
      "Accuracy 35.16%\n",
      "Epoch Number 2\n",
      "Loss: 1047.35  Val Loss: 2.06\n",
      "Accuracy 41.0%\n",
      "Epoch Number 3\n",
      "Loss: 1026.35  Val Loss: 2.02\n",
      "Accuracy 44.12%\n",
      "Epoch Number 4\n",
      "Loss: 1011.24  Val Loss: 2.0\n",
      "Accuracy 46.44%\n",
      "Epoch Number 5\n",
      "Loss: 995.65  Val Loss: 1.98\n",
      "Accuracy 48.33%\n",
      "Epoch Number 6\n",
      "Loss: 981.09  Val Loss: 1.94\n",
      "Accuracy 51.86%\n",
      "Epoch Number 7\n",
      "Loss: 967.98  Val Loss: 1.93\n",
      "Accuracy 52.82%\n",
      "Epoch Number 8\n",
      "Loss: 956.26  Val Loss: 1.89\n",
      "Accuracy 56.95%\n",
      "Epoch Number 9\n",
      "Loss: 946.92  Val Loss: 1.88\n",
      "Accuracy 58.53%\n",
      "Epoch Number 10\n",
      "Loss: 936.33  Val Loss: 1.87\n",
      "Accuracy 58.85%\n",
      "Epoch Number 11\n",
      "Loss: 928.92  Val Loss: 1.85\n",
      "Accuracy 61.71%\n",
      "Epoch Number 12\n",
      "Loss: 920.63  Val Loss: 1.84\n",
      "Accuracy 62.09%\n",
      "Epoch Number 13\n",
      "Loss: 913.4  Val Loss: 1.82\n",
      "Accuracy 64.05%\n",
      "Epoch Number 14\n",
      "Loss: 906.75  Val Loss: 1.82\n",
      "Accuracy 64.45%\n",
      "Epoch Number 15\n",
      "Loss: 900.57  Val Loss: 1.8\n",
      "Accuracy 66.09%\n",
      "Epoch Number 16\n",
      "Loss: 895.42  Val Loss: 1.8\n",
      "Accuracy 65.95%\n",
      "Epoch Number 17\n",
      "Loss: 890.15  Val Loss: 1.79\n",
      "Accuracy 66.83%\n",
      "Epoch Number 18\n",
      "Loss: 885.53  Val Loss: 1.78\n",
      "Accuracy 67.83%\n",
      "Epoch Number 19\n",
      "Loss: 880.61  Val Loss: 1.79\n",
      "Accuracy 67.18%\n",
      "Epoch Number 20\n",
      "Loss: 876.51  Val Loss: 1.78\n",
      "Accuracy 68.62%\n",
      "Epoch Number 21\n",
      "Loss: 873.17  Val Loss: 1.77\n",
      "Accuracy 68.72%\n",
      "Epoch Number 22\n",
      "Loss: 869.26  Val Loss: 1.76\n",
      "Accuracy 69.84%\n",
      "Epoch Number 23\n",
      "Loss: 866.03  Val Loss: 1.75\n",
      "Accuracy 70.74%\n",
      "Epoch Number 24\n",
      "Loss: 862.69  Val Loss: 1.76\n",
      "Accuracy 70.69%\n",
      "Epoch Number 25\n",
      "Loss: 860.16  Val Loss: 1.75\n",
      "Accuracy 71.07%\n",
      "Epoch Number 26\n",
      "Loss: 856.83  Val Loss: 1.77\n",
      "Accuracy 69.4%\n",
      "Epoch Number 27\n",
      "Loss: 853.47  Val Loss: 1.74\n",
      "Accuracy 72.29%\n",
      "Epoch Number 28\n",
      "Loss: 850.97  Val Loss: 1.74\n",
      "Accuracy 72.02%\n",
      "Epoch Number 29\n",
      "Loss: 849.37  Val Loss: 1.73\n",
      "Accuracy 72.82%\n",
      "Epoch Number 30\n",
      "Loss: 846.99  Val Loss: 1.73\n",
      "Accuracy 72.82%\n",
      "Epoch Number 31\n",
      "Loss: 843.08  Val Loss: 1.73\n",
      "Accuracy 73.05%\n",
      "Epoch Number 32\n",
      "Loss: 842.1  Val Loss: 1.74\n",
      "Accuracy 72.58%\n",
      "Epoch Number 33\n",
      "Loss: 839.58  Val Loss: 1.73\n",
      "Accuracy 73.42%\n",
      "Epoch Number 34\n",
      "Loss: 836.91  Val Loss: 1.72\n",
      "Accuracy 73.52%\n",
      "Epoch Number 35\n",
      "Loss: 835.17  Val Loss: 1.72\n",
      "Accuracy 73.92%\n",
      "Epoch Number 36\n",
      "Loss: 833.38  Val Loss: 1.71\n",
      "Accuracy 74.73%\n",
      "Epoch Number 37\n",
      "Loss: 831.78  Val Loss: 1.73\n",
      "Accuracy 73.21%\n",
      "Epoch Number 38\n",
      "Loss: 829.83  Val Loss: 1.72\n",
      "Accuracy 74.21%\n",
      "Epoch Number 39\n",
      "Loss: 827.63  Val Loss: 1.72\n",
      "Accuracy 74.27%\n",
      "Epoch Number 40\n",
      "Loss: 825.72  Val Loss: 1.71\n",
      "Accuracy 74.89%\n",
      "Epoch Number 41\n",
      "Loss: 824.8  Val Loss: 1.72\n",
      "Accuracy 74.45%\n",
      "Epoch Number 42\n",
      "Loss: 823.28  Val Loss: 1.71\n",
      "Accuracy 74.89%\n",
      "Epoch Number 43\n",
      "Loss: 822.25  Val Loss: 1.71\n",
      "Accuracy 75.17%\n",
      "Epoch Number 44\n",
      "Loss: 819.98  Val Loss: 1.71\n",
      "Accuracy 75.14%\n",
      "Epoch Number 45\n",
      "Loss: 819.43  Val Loss: 1.72\n",
      "Accuracy 74.3%\n",
      "Epoch Number 46\n",
      "Loss: 817.2  Val Loss: 1.7\n",
      "Accuracy 75.89%\n",
      "Epoch Number 47\n",
      "Loss: 815.68  Val Loss: 1.7\n",
      "Accuracy 75.55%\n",
      "Epoch Number 48\n",
      "Loss: 814.63  Val Loss: 1.71\n",
      "Accuracy 74.92%\n",
      "Epoch Number 49\n",
      "Loss: 814.04  Val Loss: 1.71\n",
      "Accuracy 75.24%\n"
     ]
    }
   ],
   "source": [
    "EPOCHS = 50\n",
    "LEARNING_RATE = 7e-4\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "    \n",
    "cnn_network = Network().to(device)\n",
    "cnn_network.train_network(train_data_loader, test_data_loader, EPOCHS, LEARNING_RATE, device)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61ea2722",
   "metadata": {},
   "source": [
    "## Part 2: Visualization\n",
    "Let's import pyplot from matplotlib and visualize our training and validation losses over epochs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4232310f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGzCAYAAAD9pBdvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/av/WaAAAACXBIWXMAAA9hAAAPYQGoP6dpAABM9UlEQVR4nO3dd3hUVf4/8PdMymTSew8kAUIoJnQIiLQIIiBgWXRBQF0bAUXW3a/4WwVcV8CuSHEtIK4IghRBEEFIEKQlEEqAEEhCeu9tkpk5vz9CRoYkkDo3mXm/nmceyJ1z537mZh7mzTnnnisTQggQERERSUQudQFERERk2hhGiIiISFIMI0RERCQphhEiIiKSFMMIERERSYphhIiIiCTFMEJERESSYhghIiIiSTGMEBERkaQYRogktmHDBshkMkRHR0tdSocxd+5c+Pv7622TyWRYunTpXfddunQpZDJZm9YTGRkJmUyGyMjINn1dIqrFMEJGr+7LvrHHiRMnpC6x0zpz5gxkMhn+9a9/NdomISEBMpkMixYtMmBlLbNmzRps2LBB6jL0jB49Gn379pW6DKJ2ZS51AUSG8tZbbyEgIKDe9u7du0tQjXEYMGAAgoOD8f333+Ptt99usM2mTZsAALNmzWrVsSorK2Fu3r7/ZK1Zswaurq6YO3eu3vb77rsPlZWVsLS0bNfjE5kqhhEyGRMnTsSgQYOkLsPozJw5E2+88QZOnDiBYcOG1Xv++++/R3BwMAYMGNCq41hZWbVq/9aQy+WSHp/I2HGYhuim5ORkyGQyvP/++/joo4/QtWtXKJVKjBo1ChcvXqzX/tChQxg5ciRsbGzg6OiIqVOn4vLly/Xapaen45lnnoG3tzcUCgUCAgLw4osvorq6Wq+dSqXCokWL4ObmBhsbG0yfPh25ubl6baKjozFhwgS4urpCqVQiICAATz/99B3f1+TJkxEYGNjgc2FhYXoB7cCBA7j33nvh6OgIW1tb9OzZE6+//vodX3/mzJkA/uwBuVVMTAzi4+N1bXbt2oVJkybpzkW3bt3w73//GxqN5o7HABqeM3L06FEMHjwYVlZW6NatGz7//PMG912/fj3Gjh0Ld3d3KBQK9O7dG2vXrtVr4+/vj7i4OERFRemG8EaPHg2g8TkjW7duxcCBA6FUKuHq6opZs2YhPT1dr83cuXNha2uL9PR0TJs2Dba2tnBzc8Orr77apPfdVGvWrEGfPn2gUCjg7e2NiIgIFBUV6bVJSEjAI488Ak9PT1hZWcHX1xePP/44iouLdW1a8hkgai32jJDJKC4uRl5ent42mUwGFxcXvW0bN25EaWkpIiIiUFVVhU8++QRjx47FhQsX4OHhAQA4ePAgJk6ciMDAQCxduhSVlZVYtWoVRowYgTNnzugmX2ZkZGDIkCEoKirCc889h+DgYKSnp2Pbtm2oqKjQ6/ZfsGABnJycsGTJEiQnJ+Pjjz/G/PnzsWXLFgBATk4Oxo8fDzc3N7z22mtwdHREcnIytm/ffsf3PWPGDMyePRunT5/G4MGDddtv3LiBEydO4L333gMAxMXFYfLkyQgJCcFbb70FhUKBa9eu4dixY3d8/YCAAAwfPhw//PADPvroI5iZmemeqwsof/3rXwHUzt+xtbXFokWLYGtri0OHDuHNN99ESUmJro6munDhgu58LF26FGq1GkuWLNH9jm61du1a9OnTBw899BDMzc2xe/duzJs3D1qtFhEREQCAjz/+GAsWLICtrS3+3//7fwDQ4GvV2bBhA5566ikMHjwYy5cvR3Z2Nj755BMcO3YMZ8+ehaOjo66tRqPBhAkTMHToULz//vs4ePAgPvjgA3Tr1g0vvvhis953Q5YuXYply5YhPDwcL774IuLj47F27VqcPn0ax44dg4WFBaqrqzFhwgSoVCosWLAAnp6eSE9Px549e1BUVAQHB4cWfwaIWk0QGbn169cLAA0+FAqFrl1SUpIAIJRKpUhLS9NtP3nypAAgXnnlFd22fv36CXd3d5Gfn6/bdu7cOSGXy8Xs2bN122bPni3kcrk4ffp0vbq0Wq1efeHh4bptQgjxyiuvCDMzM1FUVCSEEGLHjh0CQIOvdSfFxcVCoVCIv//973rb3333XSGTycSNGzeEEEJ89NFHAoDIzc1t1usLIcTq1asFALF//37dNo1GI3x8fERYWJhuW0VFRb19n3/+eWFtbS2qqqp02+bMmSO6du2q1w6AWLJkie7nadOmCSsrK139Qghx6dIlYWZmJm7/p62h406YMEEEBgbqbevTp48YNWpUvbaHDx8WAMThw4eFEEJUV1cLd3d30bdvX1FZWalrt2fPHgFAvPnmm3rvBYB466239F6zf//+YuDAgfWOdbtRo0aJPn36NPp8Tk6OsLS0FOPHjxcajUa3/bPPPhMAxNdffy2EEOLs2bMCgNi6dWujr9WazwBRa3CYhkzG6tWrceDAAb3Hvn376rWbNm0afHx8dD8PGTIEQ4cOxd69ewEAmZmZiI2Nxdy5c+Hs7KxrFxISgvvvv1/XTqvVYufOnZgyZUqDc1Vuv/z0ueee09s2cuRIaDQa3LhxAwB0/9Pes2cPampqmvy+7e3tMXHiRPzwww8QQui2b9myBcOGDUOXLl30Xn/Xrl3QarVNfn2gtvfFwsJCb6gmKioK6enpuiEaAFAqlbq/l5aWIi8vDyNHjkRFRQWuXLnS5ONpNBrs378f06ZN09UPAL169cKECRPqtb/1uHU9ZKNGjUJiYqLeEEVTRUdHIycnB/PmzdObSzJp0iQEBwfj559/rrfPCy+8oPfzyJEjkZiY2Oxj3+7gwYOorq7GwoULIZf/+U/6s88+C3t7e10tDg4OAID9+/ejoqKiwddqzWeAqDUYRshkDBkyBOHh4XqPMWPG1GvXo0ePetuCgoKQnJwMALpw0LNnz3rtevXqhby8PJSXlyM3NxclJSVNvizz1i9VAHBycgIAFBYWAgBGjRqFRx55BMuWLYOrqyumTp2K9evXQ6VS3fW1Z8yYgdTUVBw/fhwAcP36dcTExGDGjBl6bUaMGIG//e1v8PDwwOOPP44ffvihSV9KLi4umDBhAnbs2IGqqioAtUM05ubm+Mtf/qJrFxcXh+nTp8PBwQH29vZwc3PTXWXTnFCQm5uLysrKBn9XDf1ejh07hvDwcN38Hjc3N908iJaEkTt9BoKDg3XP17GysoKbm5veNicnJ93vtjUaq8XS0hKBgYG65wMCArBo0SJ8+eWXcHV1xYQJE7B69Wq999+azwBRazCMEHUQt861uFVdb4ZMJsO2bdtw/PhxzJ8/H+np6Xj66acxcOBAlJWV3fG1p0yZAmtra/zwww8AgB9++AFyuRyPPfaYro1SqcSRI0dw8OBBPPnkkzh//jxmzJiB+++/v0kTLWfNmoWSkhLs2bMH1dXV+PHHH3VzOgCgqKgIo0aNwrlz5/DWW29h9+7dOHDgAFauXAkA7faFd/36dYwbNw55eXn48MMP8fPPP+PAgQN45ZVX2vW4t2rsd2toH3zwAc6fP4/XX38dlZWVeOmll9CnTx+kpaUBaP1ngKilGEaIbpOQkFBv29WrV3WTUrt27QoAiI+Pr9fuypUrcHV1hY2NDdzc3GBvb9/glTitMWzYMPznP/9BdHQ0vvvuO8TFxWHz5s133MfGxgaTJ0/G1q1bodVqsWXLFowcORLe3t567eRyOcaNG4cPP/wQly5dwn/+8x8cOnQIhw8fvmtdDz30EOzs7LBp0ybs27cPhYWFekM0kZGRyM/Px4YNG/Dyyy9j8uTJCA8P1/UANYebmxuUSmWDv6vbfy+7d++GSqXCTz/9hOeffx4PPvggwsPD9YZu6jR15dY7fQbi4+N1zxtCY7VUV1cjKSmpXi333HMP/vWvf+HIkSP4/fffkZ6ejnXr1umeb81ngKilGEaIbrNz5069yzNPnTqFkydPYuLEiQAALy8v9OvXD998843epZMXL17Er7/+igcffBBA7T/q06ZNw+7duxtc6v3W+RtNUVhYWG+ffv36AUCTh2oyMjLw5Zdf4ty5c3pDNABQUFBQb5/mvL5SqcT06dOxd+9erF27FjY2Npg6daru+bregVvfQ3V1NdasWXPX176dmZkZJkyYgJ07dyIlJUW3/fLly9i/f3+9trcft7i4GOvXr6/3ujY2NvUuh23IoEGD4O7ujnXr1umdm3379uHy5cuYNGlSc99Si4WHh8PS0hKffvqp3nv86quvUFxcrKulpKQEarVab9977rkHcrlc9x5a+xkgaile2ksmY9++fQ1Okhw+fLjeOhzdu3fHvffeixdffBEqlQoff/wxXFxc8M9//lPX5r333sPEiRMRFhaGZ555Rndpr4ODg95aGO+88w5+/fVXjBo1Cs899xx69eqFzMxMbN26FUePHtW7/PNuvvnmG6xZswbTp09Ht27dUFpaii+++AL29va6AHQnDz74IOzs7PDqq6/CzMwMjzzyiN7zb731Fo4cOYJJkyaha9euyMnJwZo1a+Dr64t77723STXOmjULGzduxP79+zFz5kzY2Njonhs+fDicnJwwZ84cvPTSS5DJZPj222+bHcrqLFu2DL/88gtGjhyJefPmQa1WY9WqVejTpw/Onz+vazd+/HhYWlpiypQpeP7551FWVoYvvvgC7u7uyMzM1HvNgQMHYu3atXj77bfRvXt3uLu7Y+zYsfWObWFhgZUrV+Kpp57CqFGj8MQTT+gu7fX399cNAbWV3NzcBle4DQgIwMyZM7F48WIsW7YMDzzwAB566CHEx8djzZo1GDx4sG5OzqFDhzB//nw89thjCAoKglqtxrfffqv3WWiLzwBRi0h3IQ+RYdzp0l4AYv369UKIPy/tfe+998QHH3wg/Pz8hEKhECNHjhTnzp2r97oHDx4UI0aMEEqlUtjb24spU6aIS5cu1Wt348YNMXv2bOHm5iYUCoUIDAwUERERQqVS6dV3+yW7t19OeubMGfHEE0+ILl26CIVCIdzd3cXkyZNFdHR0k8/FzJkzdZcR3+63334TU6dOFd7e3sLS0lJ4e3uLJ554Qly9erXJr69Wq4WXl5cAIPbu3Vvv+WPHjolhw4YJpVIpvL29xT//+U+xf/9+vfcpRNMu7RVCiKioKDFw4EBhaWkpAgMDxbp168SSJUvqXdr7008/iZCQEGFlZSX8/f3FypUrxddffy0AiKSkJF27rKwsMWnSJGFnZycA6C7zvf13UWfLli2if//+QqFQCGdnZzFz5ky9y8Lr3ouNjU29c9FQnQ0ZNWpUo5/dcePG6dp99tlnIjg4WFhYWAgPDw/x4osvisLCQt3ziYmJ4umnnxbdunUTVlZWwtnZWYwZM0YcPHhQ16YtPgNELSETooX/LSEyMsnJyQgICMB7772HV199VepyiIhMBueMEBERkaQYRoiIiEhSDCNEREQkKc4ZISIiIkmxZ4SIiIgkxTBCREREkuoUi55ptVpkZGTAzs6uycs1ExERkbSEECgtLYW3t7feXaVv1ynCSEZGBvz8/KQug4iIiFogNTUVvr6+jT7frDCyfPlybN++HVeuXIFSqcTw4cOxcuXKBm+jXeeLL77Axo0bdTcLGzhwIN555x0MGTKkyce1s7MDUPtm7O3tm1MyERERSaSkpAR+fn667/HGNCuMREVFISIiAoMHD4Zarcbrr7+O8ePH49KlS3r3oLhVZGQknnjiCQwfPhxWVlZYuXIlxo8fj7i4OPj4+DTpuHVDM/b29gwjREREnczdpli06tLe3NxcuLu7IyoqCvfdd1+T9tFoNHBycsJnn32G2bNnN9hGpVLp3SGyLlkVFxczjBAREXUSJSUlcHBwuOv3d6uupikuLgYAODs7N3mfiooK1NTU3HGf5cuXw8HBQffgfBEiIiLj1eKeEa1Wi4ceeghFRUU4evRok/ebN28e9u/fj7i4OFhZWTXYhj0jREREnV9Te0ZafDVNREQELl682KwgsmLFCmzevBmRkZGNBhEAUCgUUCgULS2NiIiIOpEWhZH58+djz549OHLkyB0v1bnV+++/jxUrVuDgwYMICQlpyWGJiIjICDUrjAghsGDBAuzYsQORkZEICAho0n7vvvsu/vOf/2D//v0YNGhQiwolIiIi49SsMBIREYFNmzZh165dsLOzQ1ZWFgDAwcEBSqUSADB79mz4+Phg+fLlAICVK1fizTffxKZNm+Dv76/bx9bWFra2tm35XoiIiKgTatbVNGvXrkVxcTFGjx4NLy8v3WPLli26NikpKcjMzNTbp7q6Go8++qjePu+//37bvQsiIiLqtJo9THM3kZGRej8nJyc35xBERERkYnjXXiIiIpIUwwgRERFJimGEiIiIJGXSYWRXbDoWbz+PsymFUpdCRERkskw6jPwal43vT6XidHKB1KUQERGZLJMOIz097QAA8VllEldCRERkukw6jAR53Awj2SUSV0JERGS6TDqMBN/sGUnILoNG26KbFxMREVErmXQY6eJsDSsLOVRqLW7kl0tdDhERkUky6TAil8v+HKrJKpW4GiIiItNk0mEEAHreDCNXGEaIiIgkwTByc97I1WyGESIiIikwjHhymIaIiEhKDCM3w0hyfjmqajQSV0NERGR6TD6MuNkq4GxjCa0AruVw8TMiIiJDM/kwIpPJEORhC4CTWImIiKRg8mEEAII97QEA8VlciZWIiMjQGEZwyyTWbA7TEBERGRrDCG65Rw17RoiIiAyOYQTQzRnJLlGhqKJa4mqIiIhMC8MIADsrC/g4KgFwvREiIiJDYxi5KVg3b4RhhIiIyJAYRm6qm8TKy3uJiIgMi2HkJt09ahhGiIiIDIph5KaetwzTCCEkroaIiMh0MIzcFOhqC3O5DKVVamQUV0ldDhERkclgGLnJ0lyOQDcbAByqISIiMiSGkVv0vLksPCexEhERGQ7DyC10l/dyJVYiIiKDYRi5hW5ZeN6jhoiIyGAYRm5R1zNyPacMNRqtxNUQERGZBoaRW/g4KmFjaYZqjRbJeeVSl0NERGQSGEZuIZfL0MODy8ITEREZEsPIbf6cxMowQkREZAgMI7fhPWqIiIgMi2HkNj1vDtNc5TANERGRQTCM3KauZySloAIV1WqJqyEiIjJ+DCO3cbFVwNXWEkIAV7neCBERUbtjGGlAXe8I71FDRETU/hhGGtDTg/eoISIiMhSGkQb09LQFAMRn8x41RERE7Y1hpAF1d++Nz+KcESIiovbGMNKAII/anpG8MhXyy1QSV0NERGTcGEYaYG1pji7O1gC4EisREVF7YxhpRN0VNbxHDRERUftiGGkE71FDRERkGAwjjQjy4D1qiIiIDIFhpBF1PSMJ2aXQaoXE1RARERkvhpFG+LvawNJMjvJqDdKLKqUuh4iIyGgxjDTCwkyOQDcbAByqISIiak8MI3dQN1RzlVfUEBERtRuGkTuoW4mVPSNERETth2HkDuruUcO79xIREbUfhpE7qOsZuZ5bhmq1VuJqiIiIjBPDyB14O1jBTmEOtVYgMY83zSMiImoPDCN3IJPJEMSVWImIiNoVw8hd9GQYISIialcMI3fR26t23sjZlCJpCyEiIjJSzQojy5cvx+DBg2FnZwd3d3dMmzYN8fHxd9wnLi4OjzzyCPz9/SGTyfDxxx+3pl6DGxboAgCISSlEVY1G4mqIiIiMT7PCSFRUFCIiInDixAkcOHAANTU1GD9+PMrLyxvdp6KiAoGBgVixYgU8PT1bXbChdXOzgbudAtVqLc6kFEpdDhERkdExb07jX375Re/nDRs2wN3dHTExMbjvvvsa3Gfw4MEYPHgwAOC1115rYZnSkclkGN7NBTtjM3D8ej6Gd3OVuiQiIiKj0qo5I8XFxQAAZ2fnNimmjkqlQklJid5DSnUB5I/r+ZLWQUREZIxaHEa0Wi0WLlyIESNGoG/fvm1ZE5YvXw4HBwfdw8/Pr01fv7nCutXOGzmXWoQylVrSWoiIiIxNi8NIREQELl68iM2bN7dlPQCAxYsXo7i4WPdITU1t82M0h5+zNfyclVBrBU4nF0haCxERkbFpURiZP38+9uzZg8OHD8PX17eta4JCoYC9vb3eQ2rDA2uHao5zqIaIiKhNNSuMCCEwf/587NixA4cOHUJAQEB71dXhDO9eO1Rz7FqexJUQEREZl2ZdTRMREYFNmzZh165dsLOzQ1ZWFgDAwcEBSqUSADB79mz4+Phg+fLlAIDq6mpcunRJ9/f09HTExsbC1tYW3bt3b8v30q7Cbq43cimzBIXl1XCysZS4IiIiIuPQrJ6RtWvXori4GKNHj4aXl5fusWXLFl2blJQUZGZm6n7OyMhA//790b9/f2RmZuL9999H//798be//a3t3oUBuNtboYe7LYQATiZxqIaIiKitNKtnRAhx1zaRkZF6P/v7+zdpv85geDcXJOSU4Y/r+Xigr5fU5RARERkF3pumGcK43ggREVGbYxhphmGBzpDJgGs5ZcgpqZK6HCIiIqPAMNIMjtaW6ONde5nx8UT2jhAREbUFhpFm0i0Nf41hhIiIqC0wjDRT3dLwfyRyvREiIqK2wDDSTIP9nWEulyG1oBKpBRVSl0NERNTpMYw0k63CHKF+jgC4NDwREVFbYBhpgeF1QzXXOVRDRETUWgwjLaCbN3I932gWdCMiIpIKw0gLDOjiBEtzOXJKVbieWy51OURERJ0aw0gLWFmYYVBXJwDAcQ7VEBERtQrDSAsNv2WohoiIiFqOYaSFhnevXfzseGI+tFrOGyEiImophpEWCvFxgK3CHEUVNbiUWSJ1OURERJ0Ww0gLmZvJMSTAGQDXGyEiImoNhpFW4HojRERErccw0gp1642cSipAjUYrcTVERESdE8NIK/TytIejtQXKqzU4n1YsdTlERESdEsNIK8jlMoQF1vaOcL0RIiKilmEYaSWuN0JERNQ6DCOtFNatdr2R6BuFqKrRSFwNERFR58Mw0krd3GzgbqdAtVqLMymFUpdDRETU6TCMtJJMJtMN1XC9ESIiouZjGGkDw28O1RxJ4CRWIiKi5mIYaQOje7rBTC7DudQiXM0ulbocIiKiToVhpA2421shvJc7AGDTyRSJqyEiIupcGEbayMyhXQEAP55JQ0W1WuJqiIiIOg+GkTZyb3dXdHG2RmmVGnvOZUpdDhERUafBMNJG5HIZ/jq0CwDgu5M3JK6GiIio82AYaUOPDfSFhZkM59KKcTGd96ohIiJqCoaRNuRiq8ADfb0AAN9xIisREVGTMIy0sZk3h2p2xaajtKpG4mqIiIg6PoaRNjY0wBnd3GxQUa3BztgMqcshIiLq8BhG2phMJtNd5vvdiRsQQkhcERERUcfGMNIOHhngC4W5HFeySnE2tUjqcoiIiDo0hpF24GBtgckh3gCA705wIisREdGdMIy0k5nDaiey7jmfgaKKaomrISIi6rgYRtpJfz9H9PKyh0qtxY9n0qUuh4iIqMNiGGkntRNZ/1yRlRNZiYiIGsYw0o6m9feBjaUZEnPLcTKpQOpyiIiIOiSGkXZkqzDHQ/18AHBFViIiosYwjLSzuqGaXy5mIq9MJXE1REREHQ/DSDvr6+OAUD9H1GgEtkanSV0OERFRh8MwYgB1vSPfn0qBVsuJrERERLdiGDGAKSHesLMyR0pBBY5ey5O6HCIiog6FYcQAlJZmeGSAL4Day3yJiIjoTwwjBvLXm0M1By/nIDmvXOJqiIiIOg6GEQMJ8rDD6J5u0GgFPv0tQepyiIiIOgyGEQNadH8QAGBnbDqu5ZRJXA0REVHHwDBiQCG+jgjv5QGtAHtHiIiIbmIYMbBX7u8BANh9PgPxWaUSV0NERCQ9hhED6+PtgIl9PSEE8MlvV6Uuh4iISHIMIxJYGB4EmQzYeyELcRnFUpdDREQkKYYRCfT0tMPkEG8AwMcHOXeEiIhMG8OIRF4e1wNyGXDgUjbOpxVJXQ4REZFkGEYk0t3dFtP6+QAAPjrAuSNERGS6GEYk9NK4HjCTy3A4PhcxNwqlLoeIiEgSDCMS8ne1wSMDantHPj7I3hEiIjJNDCMSWzC2B8zlMvyekIdTSQVSl0NERGRwzQojy5cvx+DBg2FnZwd3d3dMmzYN8fHxd91v69atCA4OhpWVFe655x7s3bu3xQUbGz9na/xlsB8A4MMDdz+XRERExqZZYSQqKgoRERE4ceIEDhw4gJqaGowfPx7l5Y3fhfaPP/7AE088gWeeeQZnz57FtGnTMG3aNFy8eLHVxRuL+WO6w9JMjhOJBfjjep7U5RARERmUTAghWrpzbm4u3N3dERUVhfvuu6/BNjNmzEB5eTn27Nmj2zZs2DD069cP69ata9JxSkpK4ODggOLiYtjb27e03A5tya6L+Ob4DQzq6oStL4RBJpNJXRIREVGrNPX7u1VzRoqLa1cPdXZ2brTN8ePHER4errdtwoQJOH78eKP7qFQqlJSU6D2M3bwx3aEwlyP6RiF+T2DvCBERmY4WhxGtVouFCxdixIgR6Nu3b6PtsrKy4OHhobfNw8MDWVlZje6zfPlyODg46B5+fn4tLbPT8LC3wqxhXQEAHxy4ilZ0WBEREXUqLQ4jERERuHjxIjZv3tyW9QAAFi9ejOLiYt0jNTW1zY/REb0wqhuUFmY4l1qEXbEZUpdDRERkEC0KI/Pnz8eePXtw+PBh+Pr63rGtp6cnsrOz9bZlZ2fD09Oz0X0UCgXs7e31HqbAzU6BeaO7AQCW7o5DbqlK4oqIiIjaX7PCiBAC8+fPx44dO3Do0CEEBATcdZ+wsDD89ttvetsOHDiAsLCw5lVqIl4Y3Q29vexRVFGDJT/xiiMiIjJ+zQojERER+N///odNmzbBzs4OWVlZyMrKQmVlpa7N7NmzsXjxYt3PL7/8Mn755Rd88MEHuHLlCpYuXYro6GjMnz+/7d6FEbEwk+O9x0JgLpdh74Us7L2QKXVJRERE7apZYWTt2rUoLi7G6NGj4eXlpXts2bJF1yYlJQWZmX9+gQ4fPhybNm3Cf//7X4SGhmLbtm3YuXPnHSe9mro+3g548eZwzZu7LqKgvFriioiIiNpPq9YZMRRTWGfkdiq1BlNWHcXV7DJM6+eNjx/vL3VJREREzWKQdUao/SjMzfDeo6GQy4CdsRk4eCn77jsRERF1QgwjHVionyOevS8QAPD6jgsorqiRuCIiIqK2xzDSwb0SHoRAVxvklKrw9s+XpC6HiIiozTGMdHBWFmZ499EQyGTA1pg0RMbnSF0SERFRm2IY6QQG+Ttj7nB/AMDr2y+gtIrDNUREZDwYRjqJf0zoiS7O1sgorsLyfVekLoeIiKjNMIx0EtaW5ljxyD0AgE0nU/DHNd7Zl4iIjAPDSCcyvJsrZg7tAgD4v+3nUa5SS1wRERFR6zGMdDKLH+wFH0clUgsqseGPZKnLISIiajWGkU7GVmGORfcHAagdrtFoO/wCukRERHfEMNIJTQrxgqO1BdKLKnH4Ci/1JSKizo1hpBOysjDDowN8AQDfnbwhcTVEREStwzDSSc0c1hUAEHk1F6kFFRJXQ0RE1HIMI51UgKsN7u3uCiGATadSpC6HiIioxRhGOrFZw2ov8/3hdCpUao3E1RAREbUMw0gnFt7LAx72CuSXV+OXi1lSl0NERNQiDCOdmLmZHI8Pru0d+e4Eh2qIiKhzYhjp5J4Y0gVmchlOJRcgPqtU6nKIiIiajWGkk/N0sEJ4L3cAvMyXiIg6J4YRIzDr5mW+28+k8341RETU6TCMGIER3Vzh72KNMpUau2IzpC6HiIioWRhGjIBcLsPMobW9I/87cQNC8H41RETUeTCMGIlHB/rC0lyOS5klOJtaJHU5RERETcYwYiScbCwxOcQLQG3vCBERUWfBMGJE6oZq9pzPRFFFtcTVEBERNQ3DiBEZ0MURvbzsUa3WYltMmtTlEBERNQnDiBGRyWS6+9V8dzIFWi0nshIRUcfHMGJkpvXzga3CHEl55fjjer7U5RAREd0Vw4iRsVGYY3p/HwCcyEpERJ0Dw4gRqluR9cDlbGQVV0lcDRER0Z0xjBihnp52GOzvBI1WYPXha1wEjYiIOjSGESP17MhAAMC3J25gxb4rDCRERNRhMYwYqfF9PLF0Sm8AwOdHErFs9yUGEiIi6pAYRozY3BEBeGf6PZDJgA1/JOP1HRd5uS8REXU4DCNG7q9Du+C9R0MhlwHfn0rBP7adh4aBhIiIOhCGERPw6EBffPx4f5jJZfjxTBoWbolFjUYrdVlEREQAGEZMxkOh3lj91wGwMJNh97kMLNh0FtVqBhIiIpIew4gJeaCvJz5/ciAszeX4JS4LL/wvBlU1GqnLIiIiE8cwYmLGBnvgqzmDYGUhx6ErOXh2YzQqqxlIiIhIOgwjJmhkDzdseGoIrC3N8HtCHv6+NVbqkoiIyIQxjJioYYEu+ObpIQCAfRezkFPCZeOJiEgaDCMmbLC/MwZ0cYQQwM8XMqUuh4iITBTDiImbEuoNAPjpXIbElRARkaliGDFxk0K8IJcBZ1OKkFpQIXU5RERkghhGTJy7nRWGBboAAHafZ+8IEREZHsMI4aGbQzW7z3HeCBERGR7DCOGBvp4wl8twObME13JKpS6HiIhMDMMIwdHaEvcFuQEAfmLvCBERGRjDCAH4c6hmz7kMCMG7+hIRkeEwjBAAILy3BxTmciTmlSMuo0TqcoiIyIQwjBAAwFZhjvBeHgCA3VxzhIiIDIhhhHSmhHoBqA0jWi2HaoiIyDAYRkhndE932CrMkVFchTMphVKXQ0REJoJhhHSsLMwwvk/tUA2XhyciIkNhGCE9dfeq2XshE2qNVuJqiIjIFDCMkJ57u7vCydoCeWXVOJ6YL3U5RERkAhhGSI+FmRwT7/lzIisREVF7YxiheuoWQPvlYhZUao3E1RARkbFjGKF6Bvs7w8NegZIqNY5czZO6HCIiMnLNDiNHjhzBlClT4O3tDZlMhp07d951n9WrV6NXr15QKpXo2bMnNm7c2JJayUDM5DJMDqm7ky+HaoiIqH01O4yUl5cjNDQUq1evblL7tWvXYvHixVi6dCni4uKwbNkyREREYPfu3c0ulgyn7qqaA5eyUVGtlrgaIiIyZubN3WHixImYOHFik9t/++23eP755zFjxgwAQGBgIE6fPo2VK1diypQpDe6jUqmgUql0P5eU8F4phhbq64AuztZIKajAb5dzdOGEiIiorbX7nBGVSgUrKyu9bUqlEqdOnUJNTU2D+yxfvhwODg66h5+fX3uXSbeRyWS65eG5ABoREbWndg8jEyZMwJdffomYmBgIIRAdHY0vv/wSNTU1yMtreHLk4sWLUVxcrHukpqa2d5nUgLrekKj4XBRXNhwciYiIWqvdw8gbb7yBiRMnYtiwYbCwsMDUqVMxZ86c2oPLGz68QqGAvb293oMML9jTHkEetqjWaLE/LkvqcoiIyEi1exhRKpX4+uuvUVFRgeTkZKSkpMDf3x92dnZwc3Nr78NTK03hVTVERNTODLbOiIWFBXx9fWFmZobNmzdj8uTJjfaMUMdRN1Rz7FoeTnB5eCIiagfNTgNlZWWIjY1FbGwsACApKQmxsbFISUkBUDvfY/bs2br2V69exf/+9z8kJCTg1KlTePzxx3Hx4kW88847bfMOqF35u9rg4f4+0ApgwfdnkVNSJXVJRERkZJodRqKjo9G/f3/0798fALBo0SL0798fb775JgAgMzNTF0wAQKPR4IMPPkBoaCjuv/9+VFVV4Y8//oC/v3/bvANqd29P74sgD1vklqow//uzvJsvERG1KZkQQkhdxN2UlJTAwcEBxcXFnMwqkeu5ZXho1VGUV2vw/KhALJ7YS+qSiIiog2vq9zcnbVCTdHOzxbuPhgIAPo9KxK+8uoaIiNoIwwg12aQQLzw1wh8A8Pet53Ajv1zagoiIyCgwjFCzLJ7YCwO6OKK0So0X/3cGVTUaqUsiIqJOjmGEmsXSXI7VMwfA2cYSlzJLsGRXnNQlERFRJ8cwQs3m5aDEp4/3h0wGbIlOxQ/RXK6fiIhajmGEWuTeHq5YFB4EAHhj50XEZRRLXBEREXVWDCPUYhFjumNMTzeo1FrM++4Mb6ZHREQtwjBCLSaXy/DRjH7wcVTiRn4FFm2JRVphhdRlERFRJ8NFz6jVzqcV4dG1x1F9c2XWIA9bjOnpjjHB7hjY1QkWZsy8RESmqKnf3wwj1CYOX8nB2sjriEkphEb750fKzsoc9/Vww5hgd4wKcoObnULCKomIyJAYRkgSxRU1iErIReSVHERezUVBebXe84O6OuGjGf3g52wtUYVERGQoDCMkOY1W4FxaEQ5fycGhKzmIyygBAIzv7YH/zh4kcXVERNTeGEaow4nLKMbkVUchBLD3pZHo7c3fJRGRMeON8qjD6ePtgMkh3gCAVYcSJK6GiIg6CoYRMqgFY7tDJgP2XcxCfFap1OUQEVEHwDBCBhXkYYcH+3oBAD5l7wgREYFhhCQwf2x3AMDeC5lIyGbvCBGRqWMYIYPr5WWPCX08IATw2eFrUpdDREQSYxghSSwY2wMAsPtcBq7nlklcDRERSYlhhCTR18cB4b08oBXA6kPsHSEiMmUMIySZl8bVzh3ZGZuO5LxyiashIiKpMIyQZEJ8HTGmp1tt7wjnjhARmSyGEZLUS+Nq545sP5uOlPwKiashIiIpMIyQpPp3ccJ9QW7QaAXWRLJ3hIjIFDGMkORevjl3ZFtMGtIK2TtCRGRqGEZIcgO7OmNEdxeotQJrIq9LXQ4RERkYwwh1CC+PCwIAbI1ORUZRpcTVEBGRITGMUIcwJMAZwwKdUaMRWBfF3hEiIlPCMEIdRt2VNZtPpSKruEriaoiIyFDMpS6AqE5YoAsG+zvhdHIhJn5yBMMCXRDWzQVhgS7o7m4LmUwmdYlERNQOZEIIIXURd1NSUgIHBwcUFxfD3t5e6nKoHZ1LLcLc9adQWFGjt93VVoFhgc66gBLoasNwQkTUwTX1+5thhDqcarUW59OKcPx6Po4n5iPmRiFUaq1eG3c7BRaM7Y4nw/ylKZKIiO6KYYSMhkqtQWxKEY4n5uP49XycTSlCtUYLmQzY+nwYBvk7S10iERE1gGGEjFZVjQaLt1/AjrPpCHSzwd6XRsLKwkzqsoiI6DZN/f7m1TTU6VhZmGHplD5ws1MgMbccqw4lSF0SERG1AsMIdUoO1hb499Q+AIB1UYm4mF4scUVERNRSDCPUaT3Q1wsP3uMJjVbgn9vOo0ajvftORETU4TCMUKe27KG+cLS2wKXMEvz3SKLU5RARUQswjFCn5manwJuTewMAPjmYgGs5pRJXREREzcUwQp3e9P4+GBXkhmqNFv/cdh4abYe/QIyIiG7BMEKdnkwmwzsP3wMbSzOcSSnCxuPJUpdERETNwDBCRsHHUYnXHuwFAHj3l3ikFlRIXBERETUVwwgZjZlDumBIgDMqby6K1gnW8yMiIjCMkBGRy2VY+UgIFOZyHL2Whx+iU6UuiYiImoBhhIxKgKsNFt0fBAB4++fLyC6pkrgiIiK6G3OpCyBqa8/cG4CfL2TifFox/vZNNMK6ucDZxhLONpZw0f2pgJONBWwV5pDJZFKXTERk0hhGyOiYm8nx7qMhmLLqKC6kF+PCHZaKtzSXI8THAZ/9dQA8HawMWCUREdXhXXvJaF3KKMHh+BwUllejoLwa+Tf/rP27ClU1fy4fH97LHV/MHsReEiKiNtTU72/2jJDR6u1tj97ejX/4K6s1uJRZjMf/ewIHL+fg5wuZmBzibcAKiYgI4ARWMmFKSzMM7OqMeaO7AwCW/hSHoopqiasiIjI9DCNk8uaN6Ybu7rbIK6vG2z9flrocIiKTwzBCJk9hboaVj4RAJgO2xaThaEKe1CUREZkUhhEiAAO7OmH2sK4AgMU7zqOyWiNxRUREpoNhhOimfzwQDG8HK6QWVOLDA/FSl0NEZDIYRohuslWY4+3pfQEAXx1Nwvm0ImkLIiIyEQwjRLcYG+yBh0K9oRXA//14ATUa7d13IiKiVmEYIbrNkim94WRtgcuZJfji90SpyyEiMnoMI0S3cbFV4I3JvQEAHx9MQGJumcQVEREZt2aHkSNHjmDKlCnw9vaGTCbDzp0777rPd999h9DQUFhbW8PLywtPP/008vPzW1IvkUFM7++DkT1cUa3WYvH2C9Bq737XhKoaXoFDRNQSzQ4j5eXlCA0NxerVq5vU/tixY5g9ezaeeeYZxMXFYevWrTh16hSeffbZZhdLZCgymQzvTL8HSgsznEwqwJboVACAEAK5pSr8cS0P3/yRjH/tvIC/fH4cA/59AMFv/IIXvo1BcWWNxNUTEXUuzb43zcSJEzFx4sQmtz9+/Dj8/f3x0ksvAQACAgLw/PPPY+XKlc09NJFB+Tlb49UJPfHvPZfwzs+Xsf1MGhJyylBU0XjY+CUuC1eySrB21kD08uJNHYmImqLd54yEhYUhNTUVe/fuhRAC2dnZ2LZtGx588MFG91GpVCgpKdF7EElh7nB/hPo5olSlxunkQhRV1EAmA/xdrBHeywPzRnfDRzNCsWfBvdj2Qhh8HJVIzq/A9DXHsONsmtTlExF1CjIhxN0HwxvbWSbDjh07MG3atDu227p1K55++mlUVVVBrVZjypQp+PHHH2FhYdFg+6VLl2LZsmX1tt/tFsRE7SGruArbz6bBx1GJ7u626OZmCysLswbbFpRX4+XNZ/H7zSXlZ4d1xb8m9YalOeeKE5HpKSkpgYODw12/v9s9jFy6dAnh4eF45ZVXMGHCBGRmZuIf//gHBg8ejK+++qrBfVQqFVQqld6b8fPzYxihTkGjFfjk4FV8eugaAKB/F0esmTkAXg5KiSsjIjKsDhNGnnzySVRVVWHr1q26bUePHsXIkSORkZEBLy+vux6nqW+GqCP57XI2XtkSi5IqNVxsLLHqif4Y3t1V6rKIiAymqd/f7d53XFFRAblc/zBmZrVd3K3IQUQd3rheHtizYCR6edkjv7was746ibWR1/m5JyK6TbPDSFlZGWJjYxEbGwsASEpKQmxsLFJSUgAAixcvxuzZs3Xtp0yZgu3bt2Pt2rVITEzEsWPH8NJLL2HIkCHw9vZum3dB1EF1cbHGjnnD8cgAX2gFsPKXK3h2YwwKy6ulLo2IqMNo9jBNZGQkxowZU2/7nDlzsGHDBsydOxfJycmIjIzUPbdq1SqsW7cOSUlJcHR0xNixY7Fy5Ur4+Pg06ZgcpqHOTgiB70+lYulPcajWaOFpb4WPZvRDWDcXqUsjImo3BpkzYigMI2QsLqYX46XNZ5GYWw6ZDJg3uhsWhgfBwoxX2xCR8ekwc0aI6E99fRywZ8G9mDHID0IAqw9fx18+P47Ugoomv0ZOaRW+/D0Ry/deRmkVV3slos6PPSNEEtlzPgOLt19AaZUadgpzvD29L6b2a3josqpGg18vZWP7mTQcuZqLulvlhPo5YuNTQ+Bg3fCaPUREUuIwDVEnkFpQgYVbYhFzoxAA8OhAXyx7qA9sFObQagVOJxdg+5l07L2QiVKVWrdfPz9HJOeXo6iiBr297PHtM0PgYquQ6m0QETWIYYSok1BrtPj00DV8digBWgEEuNrggb6e2HM+A6kFlbp2Po5KPDzAB9P7+yDQzRZXskow68uTyCurRg93W3z3t6Fwt7eS8J0QEeljGCHqZE4m5mPhllhkFlfpttkqzPHgPZ54eIAvhvg7Qy6X6e1zPbcMM784iaySKvi7WOO7Z4fBx5ErvRJRx8AwQtQJFVVU4+2fL6OwvBoP9fPG+N6eUFo2fB+cOin5FfjrlyeQVlgJH0clNj07FF1dbAxUMRFR4xhGiExIRlElZn15Eol55XC3U2DTs0PR3d1O6rKIyMTx0l4iE+LtqMTm54chyMMWOaUqzPj8BC5llEhdFhFRkzCMEBkJdzsrbH4uDH19au+F88QXJ3AutUjqsoiI7orDNERGpriyBnPXn8LZlCLYWJphRHdX+Dlbw89JWfunszV8nZSwtjSXulQiMnKcM0JkwspUavztm9M4kVjQaBtXW0v4OFmjq7M1ngzrisH+zgaskIhMAcMIkYmr0Wjxx/V8JOeVI7WgAqmFFUgrrERqQQVKqtR6bc3kMrw5uTdmh3WFTCZr5BWJiJqHYYSIGlVcWYPUgtpwsud8BvaczwQAzBjkh7em9YHC/M6XExMRNUVTv785aExkghyUFnDwcUBfHwdM6OOBEF8HrNh3BVuiU5GQU4p1swZyNVciMhheTUNk4mQyGZ67rxvWPzUE9lbmOJNShCmfHUVsB74Sp6pGg00nU5BW2PS7HRNRx8UwQkQAgFFBbtg1/150d7dFdokKf/n8OLbFpEldVj1CCLy69Rxe33EBC74/i04w0kxEd8EwQkQ6Aa422DFvOMJ7eaBarcWrW8/hrd2XoNZopS5NZ03kdd0cl7MpRTiV1PgVQ0TUOTCMEJEeOysL/PfJgXhpXA8AwNfHkjBn/SkUlldLXBlw8FI23v81HgDQ3d0WALAu6rqUJRFRG2AYIaJ65HIZFt0fhHWzBsDa0gzHruVjwsdHsPtchmTDIgnZpVi4JRZCAE8O64ovZw+CXAYcjs/FlSwufU/UmTGMEFGjHujrhe3zhiPA1QY5pSos+P4sZn99Com5ZQato7iiBs9ujEaZSo2hAc54c0pv+LvaYGJfLwDA51GJBq2HiNoWwwgR3VGwpz32vTwSr4QHwdJcjt8T8vDAx7/jw1/jUVWjaffjqzVazP/+DJLzK+DjqMSamQNgYVb7T9cLo7oBAH46l8Era4g6MYYRIrorKwszvBzeA78uvA/3BbmhWqPFp4euYfxHR3A4Pqddj7183xX8npAHpYUZvpg9CC62Ct1z9/g6YER3F2i0Al/+ntSudRBR+2EYIaIm83e1wTdPDcbamQPgaW+FlIIKPLX+NF78Xwwyiirb/HjbYtLw1dHakPHhX0LR27v+Co7P31fbO7LldGqHmGRLRM3HFViJqFlkMhkm3uOFkUFu+OTgVXx9LBn7LmYh6moupvX3gZlMBrVWixqNgFqjRY229k+1RqBGK2BtYYZhgc4YGeSGQFebRu+FczalEK/vuAAAeGlcD0y8x6vBdiN7uKKPtz3iMkqw8fgNvBzeo93eOxG1D96bhoha5UpWCf614yKibxQ2e18fRyVG9nDFyB5uGNHdBY7WlgCA7JIqTFl1FDmlKkzo44G1MwdCLm/8Bn4/ncvAS9+fhbONJY7931goLXlvHaKOgDfKIyKD0WoF9l7MxKWMEpibyWEhl9X+aSaDud7f5cgtU+FoQh5OJRegWv3nYmoyGRDi64j7erjiyNVcnEsrRk8PO/w4bzhsFXfuxFVrtBjzQSRSCyqx7KE+mDPcv53fMRE1BcMIEXVoldUanEouwO9Xc/F7Qh7is0v1nne0tsBPEfeii4t1k17v2+PJeGNXHHydlIh8dTTMzTgljkhqvGsvEXVoSkszjApyw6ggNwBAVnEVjl7Lw+8JubieW4Y3JvVuchABgMcG+eHjgwlIK6zEzxcyMbWfT3uVTkRtjD0jRGQ0Vv2WgA8OXEUvL3vsfeneRifHEpFhNPX7m/2YRGQ0ngzrCmtLM1zOLEHU1VypyyGiJmIYISKj4WhtiSeGdAHAG+gRdSYMI0RkVJ65NwDmchlOJBYgNrVI6nKIqAkYRojIqHg7KnWTV9dFNt47klNShQOXsvHhr/H49ngyajTaRtsSUfvi1TREZHSeHxWIH8+kYf+lLFzPLYOrrQIX0opxLq0I51KLcD6tGFklVXr7/HgmHaue6A8/56ZfwUNEbYNX0xCRUXpmw2n8diUHdlbmKK1S13teLgN6uNuhj7c9Dl7ORkmVGnYKc/zn4XvwUKi3BBUTGR+uM0JEJm3emG747UqOLoh0cbZGiK8DQn0dEerniD7e9rC5ubJrWmEFFm6ORfSNQrz0/VkcTcjF0of6wNqS/0QSGQJ7RojIaJ1KKkBFtRohvo5wtrG8Y1u1RotPf0vAqsPXIAQQ6GaDVU/0Rx9vBwNVS2R8uBw8EVELHL+ej1e2xCKrpAqWZnIsfjAYc4f7G2QBtZySKuw5n4nD8TkIcLXB3+/vCQdri3Y/LlF7YRghImqhwvJq/GPbeRy8nA0AGBvsjvceDYGLrQIAUKPRQqXWoqpGc/NR+3chgC4u1nBQNj1AFJZX45e4LPwUm4ETSfm49V9kNzsF3pl+D+7v7dGm74/IUBhGiIhaQQiBb0/cwNs/X0a1WguFuRzmchmq1FpotHf+Z9PT3gpBnnYIcrdFkIcdgjzt0MPdVjdHpUylxoFLWdh9LhNHruZCfcvrDejiiPDeHvgxJg3Xc8sBANP6eWPJlD5wustQE1FHwzBCRNQGLmeWYMH3Z3Etp6zB5xXmcijM5bCyMIMAkFuqavS1fJ2U8HFU4lxaEapq/lzXpLeXPaaEemNyiJfu0uKqGg0+PpiA/x65Dq0AXG0VeHtaHzzQ16tN3x9Re2IYISJqI2qNFsn55bAwqw0ddeHD0kwOuVx/LklJVQ0SsstwNbv0lkdZvZAS6GqDKaHemBLqhe7udo0eOza1CP/Yeg4JN8PQ5BAvLHuoj27IiKgjYxghIupACsurcTW7FDcKKtDbyx59vO2bPClWpdZg1W/XsDbqOjRaARcbS7w1tS8mhbCXhDo2hhEiIiNzIa0Y/9h2DleySgEAQ/ydEexlB18nJXydrOHnZA1fJyUcrS0McvXPrQrLq7F0dxycrC3x8rgenN9CABhGiIiMUrVai88OX8Oaw9f0Jr7eylZhfjOgKBHoZotxwe4Y5O8MM3n7BJTskio8+dVJXM2uHUpytLbAPyb0xOODu7TbMalzYBghIjJiibllOJlUgLTCCqQWVNb+WVjZ6ARaV1sFJvTxwMS+XhgW6Axzs7a5T2pyXjlmfXUSaYWV8LBXwFFpifjs2p6bEF8HvDW1L/r5ObbJsajzYRghIjJBVTUapBXWhpO0wkqcSSnEwUu1996p42htgfG9a4PJiO6usDRvWTC5nFmCJ786hbwyFfxdrPHtM0Ph5WCFjcdv4KMDV1GqUkMmA2YM8sM/Hwi+6yq4ZHwYRoiICEDt0M7xxHzsu5CJXy9lo6C8WvecnZU57u/lgVlhXTGgi1OTXzM6uQBPbTiN0io1ennZY+PTQ+Bm9+cVPjmlVVix7wq2n0kHADgoa4dunhjCoRtTwjBCRET1qDVanEouwL4LWdgfl4WcW4Z1hgU6Y97o7hjZw/WOE2Aj43Pwwv9iUFWjxaCuTvhq7uBGV509nVyAN3Ze1E267etjjwVje8DNTgFbhTlsFeawufknQ4rxYRghIqI70moFzqQUYsvpVOw4m66bENvXxx4vjuqOB/p61gsIu89lYNEPsajRCIzu6Ya1MwdCaWl2x+OoNVp8dzIF7/8ar7uLckOsLOSwVVjAVmEGTwcrzB3uj/G9Peut5dKZabUCWSVV8HZUSl2KQTCMEBFRk2UUVeKL3xOx+VQqKms0AGoXZnt+VCCm9/eFpbkc3528gX/tvAghahdf+/Av/Zo13ySvTIWPDlxFzI1ClKnUKFepUaZSo0bT+NdQby97LAzvgft7exj8cuW2JITAb5dz8MGBq7icWYIXRnXDaxODpS6r3TGMEBFRsxWUV2PDsSRs+CNZN+nV094Kw7u5YPvZ2vkfM4d2wVtT+7bZsIpKrUG5SoNylRqlVWqUV6sRFZ+L9ceSUF5dG4zu8XHAwvAeGBvsftdQUq3W4lRSAQ5dycGp5Hy421lhYFcnDOjihFA/B1hbmrdJ3U0hhMDRa3l4/9erOJdapPfcqif6Y0qot8FqkQLDCBERtViZSo1NJ2/gy9+T9OaVzB/THX8fH2SQXorC8mp88XsiNvyRjIqboSTU1wEL7w/C6CA3vRpySqsQeSUXh67k4Oi1PJSpGh4OMpPL0NvLHgO6OGJAVycM7OoEH0dlu7yfk4n5+ODAVZxKKgAAKC3MMHeEP6pqNFh/LBlKCzPsiBiOYE/j/V5jGCEiolZTqTXYfiYd28+kYUqoN2aH+Ru8hvwyFf77eyI2/nFDN4TUv4sjnh4RgGs5ZTgcn4PzacV6+7jaKjCmpxtGBrkhr1SFmJRCxCQXIqukqt7re9grMNjfGSO6u+Le7q66mxW2VGxqET74NR6/J+QBACzN5Zg1tCteHN0NbnYKaLQCc74+haPX8tDVxRo/zb+30QnAnR3DCBERGZW8MhU+j7qOjcdvQKXW1ns+xNcBY4PdMTbYHX29HRqc+JpRVImYG4WIuVGIMymFiMsogea2lWz9nJW4t7srhndzxfBuLne8KWG1WovskiqkFVYio6gS+y5m4eDlbACAuVyGGYP9MH9sd3g56E9YLSyvxuRVR5FeVIkxPd3w1ZzBRjVRtw7DCBERGaWc0iqsi0zEoSvZ6OVljzHB7hjd0w3udlbNfq3Kag1iU4twPDEff1zLQ2xqUb1l9oM97XQ9JhnFlUi/GTzSiyqRU6rC7d+ichnw8ABfvDyuxx17WS6mF+ORtX9Apdbi5XE98Mr9Qc2uvzGlVTX4NS4bu89noKiiBgO7OmFogDOGBDjD0dpwi88xjBARETVTmUqNU0n5OHYtH8eu5enWR7kTS3M5fByV8HFUItDNBnOG+6Obm22TjvdjTBr+vvUcAODL2YMQ3tujxbVX1WgQGZ+Ln86l47fLOQ32HgG14ao2mLhgSICz3mJ1bY1hhIiIqJXyylT443ptr0lhRTW8b4YOH0dl7d+dlHCxsWzVBNgluy7im+M3YKcwx675IxDYxCADABqtwInEfOyKTce+i1l667gEutlgaqgPurgocTq5ECcT83E9t7zeawS62WBogAv+MsgX/ZuxCm9TMIwQERF1AtVqLf76xQlE3yhED3db7IwYARtF45cfa7UCZ1MLsed8Jvacz9S7OaKnvRWmhHphaj8f9PG2rxeS8spUOJVUgFNJBTiRmI/47FLdMNPHM/phWn+fNn1v7RZGjhw5gvfeew8xMTHIzMzEjh07MG3atEbbz507F99880297b1790ZcXFyTjskwQkRExiyntAqTPz2KnFIVHrzHE6v/OkAvSNwaQPZdyNK7KshBaYEH7/HC1H7eGOLv3KyJsEUV1TidXIhTSfl45t5AeDo0f97NnTT1+7vZK7+Ul5cjNDQUTz/9NB5++OG7tv/kk0+wYsUK3c9qtRqhoaF47LHHmntoIiIio+RuZ4W1swbi8f8ex94LWfjvkUQ8OzIQZ1ML8fP5LOy9kKkXQGwV5gjv5Y7JId64L8itxXdedrS2xP29PXB/K+aqtIVWDdPIZLK79ozcbufOnXj44YeRlJSErl27Nmkf9owQEZEp+PbEDbyx8yLkstqA0lAAmRTijZE9XGFlced7AnUE7dYz0lpfffUVwsPD7xhEVCoVVKo/x8BKSkoMURoREZGkZg3tgvOpRdgak4askqpOGUBawqBhJCMjA/v27cOmTZvu2G758uVYtmyZgaoiIiLqGGQyGd6e3hd9fRzg7ag06gByq5YNMrXQN998A0dHx7sO6yxevBjFxcW6R2pqqmEKJCIikpjC3Axzhvvj/t4eJhFEAAP2jAgh8PXXX+PJJ5+EpeWdV39TKBRQKNpvERYiIiLqOAzWMxIVFYVr167hmWeeMdQhiYiIqBNods9IWVkZrl27pvs5KSkJsbGxcHZ2RpcuXbB48WKkp6dj48aNevt99dVXGDp0KPr27dv6qomIiMhoNDuMREdHY8yYMbqfFy1aBACYM2cONmzYgMzMTKSkpOjtU1xcjB9//BGffPJJK8slIiIiY8Pl4ImIiKhdNPX726BX0xARERHdjmGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpBhGiIiISFIMI0RERCQphhEiIiKSlMFulNcadeuylZSUSFwJERERNVXd9/bd1lftFGGktLQUAODn5ydxJURERNRcpaWlcHBwaPT5TrEcvFarRUZGBuzs7CCTydrsdUtKSuDn54fU1FQuM28APN+GxfNtWDzfhsXzbXgtOedCCJSWlsLb2xtyeeMzQzpFz4hcLoevr2+7vb69vT0/zAbE821YPN+GxfNtWDzfhtfcc36nHpE6nMBKREREkmIYISIiIkmZdBhRKBRYsmQJFAqF1KWYBJ5vw+L5Niyeb8Pi+Ta89jznnWICKxERERkvk+4ZISIiIukxjBAREZGkGEaIiIhIUgwjREREJCmGESIiIpKUSYeR1atXw9/fH1ZWVhg6dChOnToldUlG4ciRI5gyZQq8vb0hk8mwc+dOveeFEHjzzTfh5eUFpVKJ8PBwJCQkSFOsEVi+fDkGDx4MOzs7uLu7Y9q0aYiPj9drU1VVhYiICLi4uMDW1haPPPIIsrOzJaq4c1u7di1CQkJ0q1CGhYVh3759uud5rtvPihUrIJPJsHDhQt02nu+2tXTpUshkMr1HcHCw7vn2Ot8mG0a2bNmCRYsWYcmSJThz5gxCQ0MxYcIE5OTkSF1ap1deXo7Q0FCsXr26weffffddfPrpp1i3bh1OnjwJGxsbTJgwAVVVVQau1DhERUUhIiICJ06cwIEDB1BTU4Px48ejvLxc1+aVV17B7t27sXXrVkRFRSEjIwMPP/ywhFV3Xr6+vlixYgViYmIQHR2NsWPHYurUqYiLiwPAc91eTp8+jc8//xwhISF623m+216fPn2QmZmpexw9elT3XLudb2GihgwZIiIiInQ/azQa4e3tLZYvXy5hVcYHgNixY4fuZ61WKzw9PcV7772n21ZUVCQUCoX4/vvvJajQ+OTk5AgAIioqSghRe34tLCzE1q1bdW0uX74sAIjjx49LVaZRcXJyEl9++SXPdTspLS0VPXr0EAcOHBCjRo0SL7/8shCCn+32sGTJEhEaGtrgc+15vk2yZ6S6uhoxMTEIDw/XbZPL5QgPD8fx48clrMz4JSUlISsrS+/cOzg4YOjQoTz3baS4uBgA4OzsDACIiYlBTU2N3jkPDg5Gly5deM5bSaPRYPPmzSgvL0dYWBjPdTuJiIjApEmT9M4rwM92e0lISIC3tzcCAwMxc+ZMpKSkAGjf890p7trb1vLy8qDRaODh4aG33cPDA1euXJGoKtOQlZUFAA2e+7rnqOW0Wi0WLlyIESNGoG/fvgBqz7mlpSUcHR312vKct9yFCxcQFhaGqqoq2NraYseOHejduzdiY2N5rtvY5s2bcebMGZw+fbrec/xst72hQ4diw4YN6NmzJzIzM7Fs2TKMHDkSFy9ebNfzbZJhhMhYRURE4OLFi3pjvNT2evbsidjYWBQXF2Pbtm2YM2cOoqKipC7L6KSmpuLll1/GgQMHYGVlJXU5JmHixIm6v4eEhGDo0KHo2rUrfvjhByiVynY7rkkO07i6usLMzKzeDODs7Gx4enpKVJVpqDu/PPdtb/78+dizZw8OHz4MX19f3XZPT09UV1ejqKhIrz3PectZWlqie/fuGDhwIJYvX47Q0FB88sknPNdtLCYmBjk5ORgwYADMzc1hbm6OqKgofPrppzA3N4eHhwfPdztzdHREUFAQrl271q6fb5MMI5aWlhg4cCB+++033TatVovffvsNYWFhElZm/AICAuDp6al37ktKSnDy5Eme+xYSQmD+/PnYsWMHDh06hICAAL3nBw4cCAsLC71zHh8fj5SUFJ7zNqLVaqFSqXiu29i4ceNw4cIFxMbG6h6DBg3CzJkzdX/n+W5fZWVluH79Ory8vNr3892q6a+d2ObNm4VCoRAbNmwQly5dEs8995xwdHQUWVlZUpfW6ZWWloqzZ8+Ks2fPCgDiww8/FGfPnhU3btwQQgixYsUK4ejoKHbt2iXOnz8vpk6dKgICAkRlZaXElXdOL774onBwcBCRkZEiMzNT96ioqNC1eeGFF0SXLl3EoUOHRHR0tAgLCxNhYWESVt15vfbaayIqKkokJSWJ8+fPi9dee03IZDLx66+/CiF4rtvbrVfTCMHz3db+/ve/i8jISJGUlCSOHTsmwsPDhaurq8jJyRFCtN/5NtkwIoQQq1atEl26dBGWlpZiyJAh4sSJE1KXZBQOHz4sANR7zJkzRwhRe3nvG2+8ITw8PIRCoRDjxo0T8fHx0hbdiTV0rgGI9evX69pUVlaKefPmCScnJ2FtbS2mT58uMjMzpSu6E3v66adF165dhaWlpXBzcxPjxo3TBREheK7b2+1hhOe7bc2YMUN4eXkJS0tL4ePjI2bMmCGuXbume769zrdMCCFa17dCRERE1HImOWeEiIiIOg6GESIiIpIUwwgRERFJimGEiIiIJMUwQkRERJJiGCEiIiJJMYwQERGRpBhGiIiISFIMI0RERCQphhEiIiKSFMMIERERSer/Az9uTWZ25M+fAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.plot(np.arange(EPOCHS), cnn_network.training_losses, label=\"Training Loss\")\n",
    "plt.title(\"Epochs vs Training Loss\")\n",
    "plt.show()\n",
    "plt.plot(np.arange(EPOCHS), cnn_network.validation_losses, label=\"Validation Loss\")\n",
    "plt.title(\"Epochs vs Validation Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed483936",
   "metadata": {},
   "source": [
    "## Conclusions from Graphs and Accuracy (~ 75%)\n",
    "From above it seems the model is still underfitted and could be run for more epochs as the training and validation loss graphs' slopes still do not appear to have hit global minimum yet."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "023c81c1",
   "metadata": {},
   "source": [
    "## Save our model weights\n",
    "So we don't have to wait to use it next time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "433343b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(cnn_network.state_dict(), \"./cnn.pth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53a7c0cc",
   "metadata": {},
   "source": [
    "# That's It!!\n",
    "More Possible Steps\n",
    "- Optimizer Hyperparameters (epochs, batchsize, learning rate)\n",
    "- Change layer parameters (change kernel or size for conv layer)\n",
    "- Change Newtork Architecture (Add conv layers or linear layers)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}