ViViT_toy_dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fd8ef81e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# running ViViT with 3D MNIST dataset \n",
    "\n",
    "# Code source of implementation of ViViT: https://github.com/rishikksh20/ViViT-pytorch\n",
    "\n",
    "\n",
    "# Only model 2 from ViViT: A Video Transformer is implemented "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ec2d3c61",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn, einsum\n",
    "import torch.nn.functional as F\n",
    "from einops import rearrange, repeat\n",
    "from einops.layers.torch import Rearrange\n",
    "from module import Attention, PreNorm, FeedForward\n",
    "from scipy import ndimage\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "from MNIST_3D_data import MNIST_3D_Growing, MNIST_3D_Random_Rotation, MNIST_3D_Gaussian_Noise, scipy_clipped_zoom_3d\n",
    "from vivit import ViViT "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "38cd01a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ Using Seed :  10  ]\n"
     ]
    }
   ],
   "source": [
    "# set seed\n",
    "def seed_all(seed=10):\n",
    "\n",
    "\n",
    "    print(\"[ Using Seed : \", seed, \" ]\")\n",
    "\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "\n",
    "seed_all()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19090303",
   "metadata": {},
   "source": [
    "### Loading 3DMnist data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "aa25136c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torchvision import transforms, utils\n",
    "transforms = transforms.Compose([\n",
    "    MNIST_3D_Random_Rotation(max_angle = 15),\n",
    "    MNIST_3D_Gaussian_Noise(mean = 0, var = 0.000001)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "56b2cbfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "config = {\n",
    "    'num_train_data': 1000,\n",
    "    'num_test_data' : 200,\n",
    "    'class_names' : ['non', \n",
    "                   'slow_g',\n",
    "                   'steady_g',\n",
    "                   'fast_g',\n",
    "                   'slow_s',\n",
    "                   'steady_s',\n",
    "                   'fast_s'],\n",
    "    'class_growth_rates' : {'non' : 1,\n",
    "                          'slow_g' :1.1,\n",
    "                          'steady_g':1.2,\n",
    "                          'fast_g': 1.3,\n",
    "                          'slow_s': 0.9,\n",
    "                          'steady_s': 0.8,\n",
    "                          'fast_s': 0.75}\n",
    "\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "98b66d4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "save_path = './dataset/3D_MNIST_vanilla.npz'\n",
    "training_data = MNIST_3D_Growing(save_path, scipy_clipped_zoom_3d, \n",
    "                                 config['num_train_data'],  \n",
    "                                 train = True,\n",
    "                                 transforms = transforms,\n",
    "                                 class_names = config['class_names'],  \n",
    "                                 class_growth_factors = config['class_growth_rates']\n",
    "                                 \n",
    "                                )\n",
    "testing_data = MNIST_3D_Growing(save_path, scipy_clipped_zoom_3d, \n",
    "                                 config['num_test_data'],\n",
    "                                 train = False,\n",
    "                                transforms = transforms,\n",
    "                                class_names = config['class_names'],  \n",
    "                                 class_growth_factors = config['class_growth_rates']\n",
    "                                \n",
    "                                )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "144aab00",
   "metadata": {},
   "outputs": [],
   "source": [
    "def seed_worker(worker_id):\n",
    "    worker_seed = torch.initial_seed() % 2**32\n",
    "    numpy.random.seed(worker_seed)\n",
    "    random.seed(worker_seed)\n",
    "    \n",
    "g = torch.Generator()\n",
    "g.manual_seed(0)\n",
    "\n",
    "training_generator = torch.utils.data.DataLoader(training_data, batch_size=16,worker_init_fn=seed_worker,\n",
    "        generator=g)\n",
    "testing_generator = torch.utils.data.DataLoader(testing_data, batch_size=16,worker_init_fn=seed_worker,\n",
    "        generator=g)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3bc1c5a8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# train_features, train_labels = next(iter(training_generator))\n",
    "# train_features.shape\n",
    "# batch size = 16, time steps = 3, 28 x 28 x 28 image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0796874",
   "metadata": {},
   "source": [
    "### Initializing model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6aca138a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# documenting the ViViT class from https://github.com/rishikksh20/ViViT-pytorch\n",
    "\n",
    "# def __init__(self, image_size, patch_size, num_classes, num_frames, dim = 192, depth = 4, heads = 3, pool = 'cls', in_channels = 3, dim_head = 64, dropout = 0.,\n",
    "#                 emb_dropout = 0., scale_dim = 4, ):\n",
    "        \n",
    "# image size: height = width of image \n",
    "# patch size: size of the little patches where an image will be divided into \n",
    "# num classes\n",
    "# num frames \n",
    "# dim: dimension of the input zl (rasterized image patch) \n",
    "# depth: number of attention layers\n",
    "# heads: number of heads in an attention layer \n",
    "# pool: pool type must be either cls (cls token) or mean (mean pooling)\n",
    "# in_channels: number of channels of input\n",
    "# dim_head: dimensions of the heads\n",
    "\n",
    "# vivit_input = {\n",
    "#     'image_size': 28,\n",
    "#     'patch_size': 14, \n",
    "#     'num_classes': len(config[\"class_names\"]),\n",
    "#     'num_frames': 3, \n",
    "#     'in_channels': 1\n",
    "# }\n",
    "\n",
    "# model = ViViT(image_size=vivit_input[\"image_size\"], \n",
    "#               patch_size=vivit_input[\"patch_size\"], \n",
    "#               num_classes=vivit_input[\"num_classes\"], \n",
    "#               num_frames=vivit_input[\"num_frames\"], \n",
    "#               in_channels=vivit_input[\"in_channels\"])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8eb98122",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    print(torch.cuda.get_device_name(0))\n",
    "    device = torch.device('cuda:0')\n",
    "    torch.set_default_tensor_type('torch.cuda.FloatTensor')\n",
    "else:\n",
    "    print('cpu')\n",
    "    device = torch.device('cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d3d0dd6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# source: https://github.com/bdrad/project-conv-meleon/blob/3DMNIST/ConvLSTM_3D_training_loop.ipynb\n",
    "\n",
    "def validate(model, data_loader):\n",
    "        model.eval()\n",
    "        correct = 0\n",
    "        with torch.no_grad():\n",
    "            for features, labels in data_loader:\n",
    "                features = features.to(torch.float)\n",
    "                \n",
    "                # reshaping input into the model to match the dimensions\n",
    "                # num frame x channels x height x width \n",
    "                features = torch.unsqueeze(torch.squeeze(features), 2)\n",
    "                \n",
    "                labels = labels.to(torch.long)\n",
    "                features = features.to(device)\n",
    "                labels = labels.to(device)\n",
    "                outputs = torch.argmax(model(features), dim=1)\n",
    "                correct += int(torch.sum(outputs==labels))\n",
    "        print(f'Validation Accuracy: {correct/(len(data_loader) * data_loader.batch_size) * 100:.3f}%')\n",
    "        return correct/(len(data_loader) * data_loader.batch_size) * 100\n",
    "\n",
    "def save_model(model, savepath):\n",
    "    torch.save(model.state_dict(), savepath)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9d7f4aa",
   "metadata": {},
   "source": [
    "### Training loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "de733b68",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def training_loop(num_iter, training_dataloader, testing_dataloader, vivit_input, verbose=False):\n",
    "    \n",
    "    \n",
    "    \n",
    "    model = ViViT(image_size=vivit_input[\"image_size\"], \n",
    "                  patch_size=vivit_input[\"patch_size\"], \n",
    "                  num_classes=vivit_input[\"num_classes\"], \n",
    "                  num_frames=vivit_input[\"num_frames\"], \n",
    "                  in_channels=vivit_input[\"in_channels\"])\n",
    "    \n",
    "    #hyperparameters\n",
    "    epochs=num_iter\n",
    "    learning_rate = 1e-4\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
    "\n",
    "    \n",
    "    validation_acc = []\n",
    "    training_loss = []\n",
    "    \n",
    "    for epoch in range(epochs):\n",
    "\n",
    "        start = time.time()\n",
    "\n",
    "        model.train()\n",
    "        current_train_loss = 0\n",
    "        length = 0\n",
    "        for x, y in training_dataloader:\n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            # reshape data to fit into model \n",
    "            # x should have the dimensions batch x num frame x channels x height x width x depth\n",
    "            x = torch.squeeze(x)\n",
    "            x = torch.unsqueeze(x, 2)\n",
    "\n",
    "            x = x.to(device).type(torch.float32)\n",
    "            y = y.to(device).long()\n",
    "\n",
    "            output = model(x)\n",
    "            loss = criterion(output, y)\n",
    "            current_train_loss += float(loss.item())\n",
    "            length += x.shape[0]\n",
    "            # ===================backward====================\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        # ===================log========================\n",
    "        current_train_loss = current_train_loss / length\n",
    "        \n",
    "        if verbose:\n",
    "            print(\"Epoch {} of iteration {} training loss: {}\".format(epoch+1, iteration, current_train_loss))\n",
    "        val_acc = validate(model, testing_dataloader)\n",
    "        validation_acc.append(val_acc)\n",
    "        training_loss.append(current_train_loss)\n",
    "\n",
    "        end = time.time()\n",
    "        \n",
    "        if verbose:\n",
    "            print(\"time elapsed: {} seconds\".format(end-start))\n",
    "            \n",
    "    return validation_acc, training_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "051be2fe",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 of iteration 30 training loss: 0.09454602044820785\n",
      "Validation Accuracy: 51.923%\n",
      "time elapsed: 12.769099950790405 seconds\n",
      "Epoch 2 of iteration 30 training loss: 0.04904242074489593\n",
      "Validation Accuracy: 62.500%\n",
      "time elapsed: 12.957772016525269 seconds\n",
      "Epoch 3 of iteration 30 training loss: 0.03428671024739742\n",
      "Validation Accuracy: 67.308%\n",
      "time elapsed: 12.854721069335938 seconds\n",
      "Epoch 4 of iteration 30 training loss: 0.020483096338808536\n",
      "Validation Accuracy: 69.712%\n",
      "time elapsed: 12.714137077331543 seconds\n",
      "Epoch 5 of iteration 30 training loss: 0.01602186904475093\n",
      "Validation Accuracy: 75.962%\n",
      "time elapsed: 12.734232664108276 seconds\n",
      "Epoch 6 of iteration 30 training loss: 0.0125580192245543\n",
      "Validation Accuracy: 77.404%\n",
      "time elapsed: 12.736901998519897 seconds\n",
      "Epoch 7 of iteration 30 training loss: 0.010873724393546582\n",
      "Validation Accuracy: 85.096%\n",
      "time elapsed: 12.70076298713684 seconds\n",
      "Epoch 8 of iteration 30 training loss: 0.006286109389737248\n",
      "Validation Accuracy: 84.135%\n",
      "time elapsed: 12.674754858016968 seconds\n",
      "Epoch 9 of iteration 30 training loss: 0.0021670702397823334\n",
      "Validation Accuracy: 83.654%\n",
      "time elapsed: 12.700137853622437 seconds\n",
      "Epoch 10 of iteration 30 training loss: 0.0025469417243730278\n",
      "Validation Accuracy: 81.731%\n",
      "time elapsed: 12.886660099029541 seconds\n",
      "Epoch 11 of iteration 30 training loss: 0.0019235401407349856\n",
      "Validation Accuracy: 86.058%\n",
      "time elapsed: 12.897661924362183 seconds\n",
      "Epoch 12 of iteration 30 training loss: 0.0034326619850471615\n",
      "Validation Accuracy: 84.135%\n",
      "time elapsed: 12.911507844924927 seconds\n",
      "Epoch 13 of iteration 30 training loss: 0.002897593056317419\n",
      "Validation Accuracy: 82.212%\n",
      "time elapsed: 12.716392040252686 seconds\n",
      "Epoch 14 of iteration 30 training loss: 0.0022010939789470284\n",
      "Validation Accuracy: 84.135%\n",
      "time elapsed: 12.676135063171387 seconds\n",
      "Epoch 15 of iteration 30 training loss: 0.0006850583334453403\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.717972040176392 seconds\n",
      "Epoch 16 of iteration 30 training loss: 0.0002802278088638559\n",
      "Validation Accuracy: 86.538%\n",
      "time elapsed: 12.705595970153809 seconds\n",
      "Epoch 17 of iteration 30 training loss: 0.0001560717822285369\n",
      "Validation Accuracy: 87.500%\n",
      "time elapsed: 12.913329124450684 seconds\n",
      "Epoch 18 of iteration 30 training loss: 0.00013263064494822174\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.674609899520874 seconds\n",
      "Epoch 19 of iteration 30 training loss: 0.00011968260630965233\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.675198078155518 seconds\n",
      "Epoch 20 of iteration 30 training loss: 0.00010995840607210993\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.67510175704956 seconds\n",
      "Epoch 21 of iteration 30 training loss: 0.00010217027645558118\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.67085599899292 seconds\n",
      "Epoch 22 of iteration 30 training loss: 9.569225180894137e-05\n",
      "Validation Accuracy: 88.462%\n",
      "time elapsed: 12.688864946365356 seconds\n",
      "Epoch 23 of iteration 30 training loss: 9.016347886063159e-05\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.683064937591553 seconds\n",
      "Epoch 24 of iteration 30 training loss: 8.535448310431093e-05\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.811312913894653 seconds\n",
      "Epoch 25 of iteration 30 training loss: 8.110902196494863e-05\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.78270697593689 seconds\n",
      "Epoch 26 of iteration 30 training loss: 7.731734268600122e-05\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.731356859207153 seconds\n",
      "Epoch 27 of iteration 30 training loss: 7.389693107688799e-05\n",
      "Validation Accuracy: 87.981%\n",
      "time elapsed: 12.85708475112915 seconds\n",
      "Epoch 28 of iteration 30 training loss: 7.078659610124304e-05\n",
      "Validation Accuracy: 88.462%\n",
      "time elapsed: 12.824476957321167 seconds\n",
      "Epoch 29 of iteration 30 training loss: 6.793797720456496e-05\n",
      "Validation Accuracy: 88.462%\n",
      "time elapsed: 12.803894758224487 seconds\n",
      "Epoch 30 of iteration 30 training loss: 6.53135734028183e-05\n",
      "Validation Accuracy: 88.462%\n",
      "time elapsed: 12.75623083114624 seconds\n"
     ]
    }
   ],
   "source": [
    "model_log = {\n",
    "    \"validation_accuracy\": [], \n",
    "    \"training_loss\": []\n",
    "}\n",
    "\n",
    "vivit_input = {\n",
    "'image_size': 28,\n",
    "'patch_size': 14, \n",
    "'num_classes': len(config[\"class_names\"]),\n",
    "'num_frames': 3, \n",
    "'in_channels': 1\n",
    "}\n",
    "\n",
    "iteration = 30\n",
    "validation_acc, training_loss = training_loop(num_iter=iteration, training_dataloader=training_generator, \n",
    "                                                  testing_dataloader=testing_generator, vivit_input=vivit_input, verbose=True)\n",
    "\n",
    "    \n",
    "model_log['validation_accuracy'].append(validation_acc)\n",
    "model_log['training_loss'].append(training_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "af57cec5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl4AAAGDCAYAAAD6aR7qAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABC7klEQVR4nO3deXxdVbn/8c+ToU2HtOmQzhOdoXMphZaZoswgICLIIKAICIrTlavXK179XVHhoqKCCEVQRCZRRmVugVKgY1LoPCdN23RK2qZDhuf3x9nFGJP0nJOzz87wfb9eeeVMe+0nJyvJN2uvvba5OyIiIiISvoyoCxARERFpKxS8RERERNJEwUtEREQkTRS8RERERNJEwUtEREQkTRS8RERERNJEwUtEUsrM3MyGB7fvM7PvxfPaJPbzOTN7Odk6RUSiYFrHS0RqM7N/AO+5+3/XefwC4LfAAHevamR7B0a4+6o49hXXa81sCLAWyG5s3yIizZ1GvESkrt8DV5qZ1Xn8SuBRBZ9wmVlW1DWISHgUvESkrr8C3YETDz1gZt2Ac4FHzGyqmb1rZrvMrMTMfmVm7epryMx+b2Y/qnX/W8E2m8zs2jqvPcfMFppZuZltNLPbaz09O/i8y8z2mNk0M/u8mb1da/vpZvaBmZUFn6fXeu5NM/uhmb1jZrvN7GUz69lAzd3M7HkzKzWzncHtAbWe725mDwVfw04z+2ut5y4ws0XB17DazM4MHl9nZqfXet3tZvbH4PaQ4JDrdWa2AXg9ePxJM9scfD2zzWxMre07mNldZrY+eP7t4LEXzOyWOl9PgZl9qr6vVUTST8FLRP6Fu+8DngCuqvXwZ4Bl7r4YqAa+BvQEpgEzgJsO124QQr4JfAIYAZxe5yV7g33mAecAN9YKDCcFn/PcvbO7v1un7e7AC8AvgR7A/wEvmFmPWi+7HLgG6AW0C2qpTwbwEDAYGATsA35V6/k/AB2BMUFbdwc1TAUeAb4VfA0nAesa2Ed9TgaOBM4I7r9E7H3qBSwAHq312juBo4HpxELyfwA1wMPAFYdeZGYTgP7AiwnUISIhUvASkfo8DFxiZh2C+1cFj+Hu8919rrtXufs6YvO+To6jzc8AD7n7EnffC9xe+0l3f9PdC929xt0LgMfibBdiQW2lu/8hqOsxYBlwXq3XPOTuK2oFy4n1NeTu2939aXevcPfdwP87VIeZ9QXOAm5w953uXunus4JNrwNmuvsrwddQ7O7L4qwf4HZ33xvUh7vPdPfd7n6A2Hs1wcy6mlkGcC3w1WAf1e4+J3jd34ARZjYiaPNK4HF3P5hAHSISIgUvEfk37v42UApcYGZDgWOAPwGY2cjg8NtmMysH/pfY6Nfh9AM21rq/vvaTZnasmb0RHOIrA26Is91Dba+v89h6YqM9h2yudbsC6FxfQ2bW0cx+GxzGKyd2mDPPzDKBgcAOd99Zz6YDgdVx1lufj98bM8s0szuCw5Xl/HPkrGfwkVPfvoLw9QRwRRDQLiM2QicizYSCl4g05BFiI11XAi+7+5bg8XuJjSaNcPcuwHeAuhPx61NCLJwcMqjO838CngUGuntX4L5a7R7u9OtNxA4N1jYIKI6jrrq+AYwCjg2+vkOHOY1YOOpuZnn1bLcRGNZAm3uJHZ48pE89r6n9NV4OXEDscGxXYEitGrYB+xvZ18PA54gdAq6oe1hWRKKl4CUiDXmE2B/+LxIcZgzkAuXAHjMbDdwYZ3tPAJ83s6PMrCPw/TrP5xIbTdofzJe6vNZzpcTmMA1toO0XgZFmdrmZZZnZpcBRwPNx1la3jn3EJvJ3r12nu5cQm3v1m2ASfraZHQpmDwLXmNkMM8sws/7B+wOwCPhs8PopwKfjqOEAsJ1YYPvfWjXUADOB/zOzfsHo2DQzax88/y6x9+ouNNol0uwoeIlIvYL5W3OATsRGog75JrFQtBv4HfB4nO29BPyc2Fl7q4LPtd0E/I+Z7Qb+m1hQO7RtBbG5Vu9Y7GzK4+q0vZ3YWZffIBZW/gM41923xVNbHT8HOhAbWZoL/L3O81cClcRG/bYCtwY1vE9s8v7dQBkwi3+Own2P2AjVTuAHBIdtG/EIsUOlxcBHQR21fRMoBD4AdgA/4V9/nz8CjAP+eJj9iEiaaQFVEZFWxsyuAq539xOirkVE/pVGvEREWpHgMO5NwP1R1yIi/07BS0SklTCzM4jNh9vC4Q9nikgEdKhRREREJE004iUiIiKSJqEGLzP7qpktMbMPzezW4LHuZvaKma0MPncLswYRERGR5iK0Q41mNhb4MzAVOEjslOwbia0JtMPd7zCz24Bu7v7txtrq2bOnDxkyJJQ6RURERFJp/vz529w9v77nskLc75HA3GD9HcxsFnAhsdWYTwle8zDwJtBo8BoyZAjz5s0LrVARERGRVDGzupcw+1iYhxqXACeZWY/g9OaziV0upHew+vOhVaB71bexmV1vZvPMbF5paWmIZYqIiIikR2jBy92XEltN+RVihxkXA1UJbH+/u09x9yn5+fWO1omIiIi0KKFOrnf3B919srufROyyFiuBLWbWFyD4vDXMGkRERESai7DPauwVfB4EXAQ8Ruyab1cHL7ka+FuYNYiIiIg0F2FOrgd42sx6ELug7JfdfaeZ3QE8YWbXARuAS0KuQURERKRZCDV4ufuJ9Ty2HZgR5n5FREREmiOtXC8iIiKSJgpeIiIiImmi4CUiIiKSJgpeIiIiImmi4CUiIiKSJmEvJyEiIhKK8v2VLCvZzYBuHeiX1yHqcqQeZRWVfLipjAPVNVGX8rExfbvQq0tOZPtX8BIRkWavpsZZs20vC9bvZMGG2MfKrXtwjz3fp0sOkwfnMXlQNyYN6sbY/l1on5UZbdFtTE2Ns6p0T63v0S5Wbd0TdVn/5leXT+Lc8f0i27+Cl4iINDu791eyeGPZxyFr4YZdlO2rBKBLThaTB3fj3PH9GNOvCxt3VLBgwy4WbNjJi4WbAWiXmcGY/l2YPKhb7GNwHn27alQslcr2VbJo466Pg9aijbvYvT92SeZuHbOZNKgbF07qz4QBeXRq33xC8JAenSLdv/mhfxeasSlTpvi8efOiLkNERELgXns0axcLN+xk+ZbduIMZjOjV+V8C1NCencnIsHrb2rp7PwvWx9pYsGEnBUVlHKiKHebq2zUnaKMbkwflMaZfV9plaapzPGIjjntYsD4WcOev38mq0tiIY4bByN65wfsae2+P6NkJs/q/R22Bmc139yn1PqfgJSKtzY69B1mxZTfHHtG9xf/yd3fWb6+goLiM/Qeroy4npbbu3v/xSNWuithoVm5OFpOCP96TB3Vj4qA8uuRkJ72Pg1U1LC0p//jQ14L1OynetQ+AdlkZjOvflcmD8hiW35mMFt5XwlBStj8YcdxJeTCaldcxm0kD8z4OsRMG5tG5vQ6g1abgJSJthrtzxYPv8c6q7Zw1tg8//NRYenZuH3VZcas4WPXxIbaFwSG27XsPRl1WaIb36szkQXkcHYyWDMtveDQrVbaU7/+XeUiFxWUcrGo+k7+bEzMY2SuXyYPzmDSoG0cP7sbQNj6aFY/Ggpciqoi0Km8s38o7q7Zzyqh8Xlu6lffWzuaHF4zlnPF9oy7t37g7G3ZUxAJAcAhn2ebdVNfE/iEemt+JU0f3io38DMyja8fkR36ao9ycrCaNZiWrd5cczhrXl7PGxfrEgapqtu1pveG2KbrkZJEbwfeoNVPwEpFWo7K6hv/3wlKG9uzE766awtpte/nmk4v58p8W8GJhX/7ngjH0iHD0a9/BagqKdjE/CFqLNu78+A9+p3aZTBiYx02nDPs4aHXr1C6yWtuS9lmZ9NdyFJImCl4i0mr8+f0NrC7dy++umkJ2ZgYje+fylxun89vZa/j5qyuYu2Y7P/rU2I9HOsLm7sxds4O/LylhwYZdLC0ppyoYzTqiZydOGpn/8aTxUX1yyQz5EJuIRE/BS0RahfL9ldz96kqOG9qd04/s9fHjWZkZfPnU4Zx+ZG+++eRibnx0AeeO78v/XDCW7iGNKB2squGFwk088NZaPtxUTofsTCYM7MqXTh768TpTYe1bRJo3BS8RaRV+/cYqdlYc5L/OOareib+j+uTyl5umc9+bq/nl6yuD0a9xnDm2T8pqKKuo5E/vb+DhOevYXL6fYfmd+PFF47hwUn9yspvPOkYiEh0FLxFp8TbuqOCht9dx0aQBjO3ftcHXZWdmcMuMEZx+VGz064Y/zuf8Cf34wfljmjSfav32vcx8ey1PzCtiX2U1xw/vwY8vGsfJI/NDP0NPRFoWBS8RafF+8vdlZGTAt84YFdfrj+zbhb9++Xh+88Zq7nl9JXNWb+d/LxzLJ8fEP/rl7sxbv5MH3lrDyx9tISvDOH9Cf6474QiO6tcl2S9FRFo5BS8RadHmr9/J8wUlfGXGCPp0jf/Ct9mZGXz19BF8Ihj9uv4P8/nUxH7cfv4Y8jo2PPpVVV3Di0s28+Bba1hcVEZex2y+fMpwrpo2ONIL74pIy6DgJSItlrvzoxc+Ij+3PV86aWhSbRzVLzb69es3VvHrN1bxzurt/O+F4/jEUb3/5XXl+yt5/P2N/H7OOop37eOInp344afGcvHk/nRsp1+lIhIf/bYQkRbrhcISFm7YxU8vHk+nJlyypF1WBl/7xMiPR7+++Mg8LprUn++fN4by/ZX8fs46Hv9gI3sOVHHc0O784PwxnDa6l+ZviUjCFLxEpEXaX1nNHS8tY3SfXC4+ekBK2hzbvyvP3nwCv3p9Jb9+czWvLdvK7v2VZJhx7vi+XHfCUMYNaHjyvojI4Sh4iUiL9PCcdRTt3Mcfrzs2pQuPtsvK4OufHMUnx/Th56+uYFivznx++hD6dtXK5iLSdApeItLibN9zgF+9vorTRvfihBE9Q9nH2P5deeDqY0JpW0TaroyoCxARSdQvXltJRWU13zl7dNSliIgkRMFLpAV7e+U2vv7EInZVHIy6lLRZtXU3j763gcunDmJ4r9yoyxERSYgONYq0UFXVNXz3r4Ws315BQVEZD187lf55rX8e0o9fXEbH7ExuPX1E1KWIiCRMI14iLdTfFm1i/fYKbjh5GFvK93PRb95haUl51GWF6p1V23ht2Va+fNpwenRuH3U5IiIJU/ASaYGqqmu45/WVHNW3C98+cxRP3TAdw/jMfe8yZ/W2qMsLRXWN86MXltI/rwOfnz4k6nJERJKi4CXSAj27eBPrtlfwlRkjMDNG9cnlLzdNp29eDp+f+QHPLd4UdYkp9/T8IpaWlHPbWaPJyc6MuhwRkaQoeIm0MLHRrlUc2bcLn6x1WZt+eR148kvTmTgoj1seW8gDb62JsMrU2nugijtfXs6kQXmcO75v1OWIiCQt1OBlZl8zsw/NbImZPWZmOWZ2u5kVm9mi4OPsMGsQaW2eK9jE2m17+eqM4f92yZquHbN55NqpnD2uDz96YSk/ev4jamo8okpT57ez17B19wH+65yjMNNlekSk5QrtrEYz6w98BTjK3feZ2RPAZ4On73b3O8Pat0hrVVVdwz2vrWJ0n1w+eVSfel+Tk53JPZdNplfuRzzw9lq27D7AnZeMp31Wyzw8t7lsP/fPXs054/ty9OBuUZcjItIkYR9qzAI6mFkW0BFofRNPJC2eXbyJE37yOj9/dQXb9hyIupzIPFewiTXb9vLVGSMavUBzZobx/fOO4razRvPc4k18fuYHlO+vTGOlqfOzfyynpgZuO1OLpYpIyxda8HL3YuBOYANQApS5+8vB0zebWYGZzTQz/Qsrh/XU/CJKdx/g56+uZPodr3Pb0wWs3LI76rLSqrrGPx7tOmNM/aNdtZkZN5w8jP/7zAQ+WLeDz9z3LlvK96eh0tRZUlzGXxYWcc3xQxjYvWPU5YiINFlowSsIVBcARwD9gE5mdgVwLzAMmEgskN3VwPbXm9k8M5tXWloaVpnSAuyvrOa9Ndv53LGDee0bJ3PJ0QN4ZmExn7h7NlfPfJ+3V27DveXPYzqc5xbHRru+cpjRrroumjyAh645ho07KrjoN3NYtbVlBFZ350cvfES3ju246dThUZcjIpISYR5qPB1Y6+6l7l4J/AWY7u5b3L3a3WuA3wFT69vY3e939ynuPiU/Pz/EMqW5e2/tDg5U1XDSyJ4My+/M/7twHO/+5wy+8YmRfLipnCsefI+zfvEWT87byIGq6qjLDUV1jfPL11cyqncuZ8Yx2lXXiSPyefxL0zhQVcPF977LB+t2hFBlar26dCtz1+zg1tNH0LVDdtTliIikRJjBawNwnJl1tNhpSDOApWZW+1zwC4ElIdYgrcCs5aW0z8rguKE9Pn6se6d23DJjBO/cdio/+/R4AL71VAEn/OQNfvX6SnbubV3XLny+YBNrShMf7aptbP+uPHPTdHp0ascVD7zH35dsTnGVqVNZXcOPX1zKsPxOXDZ1UNTliIikTJhzvN4DngIWAIXBvu4HfmpmhWZWAJwKfC2sGqR1mLViK8cO7VHvopntszK5ZMpAXvrqifzxumMZ068Ld768gml3vMZ3nylkdemeCCpOreoa55evrWRk786cNTbx0a7aBnbvyFM3Tueofl248dH5/OHddakpMsUenbueNdv28p2zjyQ7U8sNikjrEepFst39+8D36zx8ZZj7lNalaGcFq0v3cvmxgxt9nZlxwoienDCiJyu27Gbm22t5cn4Rj763gRmje/GFE4dy3NDuLXINqOcLNrG6dC+/vnxy0qNdtXXv1I4/feE4bnlsAd/724eUlO3nW2eMajbvTVlFJT9/bSXTh/XgtNG9oi5HRCSl9K+kNGuzV8SuO3jyyJ5xbzOydy53XDyeObedxq2nj2DRxl1c9ru5nHvP2zyzsIiKg1VhlZty1TXOPa+vSsloV20d2mVy3xVHc9nUgfzmzdV848nFVFbXpKz9pvjVGysp21fJd885stmEQRGRVAl1xEukqWat2Er/vA4My++c8LY9O7fn1tNHcsPJw/jrwmIeeHstX3t8MZkZBYzuk8vkQd2YPDiPyYO6Mah7x2b5R/6FwhJWbd3Dry6flJLRrtqyMjP43wvH0bdrB/7vlRWU7j7AvVccTef20f1a+OvCYh56Zx2fnjyAMf26RlaHiEhYFLyk2aqsruGdVds5b0K/JoWinOxMPjt1EJ+ZMpC5a7bz7prtLNiwk78sKOIPc9cD0LNzOyYO/GcQmzAgjw7tol3pPbZu10pG9OrM2WPDuT6hmfGVGSPo3aU933lmCZfdP5eZnz+G/Nz2oeyvIe7Ob2ev4Y6XlnHc0O5877yj0rp/EZF0UfCSZmvB+p3sOVDFySNTs5xIRoYxfXhPpg+PHbasrnFWbNnNgg07WbB+Fws37OTVpVsAyMowjuzbhcmD8pg8uBuTB3VjQLcOaR0Ve7GwhJVb93DPZakf7arr0mMGkZ/bni8/upCL7n2HR649liN6dgp1n4dU1zg/fP4jfj9nHeeO78tdn5nQYi9vJCJyONYSFp6cMmWKz5s3L+oyJM1+9o9l3DdrDQv/+xN0yUnPOk479h5k4YadH4exxUW7qDgYWxusZ+f2HwexE0f0DPVQWE2Nc8bPZ+PAP249icyQg9chizbu4trffwDAzM8fw8SBeaHub39lNV9/YhEvFm7muhOO4LtnHxl6yBQRCZuZzXf3KfU+p+AlzdW597xFx+wsnrhhWmQ1VFXXsHzLbhZs2MXC9bFAtm57BRkGP7hgLFce1/jZlsl6vmATN/9pIb+8bBLnT+gXyj4asnbbXq6e+T6luw/w689N4rTRvUPZT1lFJV/8wzzeX7uD/zrnSL5w4tBQ9iMikm6NBS+d1SjNUunuAywpLufkUdFetSArM4Mx/bpy5XGD+b9LJ/Lmt05l3n+dzmmje/G9vy7hZ/9YlvLLFdUE63YNy+/EOePCmdvVmCN6duLpG6czvFdnvvjIfP78/oaU72PTrn1c8ts5LNywk19eNkmhS0TaDAUvaZbeXhW7PudJI5rf5aJ6dm7/8VIMv35jNd98siClSzG8tGQzK7bs4SszRqTtEGNd+bnt+fP1x3H88J7c9pdCfvHqypQFzOWbd3PRb+ZQsms/D18zNe0jeiIiUVLwkmZp1vJSenRqx5h+XaIupV6HlmL4+idG8vSCIq57eB57DzR9fbCaGucXr61gWH4nzh0fbSDp1D6LB6+ewsWTB3D3qyv4zjNLqGpiwJy7Zjufvm8ONe48/qVpH5/oICLSVih4SbNTU+PMXrmNk0bmN+uJ1oeWYvjJxeN4Z9U2Pnv/XEp3H2hSm3//MPrRrtqyMzO485LxfPnUYTz2/gZu+ON89h1M7kLkLxSUcNWD79O7Sw5/uSl22SIRkbZGwUuanSWbytix92DKlpEI26XHDOJ3Vx3Nqq17uPjeOazdtjepdmpqnF+8upKhzWC0qzYz41tnjOaHF4zhtWVbufyBuexI8CLkD72zlpsfW8D4AV156oZpDOjWMaRqRUSaNwUvaXZmr4jN7zphRMs5DHXa6N48dv1x7DlQxcX3zmHRxl0Jt/GPDzezfMtuvnJa8xjtquvKaUO493NH89Gmcj597xw27qg47DY1Nc6PX1rKD577iE8e1Zs/fuFY8jq2S0O1IiLNk4KXNDuzVpQyrn9XenZO7+rpTTVxYB5P3zidzu2zuOz+uby+bEvc28bmdq1kaM9OnNeMJ5ufObYPj37hWLbvPchF985hSXFZg689WFXD159YxG9nreHK4wbzm88dTU62FkYVkbZNwUualfL9lSzYsKvFHGas69BSDMN6deKLj8zn8Q/iW4rh5Y82s2zzbm6ZMbxZjnbVNmVId56+cRrtMjO49Lfv8tbK0n97ze79lVz7+w/466JNfOuMUfzPBWOa/dclIpIOCl7SrMxZtY3qGo98/a6miC3FMI3jh/fk208ffimGmhrn568Go13NaG5XY4b3yuUvN01nYPeOXPPQBzyzsOjj57aW7+fS385l7prt3HnJBL586vBmeQFyEZEoKHhJszJrRSm57bNCv1RN2DoHSzFcNLn/YZdiePmjLSzbvJubTxtOVmbL+ZHs3SWHJ26YxjFDuvO1xxdz36zVrC7dw0X3zmHd9r08cPUUPn30gKjLFBFpVnSRbGk23J1Zy0s5fnhPsltQAGlIdmYGd10ygb5dc/j1G6sp3b2fey6bTId2/5zndGhu1xE9O7XIhUS75GTz+2uP4VtPFnDHS8u4+5UV5OZk8fj10xg3ILxrWYqItFQt/6+btBqrtu5hU9n+Fn2Ysa5DSzH8TwNLMbyydAtLS8q5+dSWNdpVW/usTH5+6URuPGUYo/vk8vSN0xW6REQaoBEvaTZmBctInNRCJ9Y35qppQ+iVm8NX/ryQT987h4evncqAbh34xasrGdKjIxdMbHmjXbVlZBjfPnN01GWIiDR7LfNfbGmVZq0oZXivzvTP6xB1KaGouxTDr15fxUcl5dx82ogWO9olIiKJ0W97aRb2HazmvbU7WuwyEvE6Zkh3nrphGtkZxl2vrGBwj458qoWPdomISPwUvKRZmLt2Oweralp98AIY0TuXv9x0PKcf2Zvbzx+j0S4RkTZEc7ykWZi9opT2WRlMPaJ71KWkRZ+uOTxw9ZSoyxARkTTTv9rSLMxaUcpxQ3vokjIiItKqKXhJ5DbuqGBN6d42cZhRRETaNgUvidzs4Fp/rWn9LhERkfooeEnkZi0vpX9eB4b27BR1KSIiIqFS8JJIHayqYc7q7Zw8Kl8XUhYRkVZPwUsitWDDTvYcqNL8LhERaRMUvCRSs1eUkpVhTB/WI+pSREREQqfgJZGataKUyYO7kZuTHXUpIiIioVPwksiU7j7Ah5vKdZhRRETajFCDl5l9zcw+NLMlZvaYmeWYWXcze8XMVgafu4VZgzRfbx1aRkLBS0RE2ojQgpeZ9Qe+Akxx97FAJvBZ4DbgNXcfAbwW3Jc2aNaKUnp2bs9RfbtEXYqIiEhahH2oMQvoYGZZQEdgE3AB8HDw/MPAp0KuQZqh6hpn9opSThrRk4wMLSMhIiJtQ2jBy92LgTuBDUAJUObuLwO93b0keE0J0Ku+7c3sejObZ2bzSktLwypTIrKkuIydFZVarV5ERNqUMA81diM2unUE0A/oZGZXxLu9u9/v7lPcfUp+vv44tzazV5RiBicM7xl1KSIiImkT5qHG04G17l7q7pXAX4DpwBYz6wsQfN4aYg3STM1aUcq4/l3p0bl91KWIiIikTZjBawNwnJl1tNi1YGYAS4FngauD11wN/C3EGqQZKquoZMGGnTqbUURE2pyssBp29/fM7ClgAVAFLATuBzoDT5jZdcTC2SVh1SDN0zurt1HjWkZCRETantCCF4C7fx/4fp2HDxAb/ZI2avaKUnJzspg4MC/qUkRERNJKK9dLWrk7s1aUcsLwnmRlqvuJiEjbor98klYrt+6hpGy/DjOKiEibpOAlaTV7RWxNtpMUvEREpA1S8JK0mrWilJG9O9Mvr0PUpYiIiKSdgpekTcXBKt5bs4OTRmi0S0RE2iYFL0mb99bs4GB1jS4TJCIibZaCl6TNrBWl5GRncMyQ7lGXIiIiEgkFL0mb2StKmTa0BznZmVGXIiIiEgkFL0mLjTsqWLNtr85mFBGRNk3BS9JiVrCMhNbvEhGRtkzBS9Ji1opSBnbvwBE9O0VdioiISGQUvCR0B6tqmLNqGyeNyMfMoi5HREQkMgpeErr563ey92C1DjOKiEibp+AloZu9spSsDGP68J5RlyIiIhIpBS8J1YGqal5buoUpQ7rRuX1W1OWIiIhESsFLQlNQtIvz7nmbFVv2cNHkAVGXIyIiEjkNQUjKHaiq5p7XVnHvrNXkd27PQ9ccw6mjekVdloiISOQUvCSllhSX8Y0nFrN8y24+ffQAvnfuUXTtkB11WSIiIs2CgpekxMGqGn71+kp+/eZqenZux8zPT+G00b2jLktERKRZUfCSJltSXMY3n1zMss27uWhyf75/7hi6dtQol4iISF0KXpK0g1U1/OqNVfzmjVV079SOB66awulHaZRLRESkIQpekpSPNpXzjScXs7SknAsn9ef75x1FXsd2UZclIiLSrCl4SUIqq2v49Rur+NXrq+jWqR2/u2oKn9Aol4iISFwUvCRuS0vK+eaTi/lwUzkXTOzH7eeNoVsnjXKJiIjES8FLDquyuoZ731zNPa+vpGuHbH575dGcMaZP1GWJiIi0OApe0qhlm2OjXEuKyzlvQj9+cP4YumuUS0REJCkKXtKgN5dv5YuPzKNLTjb3XTGZM8f2jbokERGRFk3BSxo085119MrN4dmbj6dH5/ZRlyMiItLi6SLZUq/tew7wzqptXDCxn0KXiIhIiih4Sb1eWrKZ6hrnvAn9oi5FRESk1VDwkno9u3gTw3t1ZnSf3KhLERERaTVCC15mNsrMFtX6KDezW83sdjMrrvX42WHVIMkpKdvHB+t2cP6EfphZ1OWIiIi0GqFNrnf35cBEADPLBIqBZ4BrgLvd/c6w9i1N80JBCe5w7nidxSgiIpJK6TrUOANY7e7r07Q/aYLnFm9ibP8uDM3vHHUpIiIirUq6gtdngcdq3b/ZzArMbKaZdUtTDRKH9dv3sriojPPGa1K9iIhIqoUevMysHXA+8GTw0L3AMGKHIUuAuxrY7nozm2dm80pLS8MuUwLPF5QAcK7OZhQREUm5dIx4nQUscPctAO6+xd2r3b0G+B0wtb6N3P1+d5/i7lPy8/PTUKYAPLtoE1MGd6N/XoeoSxEREWl10hG8LqPWYUYzqz1j+0JgSRpqkDgs37yb5Vt2a+0uERGRkIR6ySAz6wh8AvhSrYd/amYTAQfW1XlOIvR8wSYyDM4ep7MZRUREwhBq8HL3CqBHnceuDHOfkhx357nFm5g+rCf5ubpEkIiISBi0cr0AUFhcxrrtFZw3QaNdIiIiYVHwEiC2dld2pnHmGAUvERGRsCh4CTU1zvMFJZw8Mp+uHbOjLkdERKTVUvAS5q3fSUnZfp3NKCIiEjIFL+G5xZvIyc7g9CN7R12KiIhIq6bg1cZVVdfwYmEJM47sTaf2oZ7kKiIi0uYpeLVxc1ZvZ/veg7o2o4iISBooeLVxzy3eROf2WZwySpdlEhERCZuCVxt2oKqav3+4mU+O6U1OdmbU5YiIiLR6Cl5t2KzlpezeX8X5OptRREQkLRS82rDnCkro1jGb44f3jLoUERGRNkHBq42qOFjFqx9t4axxfcnOVDcQERFJB/3FbaNeW7qVfZXVOswoIiKSRocNXmZ2rpkpoLUyzy7eRO8u7TlmSPeoSxEREWkz4glUnwVWmtlPzezIsAuS8JXtq2TW8lLOGdePzAyLuhwREZE247DBy92vACYBq4GHzOxdM7vezHJDr05C8fKHmzlYXcP5E3WYUUREJJ3iOoTo7uXA08Cfgb7AhcACM7slxNokJM8u3sTA7h2YMKBr1KWIiIi0KfHM8TrPzJ4BXgeyganufhYwAfhmyPVJim3bc4A5q7dz3vh+mOkwo4iISDrFc1XkS4C73X127QfdvcLMrg2nLAnLS0s2U13jnKezGUVERNIunuD1faDk0B0z6wD0dvd17v5aaJVJKJ5btIkRvTozuo+m6ImIiKRbPHO8ngRqat2vDh6TFqakbB/vr9vBeRN0mFFERCQK8QSvLHc/eOhOcLtdeCVJWF4oiA1c6jCjiIhINOIJXqVmdv6hO2Z2AbAtvJIkLM8u3sS4/l05omenqEsRERFpk+IJXjcA3zGzDWa2Efg28KVwy5JUW7dtLwVFZZw3oW/UpYiIiLRZh51c7+6rgePMrDNg7r47/LIk1Z4v2ATAOeN1mFFERCQq8ZzViJmdA4wBcg5Nynb3/wmxLkmx5xaXMGVwN/rndYi6FBERkTYrngVU7wMuBW4BjNi6XoNDrktSaPnm3SzfsluXCBIREYlYPHO8prv7VcBOd/8BMA0YGG5ZkkrPLd5EhsFZYzW/S0REJErxBK/9wecKM+sHVAJHhFeSpJK781zBJqYP60l+bvuoyxEREWnT4glez5lZHvAzYAGwDngsxJokhQqKyli/vYLztXaXiIhI5BqdXG9mGcBr7r4LeNrMngdy3L0sHcVJ0z23eBPZmcYZY/pEXYqIiEib1+iIl7vXAHfVun9AoavlqKlxni8o4eSR+XTtmB11OSIiIm1ePIcaXzaziy3Bi/uZ2SgzW1Tro9zMbjWz7mb2ipmtDD53S7J2OYwP1u1gc/l+XSJIRESkmYgneH2d2EWxDwThabeZlR9uI3df7u4T3X0icDRQATwD3Ebs8OUI4LXgvoTguYJN5GRncPqRvaMuRURERIgjeLl7rrtnuHs7d+8S3O+S4H5mAKvdfT1wAfBw8PjDwKcSbEviUFVdw4uFm5lxZG86tY9rnVwREREJ2WH/IpvZSfU97u6zE9jPZ/nnmZC93b0kaKPEzHo1sN/rgesBBg0alMCuBGDO6u3s2HuQ83SJIBERkWYjnqGQb9W6nQNMBeYDp8WzAzNrB5wP/Gcihbn7/cD9AFOmTPFEthV4dvEmcttnccqo/KhLERERkUA8F8k+r/Z9MxsI/DSBfZwFLHD3LcH9LWbWNxjt6gtsTaAticOyzeW8WFjCWWP7kpOdGXU5IiIiEohncn1dRcDYBF5/Gf+64OqzwNXB7auBvyVRgzSgeNc+rp75Prk5WXz9kyOjLkdERERqiWeO1z3AoUN9GcBEYHE8jZtZR+ATwJdqPXwH8ISZXQdsIHbRbUmBXRUHuXrm+1QcrObJG6bRP69D1CWJiIhILfHM8ZpX63YV8Ji7vxNP4+5eAfSo89h2Ymc5Sgrtr6zmuofnsWF7BY9cN5XRfRI98VRERETCFk/wegrY7+7VAGaWaWYdg1AlzUBVdQ23PLaQBRt28uvLJ3Pc0B6H30hERETSLp45Xq8BtY9ZdQBeDaccSZS7872/fcgrH23h9vPGcPa4vlGXJCIiIg2IJ3jluPueQ3eC2x3DK0kS8cvXVvHY+xu46ZRhXD19SNTliIiISCPiCV57zWzyoTtmdjSwL7ySJF6Pvb+Bu19dwcWTB/CtM0ZFXY6IiIgcRjxzvG4FnjSzTcH9vsCloVUkcXnloy1895lCTh6Zzx0XjyPBa5iLiIhIBOJZQPUDMxsNjAIMWObulaFXJg2av34ntzy2gHH9u/Kbz00mOzOZ5dhEREQk3Q77F9vMvgx0cvcl7l4IdDazm8IvTeqzausernv4A/p0yWHm54/RBbBFRERakHiGSr7o7rsO3XH3ncAXQ6tIGrSlfD9Xz3yfrAzjkWuPpUfn9lGXJCIiIgmIJ3hlWK0JRGaWCbQLrySpT/n+Sq6e+T67Kg7y+2umMqiHTiwVERFpaeI5TvUPYpf4uY/YpYNuAF4KtSr5Fweqqrn+kXms2rqHh645hrH9u0ZdkoiIiCQhnuD1beB64EZik+sXEjuzUdKgpsb5+hOLmbtmBz+/dCInjsiPuiQRERFJ0mEPNbp7DTAXWANMIXadxaUh1yXEVqX/4Qsf8UJBCd85ezSfmtQ/6pJERESkCRoc8TKzkcBngcuA7cDjAO5+anpKk/tnr+Ghd9Zx7fFH8MUTh0ZdjoiIiDRRY4calwFvAee5+yoAM/taWqoS/rKgiB+/tIxzx/flv845UgukioiItAKNHWq8GNgMvGFmvzOzGcTmeEnIZq0o5T+eKmDa0B7c9ZkJZGTobRcREWkNGgxe7v6Mu18KjAbeBL4G9Daze83sk2mqr81ZWlLOjX+cz4jeufz2qqNpn5UZdUkiIiKSIvFMrt/r7o+6+7nAAGARcFvYhbVVd728nPZZGTx8zTF0ycmOuhwRERFJoYQu8ufuO9z9t+5+WlgFtWWrS/fw6tKtXDltCL265ERdjoiIiKSYrq7cjMx8ey3tsjK4atrgqEsRERGRECh4NRM79h7kqflFXDSpPz11DUYREZFWScGrmfjj3PUcqKrhuhOOiLoUERERCYmCVzOwv7KaR95dxymj8hnROzfqckRERCQkCl7NwN8WFbNtz0GtTi8iItLKKXhFzN154K21HNm3C9OH9Yi6HBEREQmRglfEZq0oZeXWPXzhhCN0WSAREZFWTsErYg+8tZbeXdpz3oR+UZciIiIiIVPwitBHm8p5e9U2rp4+hHZZ+laIiIi0dvprH6EH315Lh+xMPjdVC6aKiIi0BQpeEdlSvp9nFxfzmSkD6NpR12QUERFpCxS8IvLwnHVU1TjXasFUERGRNkPBKwIVB6t49L0NnHFUHwb36BR1OSIiIpImoQYvM8szs6fMbJmZLTWzaWZ2u5kVm9mi4OPsMGtojp6cV0TZvkq+eJJGu0RERNqSrJDb/wXwd3f/tJm1AzoCZwB3u/udIe+7WaqucWa+s5ZJg/I4enD3qMsRERGRNAptxMvMugAnAQ8CuPtBd98V1v5ailc+2sL67RV84QRdHkhERKStCfNQ41CgFHjIzBaa2QNmdmhC081mVmBmM82sW4g1NDsPvLWGAd06cMaY3lGXIiIiImkWZvDKAiYD97r7JGAvcBtwLzAMmAiUAHfVt7GZXW9m88xsXmlpaYhlps/CDTuZt34n1x5/BFmZOq9BRESkrQnzr38RUOTu7wX3nwImu/sWd6929xrgd8DU+jZ29/vdfYq7T8nPzw+xzPR54O215OZk8ZljBkZdioiIiEQgtODl7puBjWY2KnhoBvCRmfWt9bILgSVh1dCcbNxRwUuFJVw+dRCd24d9ToOIiIg0R2EngFuAR4MzGtcA1wC/NLOJgAPrgC+FXEOz8NA768gw4/PHD4m6FBEREYlIqMHL3RcBU+o8fGWY+2yOyvZV8vgHGzh3fF/6du0QdTkiIiISEc3wToPHP9jA3oPVfOFELSEhIiLSlil4hayyuoaH3lnHtKE9GNu/a9TliIiISIQUvEL2YmEJJWX7+cKJujyQiIhIW6fgFSJ353dvrWFofidOHdUr6nJEREQkYgpeIZq7ZgdLisv5wglDyciwqMsRERGRiCl4hejBt9fQvVM7LprcP+pSREREpBlQ8ArJ6tI9vLp0K1ccN5ic7MyoyxEREZFmQMErJA++vZZ2WRlcNW1w1KWIiIhIM6HgFYLtew7w9PwiLprUn56d20ddjoiIiDQTCl4hePS9DRyoqtESEiIiIvIvFLxSbH9lNY+8u45TR+UzvFdu1OWIiIhIM6LglWJ/W1TMtj0HdXkgERER+TcKXink7jzw1lqO7NuF6cN6RF2OiIiINDMKXin05opSVm7dwxdPPAIzLZgqIiIi/0rBK4UefGstvbu059zx/aIuRURERJohBa8U2XugindWb+OSowfSLktvq4iIiPw7JYQU+XBTOe4weXBe1KWIiIhIM6XglSIFRbsAGNu/a7SFiIiISLOl4JUiBUVl9O2aQ6/cnKhLERERkWZKwStFCovLGD9Ao10iIiLSMAWvFCjbV8nabXsZPyAv6lJERESkGVPwSoEPi8sAGKf5XSIiItIIBa8UKFDwEhERkTgoeKVAYVEZA7t3oFundlGXIiIiIs2YglcKLC7axfj+eVGXISIiIs2cglcT7dh7kKKd+3RGo4iIiByWglcTFR6a36XgJSIiIoeh4NVEhVqxXkREROKk4NVEBUVlDO3ZiS452VGXIiIiIs2cglcTFRaX6TCjiIiIxEXBqwm27t5PSdl+rVgvIiIicVHwaoLCotjEep3RKCIiIvEINXiZWZ6ZPWVmy8xsqZlNM7PuZvaKma0MPncLs4YwFRSVkWFwVN8uUZciIiIiLUDYI16/AP7u7qOBCcBS4DbgNXcfAbwW3G+RCovLGN6rM53aZ0VdioiIiLQAoQUvM+sCnAQ8CODuB919F3AB8HDwsoeBT4VVQ5jcnYKiMsZpxXoRERGJU5gjXkOBUuAhM1toZg+YWSegt7uXAASfe9W3sZldb2bzzGxeaWlpiGUmZ3P5frbtOaD5XSIiIhK3MINXFjAZuNfdJwF7SeCworvf7+5T3H1Kfn5+WDUmbfFGTawXERGRxIQZvIqAInd/L7j/FLEgtsXM+gIEn7eGWENoCot3kZVhHKmJ9SIiIhKn0IKXu28GNprZqOChGcBHwLPA1cFjVwN/C6uGMBUUlTGydy452ZlRlyIiIiItRNin490CPGpm7YA1wDXEwt4TZnYdsAG4JOQaUs7dKSwu48wxfaIuRURERFqQUIOXuy8CptTz1Iww9xu2op372FVRqUsFiYiISEK0cn0SCg6tWK+lJERERCQBCl5JKCjaRbvMDEb1yY26FBEREWlBFLySUFBUxpF9c2mXpbdPRERE4qfkkKCaGmdJcZnmd4mIiEjCFLwStG77XnYfqNL8LhEREUmYgleCCotjE+s14iUiIiKJUvBKUEFRGTnZGYzo1TnqUkRERKSFUfBKUEHRLsb060pWpt46ERERSYzSQwKqa5wlxeWM66/DjCIiIpI4Ba8ErC7dw77KasZrfpeIiIgkQcErAR+vWK/gJSIiIklQ8EpAYdEuOrXL5IiemlgvIiIiiVPwSkBBcRlj+nclM8OiLkVERERaIAWvOFVW1/DRpnIm6DCjiIiIJEnBK04rtuzmQFUN4wbkRV2KiIiItFAKXnEqPDSxXktJiIiISJIUvOJUUFxGbk4Wg3t0jLoUERERaaEUvOJUWFTG+AFdMdPEehEREUmOglccDlRVs2xzOeP650VdioiIiLRgCl5xWFaym8pq1xmNIiIi0iQKXnEoKI5NrB+n4CUiIiJNoOAVh8KiXXTv1I7+eR2iLkVERERaMAWvOBQUlTGuvybWi4iISNMoeB3GvoPVrNy6RxfGFhERkSZT8DqMj0rKqa5xxmnhVBEREWkiBa/DKCjaBcCEgXmR1iEiIiItn4LXYRQWldErtz29u+REXYqIiIi0cApeh1FQXKb5XSIiIpISCl6N2HOgitWle7RivYiIiKSEglcjPiwuwx2NeImIiEhKKHg1olAr1ouIiEgKKXg1YnFRGf3zOtCzc/uoSxEREZFWINTgZWbrzKzQzBaZ2bzgsdvNrDh4bJGZnR1mDU1RWLRL63eJiIhIymSlYR+nuvu2Oo/d7e53pmHfSSurqGTd9goumTIw6lJERESkldChxgYs2RSb36WJ9SIiIpIqYQcvB142s/lmdn2tx282swIzm2lm3erb0MyuN7N5ZjavtLQ05DL/XUFRMLFehxpFREQkRcIOXse7+2TgLODLZnYScC8wDJgIlAB31behu9/v7lPcfUp+fn7IZf67wuJdDO7RkbyO7dK+bxEREWmdQg1e7r4p+LwVeAaY6u5b3L3a3WuA3wFTw6whWYs3lmm0S0RERFIqtOBlZp3MLPfQbeCTwBIz61vrZRcCS8KqIVnb9xygeNc+ze8SERGRlArzrMbewDNmdmg/f3L3v5vZH8xsIrH5X+uAL4VYQ1I+XjhVlwoSERGRFAoteLn7GmBCPY9fGdY+U6UwmFg/tn+XiCsRERGR1kTLSdSjoLiMofmdyM3JjroUERERaUUUvOpRULSLCQPyoi5DREREWhkFrzq2lO9nS/kBndEoIiIiKafgVceh+V06o1FERERSTcGrjoLiMjIMjuqnifUiIiKSWgpedRQW7WJEr1w6tkvH9cNFRESkLVHwqsXdKSwuY5wOM4qIiEgIFLxq2VS2n217DjJBwUtERERCoOBVS2HRLgDGaSkJERERCYGCVy0FRWVkZRij++RGXYqIiIi0QgpetRQWlzGqTy452ZlRlyIiIiKtkIJXwN0pKCrT+l0iIiISGgWvwMYd+yjbV8m4/nlRlyIiIiKtlIJXYHEwsV4jXiIiIhIWBa9AYXEZ7bIyGNlbE+tFREQkHApegYKiXRzZtwvtsvSWiIiISDiUMoCaGmdJcTnj++swo4iIiIRHwQtYu30vew5U6VJBIiIiEioFL6CwqAzQxHoREREJl4IXkJOdwbFHdGd4fueoSxEREZFWLCvqApqDM8f25cyxfaMuQ0RERFo5jXiJiIiIpImCl4iIiEiaKHiJiIiIpImCl4iIiEiaKHiJiIiIpImCl4iIiEiaKHiJiIiIpImCl4iIiEiaKHiJiIiIpImCl4iIiEiaKHiJiIiIpImCl4iIiEiaKHiJiIiIpIm5e9Q1HJaZlQLrQ95NT2BbM2lHtagW1aJaVItqUS3Nt5bDGezu+fU+4+76iIXPec2lHdWiWlSLalEtqqU5tKNaUv+hQ40iIiIiaaLgJSIiIpImCl7/dH8zake1hNdGqtpRLeG1kap2VEt4baSqHdUSXhupake1pFiLmFwvIiIi0hpoxEtEREQkTRS8ADM708yWm9kqM7styTZmmtlWM1vShDoGmtkbZrbUzD40s68m0UaOmb1vZouDNn6QbD1Be5lmttDMnk9y+3VmVmhmi8xsXhPqyDOzp8xsWfD+TEtw+1FBDYc+ys3s1iRr+Vrw3i4xs8fMLCeJNr4abP9hInXU18/MrLuZvWJmK4PP3ZJo45Kglhozm9KEWn4WfI8KzOwZM8tLoo0fBtsvMrOXzaxfMrXUeu6bZuZm1jOJWm43s+Ja/ebsZGsxs1uC3zMfmtlPk6jl8Vp1rDOzRcnUYmYTzWzuoZ9JM5uaRBsTzOzd4Gf7OTPrEkct9f5+S6T/NtJGQv23kXbi7r+NtJFQ/22onVrPH7b/NlJL3P23sToS7LsN1RJ3/22kjUT7bkPtJNx/UyrKUyqbwweQCawGhgLtgMXAUUm0cxIwGVjShFr6ApOD27nAikRrAQzoHNzOBt4DjmtCTV8H/gQ8n+T264CeKfg+PQx8IbjdDshr4vd8M7F1VhLdtj+wFugQ3H8C+HyCbYwFlgAdgSzgVWBEsv0M+ClwW3D7NuAnSbRxJDAKeBOY0oRaPglkBbd/kmQtXWrd/gpwXzK1BI8PBP5BbB3ARvthA7XcDnwzwe9vfe2cGnyf2wf3eyXz9dR6/i7gv5Os5WXgrOD22cCbSbTxAXBycPta4Idx1FLv77dE+m8jbSTUfxtpJ+7+20gbCfXfhtpJpP82Ukvc/beRNhLtu4f9O3a4/ttILYn23YbaSbj/pvJDI14wFVjl7mvc/SDwZ+CCRBtx99nAjqYU4u4l7r4guL0bWErsD30ibbi77wnuZgcfSU3kM7MBwDnAA8lsnyrBfyMnAQ8CuPtBd9/VhCZnAKvdPdlFebOADmaWRSw8bUpw+yOBue5e4e5VwCzgwng2bKCfXUAsmBJ8/lSibbj7UndfHk8Nh2nn5eBrApgLDEiijfJadzsRR/9t5OfvbuA/mthGQhpo50bgDnc/ELxma7K1mJkBnwEeS7IWBw79h9+Vw/TfBtoYBcwObr8CXBxHLQ39fou7/zbURqL9t5F24u6/jbSRUP89zO/9uPpviv52NNRGon230Vri6b+NtJFo322onYT7byopeMW+CRtr3S8iwQ4bBjMbAkwiNmKV6LaZwTDuVuAVd0+4jcDPif3Q1yS5PcR+UF42s/lmdn2SbQwFSoGHLHbY8wEz69SEmj5LHH+06uPuxcCdwAagBChz95cTbGYJcJKZ9TCzjsT+cxuYTD2B3u5eEtRXAvRqQlupdC3wUjIbmtn/M7ONwOeA/06yjfOBYndfnMz2tdwcHDqa2dhhsMMYCZxoZu+Z2SwzO6YJ9ZwIbHH3lUlufyvws+D9vRP4zyTaWAKcH9y+hAT7b53fb0n136b8joyznbj7b902ku2/tdtJtv/W8/Uk3H/rtJF0323gvU2o/9Zp41aS7Lt12mlS/20qBa/Yobm6Ij3V08w6A08Dt9b57yku7l7t7hOJ/bc21czGJlHDucBWd5+f6LZ1HO/uk4GzgC+b2UlJtJFF7FDHve4+CdhL7JBEwsysHbEfuCeT3L4bsf/QjwD6AZ3M7IpE2nD3pcQOY7wC/J3Y4e2qRjdqYczsu8S+pkeT2d7dv+vuA4Ptb05i/x2B75JkaKvlXmAYMJFY0L4ryXaygG7AccC3gCeC//yTcRlJ/uMQuBH4WvD+fo1gJDlB1xL7eZ5P7BDOwXg3bOrvt1S10Vg7ifTf+tpIpv/WbifYd8L9t55aEu6/9bSRVN9t5HsUd/+tp42k+m497STdf1MiHcczm/MHMA34R637/wn8Z5JtDaEJc7yCNrKJHdP/eoq+vu+T4ByVYLsfExv9W0dsPlQF8Mcm1nJ7krX0AdbVun8i8EKSNVwAvNyEr+ES4MFa968CftPE9+V/gZuS7WfAcqBvcLsvsDzRNmo9/iZxzvFqqB3gauBdoGOybdR6bnC8P1O12wHGERvxXRd8VBEbpezThFri/vmu53v0d+CUWvdXA/lJvLdZwBZgQBP6Sxn/XErIgPImfo9GAu/HWcu//X5LtP/W10Yy/behdhLpv43Vkkj/rdtOMv03jloO238b+P4k03cbem/j7r8N1JJM3z3c+xJ3/03Vh0a8YpPsRpjZEcFoyGeBZ6MoJPgv4kFgqbv/X5Jt5FtwJo6ZdQBOB5Yl2o67/6e7D3D3IcTek9fdPaGRHTPrZGa5h24Tm7ia8Fmf7r4Z2Ghmo4KHZgAfJdpOoKmjBRuA48ysY/D9mkFs3kBCzKxX8HkQcFETa3qW2B8Lgs9/a0JbTWJmZwLfBs5394ok2xhR6+75JNd/C929l7sPCfpwEbFJtpsTrKVvrbsXkkT/DfwVOC1ocySxE0SSuUjv6cAydy9Ksg6IzYs5Obh9GpDwIcta/TcD+C/gvji2aej3W9z9NxW/IxtrJ5H+20gbCfXf+tpJtP82Ukvc/beR9/avJNB3D/M9iqv/NtJGQn23kfcl4f6bUulMec31g9gcmxXEkvx3k2zjMWJDuZXEfkiuS6KNE4gd5iwAFgUfZyfYxnhgYdDGEuI48ymONk8hibMaic3NWhx8fJjsexu0NRGYF3xdfwW6JdFGR2A70LWJ78cPiP0yXQL8geBsnwTbeItYeFwMzGhKPwN6AK8R+yX0GtA9iTYuDG4fIPYf6T+SrGUVsTmTh/rv4c7oqq+Np4P3tgB4jtiE5YRrqfP8Og5/VmN9tfwBKAxqeZZgZCaJdtoBfwy+rgXAacl8PcDvgRua2F9OAOYHfe894Ogk2vgqsd+ZK4A7CEYhDtNOvb/fEum/jbSRUP9tpJ24+28jbSTUfxtqJ5H+20gtcfffRtpItO82+PUQZ/9tpJZE+25D7STcf1P5oZXrRURERNJEhxpFRERE0kTBS0RERCRNFLxERERE0kTBS0RERCRNFLxERERE0kTBS0RaDDPbE3weYmaXp7jt79S5PyeV7YuIgIKXiLRMQ4CEgpeZZR7mJf8SvNx9eoI1iYgcloKXiLREdxC7cO8iM/tacGH4n5nZB8EFgb8EYGanmNkbZvYnYgtJYmZ/tdhF2z+04MLtZnYH0CFo79HgsUOjaxa0vcTMCs3s0lptv2lmT5nZMjN7tAnXXxSRNiIr6gJERJJwG7Hrfp4LEASoMnc/xszaA++Y2cvBa6cCY919bXD/WnffEVxS6wMze9rdbzOzmz12cfm6LiJ25YQJQM9gm9nBc5OAMcQuZfIOcDzwdqq/WBFpPTTiJSKtwSeBq8xsEbFLifQADl0z7/1aoQvgK2a2GJgLDKz1uoacADzm7tXuvgWYBRxTq+0id68hdjmSISn4WkSkFdOIl4i0Bgbc4u7/+JcHzU4B9ta5fzowzd0rzOxNICeOthtyoNbtavQ7VUQOQyNeItIS7QZya93/B3CjmWUDmNlIM+tUz3ZdgZ1B6BoNHFfrucpD29cxG7g0mEeWD5wEvJ+Sr0JE2hz9dyYiLVEBUBUcMvw98Atih/kWBBPcS4FP1bPd34EbzKwAWE7scOMh9wMFZrbA3T9X6/FngGnAYsCB/3D3zUFwExFJiLl71DWIiIiItAk61CgiIiKSJgpeIiIiImmi4CUiIiKSJgpeIiIiImmi4CUiIiKSJgpeIiIiImmi4CUiIiKSJgpeIiIiImny/wFbEpPMiq3L+QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.title(\"Validation accuracy\")\n",
    "plt.xticks(range(iteration))\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.plot(model_log['validation_accuracy'][0]);\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "44617e89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "plt.title(\"Training loss\")\n",
    "plt.xticks(range(iteration))\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.plot(model_log['training_loss'][0]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e0e22b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez(\"iter30_vivit_toy\", \n",
    "         validation=model_log['validation_accuracy'][0], \n",
    "         training=y))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}