Upload 10 files

.gitattributes

@@ -53,3 +53,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+fer2013/test.csv filter=lfs diff=lfs merge=lfs -text
+fer2013/train.csv filter=lfs diff=lfs merge=lfs -text
+fer2013/val.csv filter=lfs diff=lfs merge=lfs -text

fer/datasets/fer.py

@@ -0,0 +1,76 @@
+import csv
+import pathlib
+from typing import Any, Callable, Optional, Tuple
+
+import torch
+from PIL import Image
+
+from torchvision.datasets.utils import verify_str_arg, check_integrity
+from torchvision.datasets import VisionDataset
+
+
+class FERX(VisionDataset):
+    """`FER2013
+    <https://www.kaggle.com/c/challenges-in-representation-learning-facial-expression-recognition-challenge>`_ Dataset.
+
+    Args:
+        root (string): Root directory of dataset where directory
+            ``root/fer2013`` exists.
+        split (string, optional): The dataset split, supports ``"train"`` (default), or ``"test"``.
+        transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed
+            version. E.g, ``transforms.RandomCrop``
+        target_transform (callable, optional): A function/transform that takes in the target and transforms it.
+    """
+
+    _RESOURCES = {
+        "train": ("train.csv", "3f0dfb3d3fd99c811a1299cb947e3131"),
+        "test": ("test.csv", "b02c2298636a634e8c2faabbf3ea9a23"),
+        "val" : ("val.csv", "b02c2298636a634e8c2faabbf3ea9a23"),
+    }
+
+    def __init__(
+        self,
+        root: str,
+        split: str = "train",
+        transform: Optional[Callable] = None,
+        target_transform: Optional[Callable] = None,
+    ) -> None:
+        self._split = verify_str_arg(split, "split", self._RESOURCES.keys())
+        super().__init__(root, transform=transform, target_transform=target_transform)
+
+        base_folder = pathlib.Path(self.root) / "fer2013"
+        file_name, md5 = self._RESOURCES[self._split]
+        data_file = base_folder / file_name
+        #if not check_integrity(str(data_file), md5=md5):
+        #    raise RuntimeError(
+        #        f"{file_name} not found in {base_folder} or corrupted. "
+        #        f"You can download it from "
+        #        f"https://www.kaggle.com/c/challenges-in-representation-learning-facial-expression-recognition-challenge"
+        #    )
+
+        with open(data_file, "r", newline="") as file:
+            self._samples = [
+                (
+                    torch.tensor([int(idx) for idx in row["pixels"].split()], dtype=torch.uint8).reshape(48, 48),
+                    int(row["emotion"]) if "emotion" in row else None,
+                )
+                for row in csv.DictReader(file)
+            ]
+
+    def __len__(self) -> int:
+        return len(self._samples)
+
+    def __getitem__(self, idx: int) -> Tuple[Any, Any]:
+        image_tensor, target = self._samples[idx]
+        image = Image.fromarray(image_tensor.numpy())
+
+        if self.transform is not None:
+            image = self.transform(image)
+
+        if self.target_transform is not None:
+            target = self.target_transform(target)
+
+        return image, target
+
+    def extra_repr(self) -> str:
+        return f"split={self._split}"

fer/train/fer_torch_train-01.ipynb

@@ -0,0 +1,441 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "\n",
+    "import pandas as pd\n",
+    "import seaborn as sn\n",
+    "import torch\n",
+    "\n",
+    "import numpy as np\n",
+    "\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "\n",
+    "\n",
+    "from torch import nn\n",
+    "from torch.nn import functional as F\n",
+    "from torch.utils.data import DataLoader, random_split\n",
+    "from torchmetrics import Accuracy\n",
+    "from torchvision import transforms\n",
+    "\n",
+    "from pytorch_lightning import LightningModule, Trainer\n",
+    "from pytorch_lightning.callbacks.progress import TQDMProgressBar\n",
+    "from pytorch_lightning.loggers import CSVLogger\n",
+    "\n",
+    "import csv\n",
+    "import pathlib\n",
+    "from typing import Any, Callable, Optional, Tuple\n",
+    "\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "\n",
+    "from IPython.core.display import display\n",
+    "import matplotlib.pyplot as plt\n",
+    "import ipyplot\n",
+    "\n",
+    "from gauss.inductive.vision.fer.datasets.fer import FERX"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fer_root_dir = \"/Users/reeteshmukul/Library/CloudStorage/OneDrive-Personal/Datasets/FER/\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BATCH_SIZE = 128 if torch.cuda.is_available() else 64\n",
+    "\n",
+    "class LitFER(LightningModule):\n",
+    "    def __init__(self, learning_rate=2e-4):\n",
+    "\n",
+    "        super().__init__()\n",
+    "\n",
+    "        # Set our init args as class attributes\n",
+    "        self.learning_rate = learning_rate\n",
+    "        self.data_dir = fer_root_dir\n",
+    "\n",
+    "        # Hardcode some dataset specific attributes\n",
+    "        self.num_classes = 7\n",
+    "        self.dims = (1, 48, 48)\n",
+    "        channels, width, height = self.dims\n",
+    "\n",
+    "        self.transform = transforms.Compose(\n",
+    "            [\n",
+    "                transforms.ToTensor(),\n",
+    "                transforms.Normalize((0.1307,), (0.3081,)),\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "        hidden_size= 64\n",
+    "\n",
+    "        # Define PyTorch model\n",
+    "        self.model = nn.Sequential(\n",
+    "            #nn.Flatten(),\n",
+    "            nn.Conv2d(1, hidden_size, (3, 3), padding=\"same\"),\n",
+    "            nn.Dropout(0.5),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Conv2d(hidden_size, hidden_size, (3, 3), padding=\"same\"),\n",
+    "            nn.Dropout(0.5),            \n",
+    "            nn.ReLU(),\n",
+    "            nn.AvgPool2d((3, 3), padding=1, stride=2),\n",
+    "            nn.Flatten(),\n",
+    "            nn.Linear((24*24*hidden_size), hidden_size),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Dropout(0.1),\n",
+    "            nn.Linear(hidden_size, self.num_classes),\n",
+    "        )\n",
+    "\n",
+    "        self.val_accuracy = Accuracy()\n",
+    "        self.test_accuracy = Accuracy()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.model(x)\n",
+    "        return F.log_softmax(x, dim=1)\n",
+    "\n",
+    "    def training_step(self, batch, batch_idx):\n",
+    "        x, y = batch\n",
+    "        logits = self(x)\n",
+    "        loss = F.nll_loss(logits, y)\n",
+    "        return loss\n",
+    "\n",
+    "    def validation_step(self, batch, batch_idx):\n",
+    "        x, y = batch\n",
+    "        logits = self(x)\n",
+    "        loss = F.nll_loss(logits, y)\n",
+    "        preds = torch.argmax(logits, dim=1)\n",
+    "        self.val_accuracy.update(preds, y)\n",
+    "\n",
+    "        # Calling self.log will surface up scalars for you in TensorBoard\n",
+    "        self.log(\"val_loss\", loss, prog_bar=True)\n",
+    "        self.log(\"val_acc\", self.val_accuracy, prog_bar=True)\n",
+    "\n",
+    "    def test_step(self, batch, batch_idx):\n",
+    "        x, y = batch\n",
+    "        logits = self(x)\n",
+    "        loss = F.nll_loss(logits, y)\n",
+    "        preds = torch.argmax(logits, dim=1)\n",
+    "        self.test_accuracy.update(preds, y)\n",
+    "\n",
+    "        # Calling self.log will surface up scalars for you in TensorBoard\n",
+    "        self.log(\"test_loss\", loss, prog_bar=True)\n",
+    "        self.log(\"test_acc\", self.test_accuracy, prog_bar=True)\n",
+    "\n",
+    "    def configure_optimizers(self):\n",
+    "        optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n",
+    "        return optimizer\n",
+    "\n",
+    "    ####################\n",
+    "    # DATA RELATED HOOKS\n",
+    "    ####################\n",
+    "\n",
+    "    def prepare_data(self):\n",
+    "        # download\n",
+    "        #FER(fer_root_dir, train=True, download=True)\n",
+    "        #MNIST(fer_root_dir, train=False, download=True)\n",
+    "        pass\n",
+    "\n",
+    "    def setup(self, stage=None):\n",
+    "\n",
+    "        # Assign train/val datasets for use in dataloaders\n",
+    "        if stage == \"fit\" or stage is None:\n",
+    "            #fer_full = FER2013(self.data_dir, split=\"train\", transform=self.transform)\n",
+    "            #self.fer_train, self.fer_val = random_split(fer_full, [25000, 3709])\n",
+    "            self.fer_train = FERX(self.data_dir, split=\"train\", transform=self.transform)\n",
+    "            self.fer_val = FERX(self.data_dir, split=\"val\", transform=self.transform)\n",
+    "            \n",
+    "\n",
+    "        # Assign test dataset for use in dataloader(s)\n",
+    "        if stage == \"test\" or stage is None:\n",
+    "            self.fer_test = FERX(self.data_dir, split=\"test\", transform=self.transform)\n",
+    "\n",
+    "    def train_dataloader(self):\n",
+    "        return DataLoader(self.fer_train, batch_size=BATCH_SIZE, num_workers=4)\n",
+    "\n",
+    "    def val_dataloader(self):\n",
+    "        return DataLoader(self.fer_val, batch_size=BATCH_SIZE, num_workers=4)\n",
+    "\n",
+    "    def test_dataloader(self):\n",
+    "        return DataLoader(self.fer_test, batch_size=BATCH_SIZE, num_workers=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "GPU available: False, used: False\n",
+      "TPU available: False, using: 0 TPU cores\n",
+      "IPU available: False, using: 0 IPUs\n",
+      "HPU available: False, using: 0 HPUs\n",
+      "\n",
+      "  | Name          | Type       | Params\n",
+      "---------------------------------------------\n",
+      "0 | model         | Sequential | 2.4 M \n",
+      "1 | val_accuracy  | Accuracy   | 0     \n",
+      "2 | test_accuracy | Accuracy   | 0     \n",
+      "---------------------------------------------\n",
+      "2.4 M     Trainable params\n",
+      "0         Non-trainable params\n",
+      "2.4 M     Total params\n",
+      "9.590     Total estimated model params size (MB)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 99: 100%|██████████| 506/506 [8:12:31<00:00, 58.40s/it, loss=0.202, v_num=17, val_loss=2.420, val_acc=0.531]     \n"
+     ]
+    }
+   ],
+   "source": [
+    "model = LitFER()\n",
+    "trainer = Trainer(\n",
+    "    accelerator=\"auto\",\n",
+    "    devices=1 if torch.cuda.is_available() else None,  # limiting got iPython runs\n",
+    "    max_epochs=100,\n",
+    "    callbacks=[TQDMProgressBar(refresh_rate=20)],\n",
+    "    logger=CSVLogger(save_dir=\"logs/\"),\n",
+    ")\n",
+    "trainer.fit(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Testing DataLoader 0: 100%|██████████| 57/57 [00:14<00:00,  3.93it/s]\n",
+      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+      "       Test metric             DataLoader 0\n",
+      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n",
+      "        test_acc            0.5266090631484985\n",
+      "        test_loss            2.582343101501465\n",
+      "────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "[{'test_loss': 2.582343101501465, 'test_acc': 0.5266090631484985}]"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainer.test(model=model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/reeteshmukul/opt/anaconda3/lib/python3.9/site-packages/pytorch_lightning/callbacks/model_checkpoint.py:608: UserWarning: Checkpoint directory logs/lightning_logs/version_17/checkpoints exists and is not empty.\n",
+      "  rank_zero_warn(f\"Checkpoint directory {dirpath} exists and is not empty.\")\n",
+      "\n",
+      "  | Name          | Type       | Params\n",
+      "---------------------------------------------\n",
+      "0 | model         | Sequential | 2.4 M \n",
+      "1 | val_accuracy  | Accuracy   | 0     \n",
+      "2 | test_accuracy | Accuracy   | 0     \n",
+      "---------------------------------------------\n",
+      "2.4 M     Trainable params\n",
+      "0         Non-trainable params\n",
+      "2.4 M     Total params\n",
+      "9.590     Total estimated model params size (MB)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                                                           \r"
+     ]
+    }
+   ],
+   "source": [
+    "trainer.fit(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>val_loss</th>\n",
+       "      <th>val_acc</th>\n",
+       "      <th>test_loss</th>\n",
+       "      <th>test_acc</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>epoch</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.580610</td>\n",
+       "      <td>0.404291</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.467953</td>\n",
+       "      <td>0.439955</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.395855</td>\n",
+       "      <td>0.458345</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.362139</td>\n",
+       "      <td>0.471162</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1.336627</td>\n",
+       "      <td>0.486208</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       val_loss   val_acc  test_loss  test_acc\n",
+       "epoch                                         \n",
+       "0      1.580610  0.404291        NaN       NaN\n",
+       "1      1.467953  0.439955        NaN       NaN\n",
+       "2      1.395855  0.458345        NaN       NaN\n",
+       "3      1.362139  0.471162        NaN       NaN\n",
+       "4      1.336627  0.486208        NaN       NaN"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<seaborn.axisgrid.FacetGrid at 0x7fb6b8b04df0>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAasAAAFgCAYAAAAFPlYaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAA4u0lEQVR4nO3dd3xV9f3H8dcnm4QMNiFhbzDsKQ6coKDWrXVb9afWOmurba22tlWrtY466667FUcVtxTExd5DNiQECAlkEDLv9/fHuUKAACHm5p4k7+fjkQf3nnvOud8vyT3v+z3ne75fc84hIiLiZxHhLoCIiMjBKKxERMT3FFYiIuJ7CisREfE9hZWIiPheVLgLcKjGjx/vPvroo3AXQ0RkfyzcBWiMGlzLauvWreEugoiI1LMGF1YiItL0KKxERMT3FFYiIuJ7CisREfE9hZWIiPiewkpERHxPYSUiIr6nsBIREd9TWImIiO8prERExPcUViIi4nsKKxER8T2FlYiI+J7CSkREfE9hJSIivqewEhER31NYiYiI7ymsRETE9xRWIiLieworERHxvZCFlZl1NLMpZrbUzBab2Q3VrDPWzPLNbF7w5/ehKo+IyLPT13DzG/PCXQyphagQ7rsCuMU5N8fMEoHZZvapc27JXut96ZybGMJyiIiwIa+Y+z5aRllFgAtGdWZo5xbhLpIcgpC1rJxz2c65OcHHhcBSIC1U7yciciD3fLiUSDMS46J47qs14S6OHKJ6uWZlZl2AwcB31bw82szmm9mHZtZ/P9tfZWazzGxWTk5OKIsqIo3Qt6tzmbxwE9eM7c75Izrx0aJNZG3fGe5iySEIeViZWXPgLeBG51zBXi/PATo75wYCjwLvVLcP59zTzrlhzrlhbdq0CWl5RaRxqQw47n5/CR2S47jqqG5ccngXAF76ei0A+cXlvDFzPaUVleErpBxUKK9ZYWbReEH1inNu0t6vVw0v59xkM3vczFo757aGslwi0nRMWbaFxRsLePi8QcRFR5KW0ozx/dvz6oz19OuQxJ8+WEpOYSnllY4LR3UOd3FlP0LZG9CAZ4GlzrkH97NO++B6mNmIYHlyQ1UmEWl6Zq7LIzrSGH9Y+13LLj+iK4UlFdzw+jxaN48lLaUZkxdmh7GUcjChbFmNAS4CFprZvOCy3wCdAJxzTwJnAdeYWQWwEzjPOedCWCYRaWLmrd9Ov9QkYqMidy0b2rkFPzuiKy0TYrjqqG48+sVK/vHFCnIKS2mTGBvG0sr+hCysnHPTATvIOv8A/hGqMohI01YZcCzMyufsoen7vHbHxH67Hk8ckMojn6/go0XZXDS6Sz2WUGpKI1iISKO1cksRxWWVDOyYcsD1erVLpGfb5ry/QKcC/UphJSKN1vwN2wEOGlYAEwd0YMbaPDYXlIS2UFIrCisRabTmbthOUlwUXVslHHTdCQPa4xx8qI4WvqSwEpEGaUNeMXv3x5q3YTsz1+btej5/w3YGdkwhIuKAl88B6NE2kT7tE/lAYeVLCisRaXDW5e7g6Pun8K9v1+1aVl4Z4JqXZ/OzF2aSX1zOzrJKlm8uZGB6So33OyEjlaXZhRSUlIeg1PJjKKxExDfenZfFZ0s279Ni2tv0lVsJOHh62moqKgMAfLx4E9n5JRSUVPDE1FUs3phPZcDV6HrVDy4d04VZvzuepLjoH1MNCYGQjmAhIlJThSXl3PTGPAIO+qUmcf1xPRnXvx3BcQP28M2qXCIjjMxtO5m8aBOnDuzAc9PX0LlVPIM6pvD8V2uoDHghNrBjco3LkKiQ8i21rETEF2at3UbAwRVHdKWkvJKrX57NazM27LOec45vV+dxckYq3Von8PS0Vcxdv40567dz2eFduOWE3gSc45npa0hLaUbbxLgw1EbqmsJKRHzh29W5xERG8Mtxvfn05qMZ06MVf/5gCRvyivdYb1XODrYWlTKmeyuuOLIbi7IKuPU/C0iMjeKsYR3p1Cqen47ohHOH1qoSf1NYiUhIlJQf2ijm367OZVDHFOKiI4mMMO47cwAAv35rAYGA22M9gFHdWnHGkDRaN49h5ZYizhnekeax3pWN647tScuEGI7qqVkaGguFlYjUqfLKADe/OY8Bd33Cb99eSOa24oNuU1hSzqKNBYzs1nLXsvQW8fx2Qj++XpXLKzPW71r+zepc2ifF0blVPHHRkVw2pisxkRFcUmWYpDaJscz4zXGcN6JTndZNwkdhJSIAbC8u41/frN3Vu642dpZV8n//ms2kOVmM6t6Kf8/KZOz9/+OX/57P95sL97vdrHXbqAw4RnVrtcfy80d05Mierbln8lJW5xThnOO71bmM6tZyV8eLa47uzpe/PoZOreL32DYqUoe3xkS/TREB4I2ZG7jj3cU8NW11rbYvrajkome/Y8ryLfz59MN46fIRTP3VWC4c1ZkPFmRz4t+ncdnzM8jO33eG3m9X5xIdaQzp1GKP5WbG/WcNJCYqghten8fS7EK2FpXtEWoREUa7JHWiaOwUViICwIw13sgPD332Pcs27T2p98F9sngzs9Zt4/6zBnLBSG8Sw9TkZtx1an++vu1YbjmhF1+vyuXhz1bss+13q/MYmJ5Cs5jIfV5rnxzHX88cwMKsfK59ZTYAo7u32mc9adwUViJCIOCYuTaPE/u1I7lZNLe8OZ/yQzwd+M7cLFKT4zhjcNo+r7VIiOEXx/VkwoBUPliYvUfni6LSChZm5e9xvWpvJ/Zvz4WjOrE2t5jU5Dg6tYzf77rSOCmsRITlmwspKKlgXP/2/OknGSzeWMBjU1bud/3JC7O55c35u3rp5RaVMvX7HE4d1OGA4/CdMTidwpIKPl+6ZdeyWWvzqr1etbffTehHRloyJx2WWu2NwtK4KaxEZNfgryO6tmT8Ye05OaM9/5y2mp1l+3Y/rww4/jJ5KW/NyeQ/czIBeH9BNhUBxxmD953ksKrR3VvRLimWt+dm7lr21cqtREUYQzu3OMCWEBcdyXvXjeH3p/Q74HrSOCmsRITv1uSRmhxHeotmAFw0qgs7yir5ZMmmfdb9dMkmMrftpGVCDH/9aDmFJeVMmptF39QkerdPPOD7REYYpw1K43/Lc8gtKmVRVj4vfr2O4/q2JT7m4KO/qUXVdCmsRJo45xwz1+QxvMvu7uAju7YkLaUZb83J2mf9Z6evIb1FM565ZBhbi0r51X8WMH/Ddk4f3KFG73f64DQqAo7XZqzn2lfm0Kp5DPecMaBO6ySNj8JKpIlbl1vMlsJSRnTd3cEhIsI4fXAa01fk7DFz7oLM7cxcu41LD+/CkE4tOGtoOh8u2oQZnDZo344V1embmkSf9ok88Mn3ZG3fyaPnD6ZlQkyd10saF4WVSBM3o8r1qqrOGJJGwHnTdvzg2elraB4bxbnDOwLwq3G9SYiJ5IgerQ/pXqczh6Tv2n5Yl/33AhT5gaYIEWniZq7JIyU+mh5tmu+xvFub5gzulMJbs7O48shufLM6lw8WZHPx6C67ptJomxTHpGvHkNzs0KbWuGxMF/qnJTGqq+6XkppRWIk0cTPWeterqutyfsaQdO54ZxE//ed3fLM6l7SUZlxxZNc91jlYp4rqREVGcHj31rUuszQ9Og0o0oQtyspnXW4xI7tWfyrulAGpxEZFsDArn1vH9ebzW46mQ0qzei6liFpWIk2Wc44/f7CUFvHRnBO8BrW3lPgY3v/FEbRMiKFV89h6LqHIbgorkSZqyvItfLM6l7tO6UfSAaZz79nu0E/zidQ1nQYUacQ+WJDNhEe+ZFFW/h7LKyoD/GXyMrq2TuCnwUFnRfxMYSXSCOXvLOemN+bx81fnsHhjAc98uee0H2/OymTlliJ+Pb43MVE6DIj/6TSgSCOzo7SCMx7/irW5xdx4fE82F5Ty1pxM7iouIyU+hpLySh767HuGdm7BuP7tw11ckRrRVyqRRuZPHyxl9dYdPH/pcG48vhcXjepMWUWAScGhk17+dh1bCku5dVxvjbUnDYbCSsSHFmXlU1Zx6NPLf7ZkM6/NWM9VR3XjqF5tAOjXIYmB6cm8PnM9O0oreHLqKsb0aHXQKTlE/ERhJeIz328uZOKj03l62qpD2m5Tfgm3TVpA39Qkbj6h1x6vnT+iE99vLuKWN+eztaiMm0/oXZdFFgk5XbMS8Zm3gnNEvT5zA9eO7bHPyBKlFZXc+u8FbNhWTEqzaKIjI1i+uZB1ucXEREXw6pWDiI3ac3r4UwZ24O73l/DR4k2M7d3moHNHifiNWlYiPlIZcLwzN4uU+Ggyt+3k61W5+6zz2JRVvDd/IzGREWwtKmP11h30S03i1nG9eefaMfSq5r6ohNgoTg2Oir53q0ukIVDLSsRHvlq5lc0FpTx07iDu+u9iXp+5niN67h5Db2l2AY9PWcnpg9P4+7mDDmnfvxrXm5Mz2jMgPaVuCy1SD9SyEvGRSXMySYqL4qSM9pw+OI1PFm8mb0cZ4N3I++u3FpDcLJo7Jh761O4tEmI4smebui6ySL1QWIn4RFFpBR8t3sQpAzsQGxXJucM7UlYZ4O25WeTvLOfu95ewIDOfu07tr8kKpcnRaUCROra9uIxnp6/hiiO6kRy/e8y9kvJKYiIjqp2KA2DywmxKygOcOdSbmLBP+yQGdUzh8SkrefCT5ewoq+TcYR2ZOCC1Xuoh4idqWYnUsckLN/HoFyu55PkZFJVWADBjTR6j7/mcX7w2F+fcPttsyi/h6Wmr6do6gcEdU3Ytv2xMF7bvLOe4vu344PojuO+sAbqRV5oktaxE6tjCrO275oC6/IWZnDkkjTveWUxcdAQfLMzmyJmtOW9Ep13rz9uwnatemsWO0gqeuHDoHmF02qA0xh/Wfp+u6CJNjVpWInVsYVY+w7u05O/nDmLm2jx+/dZCBndKYeqtx3B491b84b9LWLN1ByXllTw9bRXnPPUNMVERvHXt4btGnahKQSWilpVInSopr2T5pkKuOLIbpw7sQKQZizbmc9PxvYiJiuBv5wxk/ENfcmWwJZWdX8IxvdvwwNkDNbmhyAEorETq0PJNhZRXOgakJQMwYUAqE6p0iEhNbsa9Z2RwzStzGNwphQfPGcTo7hqjT+RgFFYidWhBcJLDw4JhVZ2TMlKZ8ZvjaJMYq84SIjWksBKpQwszt9MiPpr0Fs0OuF7bpLh6KpFI46AOFiJ1aGFWARnpKWoxidQxhZVIDWzcvpPxD01jyrIt+12npLyS7zcX7rpeJSJ1R2ElUgN//WgZyzYVcud7i/c7KeKS7AIqA46MdIWVSF1TWIkcxNz123hn3kZGdWvJ+rxiXvluXbXrLcz0OldkqGUlUucUViIH4Jzjj+8voU1iLM9cMpzDu7fi0S9WUlBSvs+6C7Pyad08htRkdZ4QqWsKK5EDeG/+Ruau386t43rTPDaK20/qS96OMp6auueU8xWVAeZv2E5GWrI6V4iEgLqui1TDOccbMzdw9/tL6N8hibOGeCOhZ6Qnc+rADjzxv1V8tmQLfVIT2VlWyTercyksqeCUgR3CXHKRxklhJbKXbTvK+OW/5/P5si0c3r0VD5w9cI9pPf54Wn+6tIpn8cYCZq7JIzLSmJCRypgerTmxf7swllyk8VJYiezl4c9XMG1FDr+f2I9LD++yz/xTKfEx3Hxi7zCVTqRpUliJ7OWrlVsZ3b01lx/RNdxFEZGgkHWwMLOOZjbFzJaa2WIzu6GadczMHjGzlWa2wMyGhKo8IjWxpbCEFVuKOFyDy4r4SihbVhXALc65OWaWCMw2s0+dc0uqrHMS0DP4MxJ4IvivSFh8uzoPQGEl4jMha1k557Kdc3OCjwuBpUDaXqudBrzkPN8CKWaWikiYfLNqK4lxUfTvoBt7RfykXu6zMrMuwGDgu71eSgM2VHmeyb6BhpldZWazzGxWTk5OyMopTYtzjqenrWL2um27ln29KpdR3VoRGaF7pUT8JORhZWbNgbeAG51zBXu/XM0mbp8Fzj3tnBvmnBvWps2+036L1MYzX67hL5OXcf1rcykpryRzWzHrcot1ClDEh0LaG9DMovGC6hXn3KRqVskEOlZ5ng5sDGWZRAC+WZXLvR8tIyMtmYVZ+Tw7fQ1tE71p5Q/v3jrMpRORvYWyN6ABzwJLnXMP7me194CLg70CRwH5zrnsUJVJBCA7fyfXvTqHLq3iefXKkZzYrx2PT1nJe/M30iohhl7tmoe7iCKyl1CeBhwDXAQca2bzgj8nm9nVZnZ1cJ3JwGpgJfBP4NoQlkeauB2lFTw2ZSXjH/qSkvJKnrpoKIlx0dx+cl/KKgN8uWIro7u30th+Ij4UstOAzrnpVH9Nquo6Dvh5qMogjZNz7pADZVFWPpc8N4PcHWUc26ctt47rTY+2iQB0bZ3AxaO78Oz0NToFKOJTGsFCGpT8neVc/Ox39E1N4t4zB+zzem5RKdNXbqVDSjOGd2kJQGXAcdukBURGGJOuPZwhnVrss90Nx/ckKtKYMEB3Toj4kcJKGoyyigDXvDyb+Zn5zM/M59g+bTmxf3sAZq7N40/vL2FBVj7OQUxkBP/62QhGdmvFy9+uY1FWAf/46eBqgwogKS6a20/qW5/VEZFDoPmspEFwzvHbtxfy9apc7jszgz7tE/ndO4vI31nO3PXbuPS5GeQVl3HT8b147cpRpLdsxpUvzeLrlVt54OPlHNmzNRMy1GoSaajMu2zUcAwbNszNmjUr3MWQevbajPXcPmkh1x/Xk5tP6MXCzHxOe2w6R/dqw+x120iJj+HfV4+mXZI3S++GvGJOf/xrthaVEhMZwcc3HUXX1glhroU0EeqhEwJqWUmD8PnSzXRrncBNx/cEvEkQrzyqG1OW55AQG8UrV4zcFVQAHVvG8/ylw0luFs0Nx/dUUIk0cLpmJb7nnGPehnyO6tV6j16ANx3fi7ioSE4fnEbHlvH7bJeRnsys3x1PdKS+k4k0dAor8b2N+SVsLSplUMeUPZbHRUdy0wm9DritgkqkcdAnWXxv/obtAAxMTwlrOUQkfBRW4nvzM7cTExlBn9TEcBdFRMJEYSW+N3/Ddvp2SCI2KjLcRRGRMFFYia9VBhwLM/MZmK7JEEWaMoWV+NqqnCJ2lFXqepVIE6ewEl/b1blir56AItK0KKzE1+ZnbicxNopuuqlXpElTWImvzd+Qz4COyUREaAQbkaZMYSW+VVJeydLsAgboepVIk6cRLMSX8neWc//Hy6gIOHWuEBGFlfiLc46352bxl8lLyd1RxgUjO3F837bhLpaIhJnCSurFC1+toSLguOLIbvtdp6S8kjvfXcwbszYwpFMKL1w2gsPSdH+ViCispB6UlFdy/8fLKS6vZEB6CiO6ttxnnU35Jfzfy7OZv2E7vzi2Bzce34tIdaoQkSB1sJCQ+2LZFnaUVZIQE8Wv/jOfnWWVe7yeX1zOT//5LSs3F/LkhUO55cTeCioR2YPCSkLuvXkbad08lqcuGsra3GIe+GT5rtfKKwNc88psNmwr5vnLRjD+sPZhLKmI+JVOA0pIFZSU88XyLfx0RCfG9GjNxaM789xXa4iMMEZ0acmnSzbz9apcHjh7YLWnB0VEQGElIfbJ4s2UVQQ4ZWAHAH49vg9rc4t5/qs1PD1tNQDXju3OWUPTw1lMEfE5hZWE1HvzN5KW0owhnVIASIiN4qXLR1BSXsmCzHw2FZQwMSM1vIUUEd9TWEnI5BaV8tXKrVx5ZDfM9uwwERcdqdN+IlJjCiupU2u27uDUf0ynqLQCAwIOTg2eAhQRqS2FldSpBz/9nsqA47pjelAZcKQmx9FX09GLyI+ksJI6s2RjAf+dv5GfH9OdW07sHe7iiEgjovuspM48+OlykuKiuOrI7uEuiog0Mgor+VGKSitwzjFn/TY+W7qF/zu6O8nx0eEulog0MjoNKLVSXhnghtfnMnnhJmKjIoiKMFo3j+HSw7uEu2gi0ggprOSQVQYcN70xj8kLN3HJ6M7ERkeSU1jKhIxUEmL1JyUidU9HFjkkgYDjtrcW8P6CbG4/qQ//d7SuT4lI6OmalRySt+dm8e/ZmdxwXE8FlYjUG4WV1FhlwPHYlJX0S03ixuN7hrs4ItKEKKykxt5fsJHVW3dw/XE99hk+SUQklBRWUiOBgOMfX6ykd7tETuynOadEpH4prKRGPlq8iRVbivj5sT2I0Cy+IlLP1BtQ9isQcCzeWMDXq7by0jfr6NYmgQmazkNEwkBhJdWqDDiueHEmU5bnANCjbXP+eFp/ItWqEpEwUFhJte7/eDlTludwywm9OHd4R9omxYW7SCLShCmsZB/vL9jIk1NXccHITvziOHVRF5HwUwcL2cOKzYXc+u8FDO3cgjtP6R/u4oiIAAorqSIQcPzqrQU0i4nkiQuGEBOlPw8R8QcdjWSXV2asZ+767fxuQl9doxIRX1FYCQBbCkr464fLGNOjFacPTgt3cURE9tDow2rbjjLG/X0ab8xcH+6i+Nof/ruE0soAf/pJhoZSEmmCzKzoAK91MbNF9VmevTX6sEqJj2bj9p0szMoPd1F84aNFmzj7ya/ZUliya9k7c7P4YGE21x/bg66tE8JYOhGR6jX6rutmRt8OSSzZWBDuooSdc477P17GqpwdXPnSbN64ahQbt+/kN28vZESXllytKT9EQqLLbR88BAyq493OW3vvhBv396KZ3Qesc849Hnx+F+CAo4AWQDTwO+fcu4fypmYWBzwBDAMqgJudc1PMrD/wPBCD1xA6E9gIvAmkA5HA3c65Nw7l/X7Q6MMKoF9qEm/O2kBlwDXpERimr9zKqpwd/GRQB96dv5Gb3pjH2txiYqMiePj8QURFNvqGtkhT8jrwEPB48Pk5wHjg7865AjNrDXxrZu8559wh7PfnAM65DDPrA3xiZr2Aq4GHnXOvmFkMXjidDGx0zk0AMLPk2lamyYRVcVkl63J30K1N83AXJ2xe/HotrZvHcN9ZA+jfIZk/T14KwPOXDic1uVmYSyfSeB2oBRQqzrm5ZtbWzDoAbYBtQDbwdzM7CggAaUA7YNMh7PoI4NHgeywzs3VAL+Ab4Ldmlg5Mcs6tMLOFwAPBVt77zrkva1ufphFWHZIAWJJd0GTDan1uMZ8v28J1x/QgNiqSK47sSkl5JYlxURzTp224iyciofEf4CygPV5L6wK84BrqnCs3s7XAod6nUu3pKefcq2b2HTAB+NjMrnDOfWFmQ/FaWPeY2SfOuT/WpiJNIqx6tG1OVISxNLuAiQM6hLs4YfHSN2uJNOOCkZ0B71qehlISafReB/4JtAaOxjsVuCUYVMcAnWuxz2l4ofdF8PRfJ2C5mXUDVjvnHgk+HmBmy4A859zLwd6Gl9a2Ik0irOKiI+nRtnmT7WSxo7SCN2Zt4KSMVNon62ZfkabCObfYzBKBLOdctpm9AvzXzGYB84Bltdjt48CTwVN8FcClzrlSMzsXuNDMyvFOK/4RGA7cb2YBoBy4prZ1OWhYmdl1wCvOuW2HsmMzew6YiJfih1Xz+ljgXWBNcNGk2jYPa6JfahJfrdoaqt372gcLsiksqeDi0bX5EiUiDZlzLqPK463A6P2st99rJM65tcBhwcclVNNCcs7dA9yz1+KPgz8/Wk26f7UHZprZm2Y23mp+x+gLeD1PDuRL59yg4E/Iggq861abC0rZWlQayrfxpTdmbaBbmwSGdW4R7qKIiNTKQcPKOfc7oCfwLF6arjCzv5jZAW/Kcc5NA/LqopB1oV+q18liaXbTOhW4ckshs9dt49xhHTUyhYgckJllmNm8vX6+C3e5oIYjWAT74G8K/lTg3VD2HzP76498/9FmNt/MPgzeUFYtM7vKzGaZ2aycnJxavVHfYFg1tetWb87KJCrCOGNIeriLIiI+55xbWOVs1w8/I8NdLqhBWJnZ9WY2G/gr8BWQ4Zy7BhgKnGlmKbV87zlAZ+fcQLw+++/sb0Xn3NPOuWHOuWFt2rSp1Zu1SIghNTmu0besdpRWsCGvGIDyygCT5mRybJ+2tEmMDXPJRERqrya9AVsDZzjn1lVd6JwLmNkpwBfAkEN9Y+dcQZXHk83scTNrHbwAGBL9UpNY0sjD6vZJC/nvgo1cNKozGWnJbC0q49zhHcNdLBGRH+WgYeWc+/0BXltyCB0u9mBm7YHNzjlnZiPwWnm5tdlXTfXrkMT/vs+hpLySuOjIUL5VWGwuKGHywmx6tGnOy9+uI+CgbWIsR/eqXWtURMQv6uI+q2rHlDKz14CxQGszywTuxBs4Eefck3h3VV9jZhXATuC8Qxyf6pAdlpZMZcAxf8N2RnZrFcq3CovXZqynIuB45pJhFJZU8NePlzOufzuN+SciDV7Ibgp2zp1/kNf/AfwjVO9fndHdWxEVYUxZntPowqq8MsCr363n6F5t6NzKm+bjpctHhLlUItJQmFnRge61Cre6+MrdYPpDJ8VFM7xLS/63fEu4i1LnPlm8mS2FpbrxV0QapbpoWR1XB/uoN8f0acNfJi8ja/tO0lIaz0jjL32zlvQWzRjbW4PSivjSXcn/q355/tjg6w9R/ZxXN3JX/jzuSr6UqiNH/LDdftTlfFZm1hxvxKF9tjOzi4FfBve9wDl3kZm1A54EugV3cY1z7uuDvc+B/OiWlXPONzf+1sSxwRHGpyxrPK2rr1Zu5bs1eVw4qnOTnq9LRPbwOnBulefn4E2OeLpzbghwDPC3GnaSK6luu+D9sb8Fjg3ehnRDcP1HgKnBZUOAxT+2MhbiPg11btiwYW7WrFm13t45x1H3T6FX20SevXR4HZYsPCbNyeTXby2gU8t4Jl0zhuT46HAXSaSp8803RjNbinf2qw3eALRjgb/jta4CQG+gq3Nu04GuWZlZdHXbAWcD7Z1zv91r/Rwg3TlXZ+PbNYlR16syM47p3ZY3Z21o0F3YyyoCPPz59zw2ZRWju7XiyQuHKqhEZG91NZ/V/rYz9tMjvK41yT7Nx/RpS0l5gG9Xh/S2rpBwzvHpks2c+PepPDZlFWcPTefFy0coqESkOq8D5+EF1n+AZGo3n9X+tvscOMfMWgGYWcsqy68JLos0s6QfW5EmGVaju7UiLjqiQV63uvv9pVz50iyiIiN48fIR3H/2QGKimuSvUUQOwjm3GNg1nxXwCjAsOJ/VBdR8Pqtqtwvu/8/AVDObDzwYXP8G4JjgnFezgf2O/VpTTe6a1Q+ueHEm8zPzmfLLsTSPbRhnQ9fl7uDYv03ljMFp/OWMDKJ1s6+IH/nmmlVj0mSPdtce04OtRaU8+Mn34S5KjT02ZSVREcat43orqESkSWmyR7whnVpwwchOvPD1GhZm5oe7OAe1Ia+YSXOyOH9EJ9omaWp6Eal7DX4+q8bq1nF9aNU8ltvfXkBFZSDcxTmgx6asJCLCuGbsAee8FBGpNT/PZ9UwLtaESHKzaO48pR/XvTqXZ6av4eqj/RMEXyzbzG8mLSI+NpJ+qUl8tGgTF4zsRDu1qkSkCWrSLSuACRmpjO/fnr9+tIyp39duFuK6FAg4Hv18BT97cRYp8dH0aNOcueu3kxAbxdVqVYlIE9VkewNWtaO0gjOf+Jqs7Tt55+dj6N4mPAMPVwYcN70xj/fmb+T0wWncc0bGrpuWnXPUcuowEalf+qCGQJNvWQEkxEbxzCXDiImM4MoXZ7GloKTey+Cc4453F/He/I3cOq43D54zcI/RNRRUItKUKayC0lvE8+RFQ9mYv5OTH/my3k8J/v3T73n1u/VcO7Y7Pz+mh8JJRH4UM0sxs2true2NZhZ/kHXWmlnr2pXu0CmsqhjepSX/ve4IWiXEcslzM7j3w2Uh7SW4bFMBz3y5mkuem8EjX6zkvOEduXVc75C9n4g0KSlArcIKuBE4YFjVN4XVXnq2S+Td68Zw/ohOPDl1FZc+P5NtO8rqbP/OOaZ9n8M5T33D+Ie+5E8fLGVDXjHXjO3On35ymFpUIo1UxosZ/8t4MePSunx8EPcC3YP3St1vZrea2UwzW2BmfwAwswQz+8DM5pvZIjM718yuBzoAU8xsSk3qZmY3B7dfZGY37m/fweX3mtmSYDkeqMn+oYl3Xd+fuOhI7jkjg0Edk7njncWc+th0bjmhN20SY0mJjyYpLprmsVEkxkURVcORJDbll/D+go1MmpPFkuwC2ifFccfEfpyc0Z7U5MYzCaSI+MZtwGHOuUFmdiLeYLYj8DqAvGdmR+GNpL7ROTcBwMySnXP5ZnYzcIxzbuvB3sTMhgKXASOD+/7OzKbiTby4x76DA92eDvRxzjkzS6lpZdQb8CDmrN/G1f+azZbCfadliYuO4KTDUjl7WDpDO7egpCzAjrIKsvN3sj6vmDVbi1m1pYgVWwpZsaUI5yAjLZmfjuzEGUPSiI1qmNOTiMgB+eL0iJl1Ad53zh0WbMGcBWwPvtwcuAf4EvgYeDO47pfBbdcCww4UVj+sgzewbSvn3O+Dy+8GcoCP9t63mUXhDWw7C/gguLxGp67UsjqIIZ1aMPXWY9iwrZi8HWVs21FGYWkFO0orWLGliP/O38jbc7Oq3dYMOreMp0fbRCYO6MDEAal0C1O3eBFp0gy4xzn31D4veC2jk4F7zOwT59wfa7HvfTjnvq9u32Y2Am9CyPOA64Bja/ImCqsaaBYTSa92idW+9vuJ/fh48SY25BXTLCaK+JhI2ifF0alVPGkpzRrs5I4i0uAV4k0PAl4L524ze8U5V2RmaUA5XgbkOedeNrMi4NK9tj3oaUBgGvCCmd2LF1ynAxeZWYe9921mzYF459xkM/sWWFnTyiisfqS46EhOG5QW7mKIiOzBOZdrZl+Z2SLgQ+BV4JtgJ64i4EKgB3C/mQXwwuua4OZPAx+aWbZz7piDvM8cM3sBmBFc9Ixzbq6Zjatm34nAu2b2wyzDN9W0PrpmJSJSt3xxzaqxUdd1ERHxPZ0GFBGR/QrOZxW71+KLnHML67McCisREdkvv8xnpdOAIiLieworERHxPYWViIj4nsJKRKQRCvUUIfVNYSUi0jil0IimCFFvQBGRxmnXFCHAp8AW4By8buhvO+fuNLMEvIFm04FI4G6gHbunCNm6vxEszOwJYDjQDPiPc+7O4PLhwMNAAlCKNw5gMXAfMA5wwD+dc48eSmUUViIi9WBpn77/22vRC32XLX1haZ++twHjgY/6Llt679I+fS9l9xh9APRdtnTs0j592wOvBxed13fZ0k0HectQTxHyW+dcnplFAp+b2QBgGfAGcK5zbqaZJQE7gauArsBg51xFcKqQQ6KwEhFp/E4M/swNPm8O9MSbIuQBM7uPKlOE1NA5ZnYVXo6kAv3wWk3ZzrmZAM65AgAzOx540jlXEVyed6gV0NiAIiJ1yxdjA+41n9XfgO/3M0VIS7xpPK4GfpjGYy0HmM/KzLrinVoc7pzbFhzI9n/AHOBx59wRe60/Kbj8s9rWRx0sREQap72nCLk8OEUHZpZmZm2D03gUO+deBh4AhlSzbXWSgB1Avpm1A04KLl8GdAhet8LMEoMTLn4CXB18jE4DiogIENopQpxz881sLrAYWA18FVxeZmbnAo+aWTO861XHA88AvYAFZlYO/BP4x6HUR6cBRUTqli9OAzY2Og0oIiK+p9OAIiKyX5oiREREfE9ThIiIiNSQwkpERHxPYSUiIr6nsBIREd9TWImIiO8prERExPcUViIi4nsKKxER8T2FlYiI+J7CSkREfE9hJSIivqewEhER31NYiYiI74UsrMzsOTPbEpylsrrXzcweMbOVZrbAzIZUt56IiEgoW1YvAOMP8PpJQM/gz1XAEyEsi4iINGAhCyvn3DQg7wCrnAa85DzfAilmlhqq8oiISMMVzmtWacCGKs8zg8v2YWZXmdksM5uVk5NTL4UTERH/CGdYWTXLXHUrOueeds4Nc84Na9OmTYiLJSIifhPOsMoEOlZ5ng5sDFNZRETEx8IZVu8BFwd7BY4C8p1z2WEsj4iI+FRUqHZsZq8BY4HWZpYJ3AlEAzjnngQmAycDK4Fi4LJQlUVERBq2kIWVc+78g7zugJ+H6v1FRKTx0AgWIiLieworERHxPYWViIj4nsJKRER8T2ElIiK+p7ASERHfU1iJiIjvKaxERMT3FFYiIuJ7CisREfE9hZWIiPiewkpERHxPYSUiIr6nsBIREd9TWImIiO8prERExPcUViIi4nsKKxER8T2FlYiI+J7CSkREfE9hJSIivqewEhER31NYiYiI7ymsRETE9xRWIiLieworERHxPYWViIj4nsJKRER8T2ElIiK+p7ASERHfU1iJiIjvKaxERMT3FFYiIuJ7CisREfE9hZWIiPiewkpERHxPYSUiIr6nsBIREd9TWImIiO8prERExPcUViIi4nsKKxER8T2FlYiI+J7CSkREfE9hJSIivqewEhER31NYiYiI7ymsRETE9xRWIiLieworERHxPYWViIj4nsJKRER8T2ElIiK+FxXuAohIGKz/DgqzISISIqIgMhoiY6Btf0hoVffvV1kBWxZDiy4Qlww7t0F5CZhBoMJ7XLIdEtpAi84H319RDix8E5q1gLZ9oXVviInf8/3WfwPN20LrXt77SIOmsPKj0iLI3wD5Wd4HuLTQO6j0HAeJ7XavV1EK29fDtrVQnAddj4KkVO+1ynLYMAMqdkJCW0hKC81BaH8CAcieB5sXQUwCxCRCzxP2PGgUboKt30OrHpCYWvcHlJ3bIXMm7NgK5cXQaTS06wdlOyA/E4q2wI4tEJsMrbpDSifv/7koBzZ8C6mDIDndK5dzUFYEsYn7vk9pEXz9CMSlwOhrIXcVvDAR2vWHDoO8g2VsIjRvB2lDvP+b2c/DzjzYkeu9Z99TIH0ERETAtnXw4a+8AElMhfhW3u86Oh6OvtV7z8oKr1w7t3t/I9HxENscYpp7y5d/BBUlXjg0S4HvP4Zl78NP34ToZvDVw7D8g33rct6r0GeCt/7GuTD0st1/c9vW7Q4S57z3Kc7zfs8530PuSjjhj15ofPMYrJ7q/Z+VFkDuaijfAee8BP1Og1nPw+d/2Pf9j/wlHHeHt9+SfMhZDis+gYIs6DAEMs7yflevnQdZs3ZvFxENnQ+HUx+B5E7wxGjvbwu8AGzbD3bkwDVfe+We/zr0ON77P178Niz9L3QcCUf/6pD/zKR+hDSszGw88DAQCTzjnLt3r9fHAu8Ca4KLJjnn/hjKMtWbynLv22N8a+8AVFkOFuk9XvOl9wHuerT3gVo73TswnHi3d3D85HfewWxvE/4Gw6+AOS/Bd09DzlLvW+kPxt3jHSy/fQKm3AOl+XtuP/HvMOzyg5d95zbvgApe2O3c7h3gO40MLiuFqNjqty0vgQ9u9g4wO3J2L4+Kg99t9h5/eics+wByV+x+vVlLuH6ud2B951rvIJXQ2vtm3PVo6HGc9y0avDAo3+kdxONbei2CqkE3/w349jHIXgC43ctPut8Lq+Ufwls/27fsI6+Gk+7zQuSNC71lCW29g29BNqQOhCs+9Q7UL53mBUNcMqz6HIo2w5CLg3WN9b44bFrgveaC/5fpw+GKz7yyfnQbVJZ5IV5ZBt/8A1p0hetmeqFWsNFbvnqa93u0SGjZ1Qsr5+CRwd4Xmqr1A7htvVemGU97711VuwzvC1DrHjD+L3DsbyFQ6f0NVZZDZal3UAfYtBD+dy9MewD6neoF1cY5cMMCSOkIr18A2fOhIHP3/mOTYNQ1XpgU50HRJq9+SeneF4X0EdDpcG/dHsdDXBJYhFe3qDjvd9+6p/f6Vw/DVw95j6MTIDnNC9C0od7+x9+7e/stS7wvJaunesEUEQEjrvIelxbC2i9hy1Jon+H9HZcWwLvXee8ZKPdCvVUP73cmvmXOuYOvVZsdm0UC3wMnAJnATOB859ySKuuMBX7pnJtY0/0OGzbMzZo16+Ar1oeKUu+AuOE7yFsNR93qtWw+/q0XGK7S+0C07OZ9uz/jKeh+rHcgXPrfPfeV0tn71tlhkNci2r7eC65mLbyDYkk+JHXwPtBz/uV9G0wdCG16e9+eo+O99eNbwpL3vA927/HeB7Zos/dhPvx67+AfqIStK7yDTaDc2651L2//mxfDE4fvW9fEDnDLUu/xo0O9VkSvcd7BJXeld1A4Ifg947mTvH31GucdoCvLvJZNh8HegfaZ471ydjnSC4/c1d7/30nB7zJT7vH+T4tzvQPyzm3eAe2Kz7yWyZsXw5J39yyfRcKFb0H3Y2D2i7DgTeh6JHQe4x3oouO9MkfHwdaVXmsgoY33U7LdC8CYeDjsTK/VsnGut07WbK/8ianQaZTXAiotglfP2d2qadkNjrsTOg7f9/+trNhrxZUVeqfbUgd6yws3eb/bqFjv/275h14Lubpv9pUVEFnle2VlOUy733sc38oLp/Jibz+jr9vdOizM9vZZtBm6HOGdLjsUuau80Jv7stcyH3opDL7Ae78v/gR5a7wA6DDIC7mENnXXOs5b7X1G2md4v8OoWO8zEBW3/y9Kh2LLMpj+oBewg873Wm1117LXOccQCGVYjQbucs6NCz6/HcA5d0+VdcbSEMJq21pY8anXqjGDf50B6772vpEGyr11mrWEi9+F1AFeWGxa4H14t6/3PniR0TDmRu9gW1nufdtb940XNl2OgMT29VOX4jx4bMSerR7wvvX+0GqY8c/dy6NivIN8YurultWXD3qnlLLmsOubfVI6/N9UrzX0wymiuhAIeIGx4mM46ldeeTYtgrxV3heAnXne/2eg0mt9da4maOXH+eEYoes+NaX/qBAIZVidBYx3zl0RfH4RMNI5d12VdcYCb+G1vDbiBdfiA+23XsOqstw7FTH1r96361/M8U5BzH7Ra01ERHnhkz5iz2tJfrZ5CSx4wwvJ1EHe9Yv8TO/bd/8zvFMoNVWUA4UboWV373qJiIDCKiRCec2qul/Y3sk4B+jsnCsys5OBd4Ce++zI7CrgKoBOnTrVcTGrsWkRLJ/snWravAj6/QRO+IN3ug1g6CWhL0OotOvn1aWqll1rt6/mbbwfEZEQC+V9VplAxyrP0/FaT7s45wqcc0XBx5OBaDNrvfeOnHNPO+eGOeeGtWkTooNj9nzv1B54ATXlz961knNfgXNe3B1UIiJS70LZspoJ9DSzrkAWcB7w06ormFl7YLNzzpnZCLzwzA1hmfZVWeH1HPv8bu9i7pVfQMbZcNhZe17UFhGRsAnZ0dg5V2Fm1wEf43Vdf845t9jMrg6+/iRwFnCNmVUAO4HzXKguolVn/bfwwS1eS6rPRDj1Ue8iskXWWxFEROTgQtbBIlTqrIPFlL/A1Pu8Lrkn3eeFlXo7iciPpwNJCDTd81xdj/Lu2zj2DvVkExHxuaY1kO3Obd4Np4GAd2/TSfcpqEREGoCmFVaf/h6+fMAbpkhERBqMphNWWbO9YYpGXu0NMCoiIg1G0wirQAAm3+qNi3f0r8NdGhEROURNo4PF/Fe9ltXpT3kjNYuISIPSNFpW677x5qoZcG64SyIiIrXQNFpWP3nMmz5B91GJiDRITaNlBdXP8CoiIg1C0wkrERFpsBRWIiLieworERHxPYWViIj4nsJKRER8T2ElIiK+p7ASERHfU1iJiIjvKaxERMT3FFYiIuJ7CisREfE9hZWIiPieOefCXYZDYmY5wLpabNoa2FrHxfED1athUb0altrUa6tzbnwoCtOUNbiwqi0zm+WcGxbuctQ11athUb0alsZar4ZIpwFFRMT3FFYiIuJ7TSmsng53AUJE9WpYVK+GpbHWq8FpMtesRESk4WpKLSsREWmgFFYiIuJ7jT6szGy8mS03s5Vmdlu4y1NbZtbRzKaY2VIzW2xmNwSXtzSzT81sRfDfFuEua22YWaSZzTWz94PPG3y9zCzFzP5jZsuCv7fRjaReNwX/BheZ2WtmFtdQ62Vmz5nZFjNbVGXZfutiZrcHjyXLzWxceErdNDXqsDKzSOAx4CSgH3C+mfULb6lqrQK4xTnXFxgF/DxYl9uAz51zPYHPg88bohuApVWeN4Z6PQx85JzrAwzEq1+DrpeZpQHXA8Occ4cBkcB5NNx6vQDsfQNvtXUJft7OA/oHt3k8eIyRetCowwoYAax0zq12zpUBrwOnhblMteKcy3bOzQk+LsQ78KXh1efF4GovAj8JSwF/BDNLByYAz1RZ3KDrZWZJwFHAswDOuTLn3HYaeL2CooBmZhYFxAMbaaD1cs5NA/L2Wry/upwGvO6cK3XOrQFW4h1jpB409rBKAzZUeZ4ZXNagmVkXYDDwHdDOOZcNXqABbcNYtNp6CPgVEKiyrKHXqxuQAzwfPL35jJkl0MDr5ZzLAh4A1gPZQL5z7hMaeL32sr+6NMrjSUPR2MPKqlnWoPvqm1lz4C3gRudcQbjL82OZ2URgi3NudrjLUseigCHAE865wcAOGs6psf0KXr85DegKdAASzOzC8Jaq3jS640lD0tjDKhPoWOV5Ot4piwbJzKLxguoV59yk4OLNZpYafD0V2BKu8tXSGOBUM1uLd5r2WDN7mYZfr0wg0zn3XfD5f/DCq6HX63hgjXMuxzlXDkwCDqfh16uq/dWlUR1PGprGHlYzgZ5m1tXMYvAujr4X5jLVipkZ3vWPpc65B6u89B5wSfDxJcC79V22H8M5d7tzLt051wXv9/OFc+5CGn69NgEbzKx3cNFxwBIaeL3wTv+NMrP44N/kcXjXTxt6varaX13eA84zs1gz6wr0BGaEoXxNUqMfwcLMTsa7JhIJPOec+3N4S1Q7ZnYE8CWwkN3Xdn6Dd93qTaAT3oHkbOfc3heMGwQzGwv80jk30cxa0cDrZWaD8DqNxACrgcvwviA29Hr9ATgXr4fqXOAKoDkNsF5m9howFm8qkM3AncA77KcuZvZb4HK8ut/onPuw/kvdNDX6sBIRkYavsZ8GFBGRRkBhJSIivqewEhER31NYiYiI7ymsRETE9xRWIgdhZmN/GA1eRMJDYSUiIr6nsJJGw8wuNLMZZjbPzJ4KzpFVZGZ/M7M5Zva5mbUJrjvIzL41swVm9vYPcxaZWQ8z+8zM5ge36R7cffMqc1O9Ehy9QUTqicJKGgUz64s3qsIY59wgoBK4AEgA5jjnhgBT8UYoAHgJ+LVzbgDeqCA/LH8FeMw5NxBvzLvs4PLBwI1486J1wxvTUETqSVS4CyBSR44DhgIzg42eZngDkAaAN4LrvAxMMrNkIMU5NzW4/EXg32aWCKQ5594GcM6VAAT3N8M5lxl8Pg/oAkwPea1EBFBYSeNhwIvOudv3WGh2x17rHWh8sQOd2iut8rgSfXZE6pVOA0pj8Tlwlpm1BTCzlmbWGe9v/KzgOj8Fpjvn8oFtZnZkcPlFwNTg/GCZZvaT4D5izSy+PishItXTt0NpFJxzS8zsd8AnZhYBlAM/x5v0sL+ZzQby8a5rgTf1w5PBMPphRHTwguspM/tjcB9n12M1RGQ/NOq6NGpmVuScax7ucojIj6PTgCIi4ntqWYmIiO+pZSUiIr6nsBIREd9TWImIiO8prERExPcUViIi4nv/DxFMQH8Xp5llAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 439.5x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "metrics = pd.read_csv(f\"{trainer.logger.log_dir}/metrics.csv\")\n",
+    "del metrics[\"step\"]\n",
+    "metrics.set_index(\"epoch\", inplace=True)\n",
+    "display(metrics.dropna(axis=1, how=\"all\").head())\n",
+    "sn.relplot(data=metrics, kind=\"line\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.7 ('base')",
+   "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.9.7"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "13c03235e9ff730a4bd51e1f602be3bd93655a1f9b860f83693cc60199f0a90d"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

fer2013.csv.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cef395bbf67f80b8968362818f7fe00ddc1d6604b5f79795ca263e656d937cb
+size 101279992

fer2013/test.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f9b7c61fb507efe8430cd0b5eb297fb405ca648b230f333049e2531c9724eac1
+size 30128889

fer2013/train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5106ed9042eac3e4f72d2dcc373e24a0bd6920c579a875a9244eb98dbc9ea059
+size 241033347

fer2013/val.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9c9ca92361febea201ad9aacf16df4a0fd0f3c07079edb8de4752ee3f65e3280
+size 30114787