MobiAct_GRU_Classification_transferLearning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:01:14.428949Z",
     "start_time": "2020-07-28T11:01:13.764893Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tqdm\n",
    "import collections \n",
    "import time\n",
    "import glob\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from torch.optim.lr_scheduler import _LRScheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:01:15.383236Z",
     "start_time": "2020-07-28T11:01:15.373221Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda:0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:01:17.583089Z",
     "start_time": "2020-07-28T11:01:17.580313Z"
    }
   },
   "outputs": [],
   "source": [
    "fall_data_dir = \"/workspace/inkyung/Fall Detection/Mobidata_resampled(Smartfall)/fall/*.csv\"\n",
    "adl_data_dir = \"/workspace/inkyung/Fall Detection/Mobidata_resampled(Smartfall)/adl/*.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprecessing\n",
    "\n",
    "- sliding window size of 40\n",
    "- if data contains all fall samples(30 samples) then label as 'FALL'\n",
    "- unless, it's all labelled as 'ADL'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:01:46.616043Z",
     "start_time": "2020-07-28T11:01:42.862836Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "08b560922d5e4b0b9d4ca9f37c5d0cfe",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=767.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ADL\n",
      "ADL\n",
      "ADL\n",
      "ADL\n",
      "ADL\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n = 40\n",
    "fall_X_list, fall_y_list = list(), list()\n",
    "for file in tqdm.notebook.tqdm(glob.glob(fall_data_dir)):\n",
    "    data = pd.read_csv(file)\n",
    "    for i in range(0, len(data) - 40):\n",
    "        temp = list()\n",
    "        temp.append(data['acc_x'][i : i + n])\n",
    "        temp.append(data['acc_y'][i : i + n])\n",
    "        temp.append(data['acc_z'][i : i + n])\n",
    "        \n",
    "        cnt = collections.Counter(data['label'][i: i + n])\n",
    "        num_adl = cnt[0]\n",
    "        num_fall = cnt[1]\n",
    "        if num_fall == 30:\n",
    "            fall_X_list.append(temp)\n",
    "            fall_y_list.append(1)\n",
    "        else:\n",
    "            print('ADL')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:01:58.833716Z",
     "start_time": "2020-07-28T11:01:53.186104Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3882f79de44549e68deff3aa4c3744b0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=1469.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "n = 40\n",
    "adl_X_list, adl_y_list = list(), list()\n",
    "for file in tqdm.notebook.tqdm(glob.glob(adl_data_dir)):\n",
    "    data = pd.read_csv(file)\n",
    "    for i in range(0, len(data) - 40):\n",
    "        temp = list()\n",
    "        temp.append(data['acc_x'][i : i + n])\n",
    "        temp.append(data['acc_y'][i : i + n])\n",
    "        temp.append(data['acc_z'][i : i + n])\n",
    "        \n",
    "        adl_X_list.append(temp)\n",
    "        adl_y_list.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:02:49.489270Z",
     "start_time": "2020-07-28T11:02:49.481985Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the length of fall data 7665\n",
      "the total length of X data 15330\n"
     ]
    }
   ],
   "source": [
    "# to keep the balance between ADL and FALL data, used only the part of ADL data\n",
    "\n",
    "print('the length of fall data', len(fall_X_list))\n",
    "adl_X_list = adl_X_list[:7665]\n",
    "adl_y_list = adl_y_list[:7665]\n",
    "\n",
    "X_data = fall_X_list + adl_X_list\n",
    "y_data = fall_y_list + adl_y_list\n",
    "\n",
    "print('the total length of X data', len(X_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:06.292454Z",
     "start_time": "2020-07-28T11:03:06.275954Z"
    }
   },
   "outputs": [],
   "source": [
    "# splitting data into train, validation, test set\n",
    "X_train, X_test, y_train, y_test = train_test_split(X_data, y_data, test_size=0.2, random_state=42)\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.3, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:10.664965Z",
     "start_time": "2020-07-28T11:03:08.010710Z"
    }
   },
   "outputs": [],
   "source": [
    "X_train = np.asarray(X_train).reshape(-1, 40, 3)\n",
    "y_train = np.asarray(y_train).reshape(-1, )\n",
    "\n",
    "X_valid = np.asarray(X_valid).reshape(-1, 40, 3)\n",
    "y_valid = np.asarray(y_valid).reshape(-1, )\n",
    "\n",
    "X_test = np.asarray(X_test).reshape(-1, 40, 3)\n",
    "y_test = np.asarray(y_test).reshape(-1, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:11.258212Z",
     "start_time": "2020-07-28T11:03:11.250961Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "size of X_train (8584, 40, 3)\n",
      "size of y_train (8584,)\n",
      "------------------------------\n",
      "size of X_valid (3680, 40, 3)\n",
      "size of y_valid (3680,)\n",
      "------------------------------\n",
      "size of X_test (3066, 40, 3)\n",
      "size of y_test (3066,)\n"
     ]
    }
   ],
   "source": [
    "print('size of X_train', X_train.shape)\n",
    "print('size of y_train', y_train.shape)\n",
    "print('------------------------------')\n",
    "print('size of X_valid', X_valid.shape)\n",
    "print('size of y_valid', y_valid.shape)\n",
    "print('------------------------------')\n",
    "print('size of X_test', X_test.shape)\n",
    "print('size of y_test', y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:13.497936Z",
     "start_time": "2020-07-28T11:03:13.492887Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "enc = LabelEncoder()\n",
    "\n",
    "y_train = enc.fit_transform(y_train)\n",
    "y_valid = enc.fit_transform(y_valid)\n",
    "y_test = enc.fit_transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:16.984977Z",
     "start_time": "2020-07-28T11:03:16.979724Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "\n",
    "train_data = TensorDataset(torch.from_numpy(X_train), torch.from_numpy(y_train))\n",
    "train_loader = torch.utils.data.DataLoader(train_data,\n",
    "                                           shuffle=True,\n",
    "                                           batch_size=batch_size)\n",
    "\n",
    "valid_data = TensorDataset(torch.from_numpy(X_valid), torch.from_numpy(y_valid))\n",
    "valid_loader = torch.utils.data.DataLoader(valid_data,\n",
    "                                           shuffle=True,\n",
    "                                           batch_size=batch_size)\n",
    "\n",
    "test_data = TensorDataset(torch.from_numpy(X_test), torch.from_numpy(y_test))\n",
    "test_loader = torch.utils.data.DataLoader(test_data,\n",
    "                                          shuffle=True,\n",
    "                                          batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:18.482257Z",
     "start_time": "2020-07-28T11:03:18.475762Z"
    }
   },
   "outputs": [],
   "source": [
    "class GRUNet(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, output_dim, n_layers):\n",
    "        super(GRUNet, self).__init__()\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.n_layers = n_layers\n",
    "        \n",
    "        self.GRU = nn.GRU(input_size = input_dim,\n",
    "                          hidden_size = hidden_dim, \n",
    "                          num_layers = n_layers,\n",
    "                          batch_first=True)\n",
    "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
    "        self.relu = nn.ReLU()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        h0 = self.init_hidden(x)\n",
    "        out, hn = self.GRU(x, h0)\n",
    "        out = self.fc(self.relu(out[:, -1]))\n",
    "        return out\n",
    "    \n",
    "    def init_hidden(self, x):\n",
    "        h0 = torch.zeros(self.n_layers, x.size(0), self.hidden_dim)\n",
    "        return h0.cuda()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing cyclic learning rate\n",
    "- implmenting a simple cosine scheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:43.798856Z",
     "start_time": "2020-07-28T11:03:43.791940Z"
    }
   },
   "outputs": [],
   "source": [
    "class CyclicLR(_LRScheduler):\n",
    "    \n",
    "    def __init__(self, optimizer, schedule, last_epoch=-1):\n",
    "        assert callable(schedule)\n",
    "        self.schedule = schedule\n",
    "        super().__init__(optimizer, last_epoch)\n",
    "\n",
    "    def get_lr(self):\n",
    "        return [self.schedule(self.last_epoch, lr) for lr in self.base_lrs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:44.939792Z",
     "start_time": "2020-07-28T11:03:44.935895Z"
    }
   },
   "outputs": [],
   "source": [
    "def cosine(t_max, eta_min=0):\n",
    "    \n",
    "    def scheduler(epoch, base_lr):\n",
    "        t = epoch % t_max\n",
    "        return eta_min + (base_lr - eta_min)*(1 + np.cos(np.pi*t/t_max))/2\n",
    "    \n",
    "    return scheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:45.789594Z",
     "start_time": "2020-07-28T11:03:45.656035Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f7a84e2d110>]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = 100\n",
    "sched = cosine(n)\n",
    "lrs = [sched(t, 1) for t in range(n * 4)]\n",
    "plt.plot(lrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:03:54.566173Z",
     "start_time": "2020-07-28T11:03:53.011411Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GRUNet(\n",
      "  (GRU): GRU(3, 256, num_layers=2, batch_first=True)\n",
      "  (fc): Linear(in_features=256, out_features=2, bias=True)\n",
      "  (relu): ReLU()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "input_dim = next(iter(test_loader))[0].shape[2]\n",
    "output_dim = 2\n",
    "n_layers = 2\n",
    "hidden_dim = 256\n",
    "\n",
    "lr = 0.000001\n",
    "n_epochs = 100\n",
    "iterations_per_epoch = len(test_loader)\n",
    "best_acc = 0.\n",
    "patience, trials = 15, 0\n",
    "\n",
    "model = GRUNet(input_dim, hidden_dim, output_dim, n_layers).cuda()\n",
    "print(model)\n",
    "criterion = nn.CrossEntropyLoss().cuda()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "sched = CyclicLR(optimizer, cosine(t_max=iterations_per_epoch * 2, eta_min = lr/10))\n",
    "epoch_times = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:05:26.052872Z",
     "start_time": "2020-07-28T11:04:21.418957Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1 best model saved with accuracy: 51.79%\n",
      "Epoch 2 best model saved with accuracy: 52.12%\n",
      "Epoch 3 best model saved with accuracy: 52.45%\n",
      "Epoch 4 best model saved with accuracy: 52.93%\n",
      "Epoch:   5. Loss: 1.1859. Acc.: 53.64%\n",
      "Epoch 5 best model saved with accuracy: 53.64%\n",
      "Epoch 6 best model saved with accuracy: 54.73%\n",
      "Epoch 7 best model saved with accuracy: 55.35%\n",
      "Epoch 8 best model saved with accuracy: 56.39%\n",
      "Epoch 9 best model saved with accuracy: 57.20%\n",
      "Epoch:  10. Loss: 0.6988. Acc.: 59.24%\n",
      "Epoch 10 best model saved with accuracy: 59.24%\n",
      "Epoch 11 best model saved with accuracy: 61.25%\n",
      "Epoch 12 best model saved with accuracy: 62.64%\n",
      "Epoch 13 best model saved with accuracy: 64.57%\n",
      "Epoch 14 best model saved with accuracy: 65.65%\n",
      "Epoch:  15. Loss: 1.1071. Acc.: 67.17%\n",
      "Epoch 15 best model saved with accuracy: 67.17%\n",
      "Epoch 16 best model saved with accuracy: 68.64%\n",
      "Epoch 17 best model saved with accuracy: 70.00%\n",
      "Epoch 18 best model saved with accuracy: 71.85%\n",
      "Epoch 19 best model saved with accuracy: 73.21%\n",
      "Epoch:  20. Loss: 0.1923. Acc.: 74.29%\n",
      "Epoch 20 best model saved with accuracy: 74.29%\n",
      "Epoch 21 best model saved with accuracy: 74.97%\n",
      "Epoch 22 best model saved with accuracy: 75.84%\n",
      "Epoch 23 best model saved with accuracy: 76.88%\n",
      "Epoch 24 best model saved with accuracy: 77.74%\n",
      "Epoch:  25. Loss: 1.1604. Acc.: 78.59%\n",
      "Epoch 25 best model saved with accuracy: 78.59%\n",
      "Epoch 26 best model saved with accuracy: 79.40%\n",
      "Epoch 27 best model saved with accuracy: 80.19%\n",
      "Epoch 28 best model saved with accuracy: 80.76%\n",
      "Epoch 29 best model saved with accuracy: 81.25%\n",
      "Epoch:  30. Loss: 0.3290. Acc.: 82.01%\n",
      "Epoch 30 best model saved with accuracy: 82.01%\n",
      "Epoch 31 best model saved with accuracy: 82.31%\n",
      "Epoch 32 best model saved with accuracy: 83.07%\n",
      "Epoch 33 best model saved with accuracy: 83.45%\n",
      "Epoch 34 best model saved with accuracy: 83.99%\n",
      "Epoch:  35. Loss: 0.4668. Acc.: 84.46%\n",
      "Epoch 35 best model saved with accuracy: 84.46%\n",
      "Epoch 36 best model saved with accuracy: 84.84%\n",
      "Epoch 37 best model saved with accuracy: 85.11%\n",
      "Epoch 38 best model saved with accuracy: 85.33%\n",
      "Epoch 39 best model saved with accuracy: 85.76%\n",
      "Epoch:  40. Loss: 0.3399. Acc.: 85.90%\n",
      "Epoch 40 best model saved with accuracy: 85.90%\n",
      "Epoch 41 best model saved with accuracy: 86.28%\n",
      "Epoch 42 best model saved with accuracy: 86.44%\n",
      "Epoch 43 best model saved with accuracy: 86.77%\n",
      "Epoch 44 best model saved with accuracy: 86.93%\n",
      "Epoch:  45. Loss: 0.1752. Acc.: 87.23%\n",
      "Epoch 45 best model saved with accuracy: 87.23%\n",
      "Epoch 46 best model saved with accuracy: 87.39%\n",
      "Epoch 47 best model saved with accuracy: 87.61%\n",
      "Epoch 48 best model saved with accuracy: 87.83%\n",
      "Epoch 49 best model saved with accuracy: 88.15%\n",
      "Epoch:  50. Loss: 0.1303. Acc.: 88.32%\n",
      "Epoch 50 best model saved with accuracy: 88.32%\n",
      "Epoch 51 best model saved with accuracy: 88.59%\n",
      "Epoch 52 best model saved with accuracy: 88.72%\n",
      "Epoch 53 best model saved with accuracy: 88.94%\n",
      "Epoch 54 best model saved with accuracy: 89.18%\n",
      "Epoch:  55. Loss: 0.3787. Acc.: 89.43%\n",
      "Epoch 55 best model saved with accuracy: 89.43%\n",
      "Epoch 56 best model saved with accuracy: 89.67%\n",
      "Epoch 57 best model saved with accuracy: 89.92%\n",
      "Epoch 58 best model saved with accuracy: 90.05%\n",
      "Epoch 59 best model saved with accuracy: 90.24%\n",
      "Epoch:  60. Loss: 0.2989. Acc.: 90.46%\n",
      "Epoch 60 best model saved with accuracy: 90.46%\n",
      "Epoch 61 best model saved with accuracy: 90.65%\n",
      "Epoch 62 best model saved with accuracy: 90.82%\n",
      "Epoch 63 best model saved with accuracy: 90.98%\n",
      "Epoch 64 best model saved with accuracy: 91.17%\n",
      "Epoch:  65. Loss: 0.0773. Acc.: 91.33%\n",
      "Epoch 65 best model saved with accuracy: 91.33%\n",
      "Epoch 66 best model saved with accuracy: 91.41%\n",
      "Epoch 67 best model saved with accuracy: 91.49%\n",
      "Epoch 68 best model saved with accuracy: 91.68%\n",
      "Epoch 69 best model saved with accuracy: 91.82%\n",
      "Epoch:  70. Loss: 0.2012. Acc.: 92.04%\n",
      "Epoch 70 best model saved with accuracy: 92.04%\n",
      "Epoch 71 best model saved with accuracy: 92.09%\n",
      "Epoch 72 best model saved with accuracy: 92.15%\n",
      "Epoch 73 best model saved with accuracy: 92.17%\n",
      "Epoch 74 best model saved with accuracy: 92.39%\n",
      "Epoch:  75. Loss: 0.2656. Acc.: 92.47%\n",
      "Epoch 75 best model saved with accuracy: 92.47%\n",
      "Epoch 76 best model saved with accuracy: 92.69%\n",
      "Epoch 77 best model saved with accuracy: 92.80%\n",
      "Epoch 78 best model saved with accuracy: 92.88%\n",
      "Epoch 79 best model saved with accuracy: 92.96%\n",
      "Epoch:  80. Loss: 0.0141. Acc.: 93.07%\n",
      "Epoch 80 best model saved with accuracy: 93.07%\n",
      "Epoch 81 best model saved with accuracy: 93.18%\n",
      "Epoch 82 best model saved with accuracy: 93.29%\n",
      "Epoch 83 best model saved with accuracy: 93.45%\n",
      "Epoch 84 best model saved with accuracy: 93.61%\n",
      "Epoch:  85. Loss: 0.1489. Acc.: 93.70%\n",
      "Epoch 85 best model saved with accuracy: 93.70%\n",
      "Epoch 86 best model saved with accuracy: 93.80%\n",
      "Epoch 87 best model saved with accuracy: 93.91%\n",
      "Epoch 88 best model saved with accuracy: 94.02%\n",
      "Epoch 89 best model saved with accuracy: 94.08%\n",
      "Epoch:  90. Loss: 0.2240. Acc.: 94.13%\n",
      "Epoch 90 best model saved with accuracy: 94.13%\n",
      "Epoch 91 best model saved with accuracy: 94.24%\n",
      "Epoch 92 best model saved with accuracy: 94.29%\n",
      "Epoch 93 best model saved with accuracy: 94.38%\n",
      "Epoch:  95. Loss: 0.1246. Acc.: 94.38%\n",
      "Epoch 96 best model saved with accuracy: 94.43%\n",
      "Epoch 97 best model saved with accuracy: 94.62%\n",
      "Epoch 98 best model saved with accuracy: 94.81%\n",
      "Epoch 99 best model saved with accuracy: 94.84%\n",
      "Epoch: 100. Loss: 0.2681. Acc.: 94.92%\n",
      "Epoch 100 best model saved with accuracy: 94.92%\n",
      "Total Training Time: 53.69304687600007 seconds\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "relearning the model using pretrained model by SmartFall data\n",
    "\"\"\"\n",
    "model.load_state_dict(torch.load('SmartFall_gru.pth'))\n",
    "train_loss, train_acc = list(), list()\n",
    "for epoch in range(1, n_epochs + 1):\n",
    "    start_time = time.process_time()\n",
    "    for i, (X_batch, y_batch) in enumerate(train_loader):\n",
    "        model.train()\n",
    "        X_batch = X_batch.float().cuda()\n",
    "        y_batch = y_batch.cuda()\n",
    "        optimizer.zero_grad()\n",
    "        out = model(X_batch)\n",
    "        loss = criterion(out, y_batch)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        sched.step()\n",
    "    current_time = time.process_time()\n",
    "    epoch_times.append(current_time-start_time)\n",
    "    \n",
    "    model.eval()\n",
    "    correct, total = 0, 0\n",
    "    for x_val, y_val in valid_loader:\n",
    "        x_val, y_val = [t.cuda() for t in (x_val.float(), y_val)]\n",
    "        out = model(x_val)\n",
    "        preds = F.log_softmax(out, dim=1).argmax(dim=1)\n",
    "        total += y_val.size(0)\n",
    "        correct += (preds == y_val).sum().item()\n",
    "        \n",
    "    acc = correct / total\n",
    "    \n",
    "    train_loss.append(loss.item())\n",
    "    train_acc.append(acc)\n",
    "    \n",
    "    if epoch % 5 == 0:\n",
    "        print(f'Epoch: {epoch:3d}. Loss: {loss.item():.4f}. Acc.: {acc:2.2%}')\n",
    "        \n",
    "    if acc > best_acc:\n",
    "        trials = 0\n",
    "        best_acc = acc\n",
    "        torch.save(model.state_dict(), 'SmartFall_gru_transfer_learning_to_MobiAct.pth')\n",
    "        print(f'Epoch {epoch} best model saved with accuracy: {best_acc:2.2%}')\n",
    "    else:\n",
    "        trials += 1\n",
    "        if trials >= patience:\n",
    "            print(f'Early stopping on epoch {epoch}')\n",
    "            break\n",
    "print(\"Total Training Time: {} seconds\".format(str(sum(epoch_times))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:05:26.178142Z",
     "start_time": "2020-07-28T11:05:26.054707Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmAAAAD3CAYAAAC6l+gCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXxb5ZX4/8+xLNnyvsTZnJ0kQAgQIIVSdihQSiktpcswnelGofvOrzNdQzsz32k73RcYhra0pXuhLRQo0LKUHbIQyAoJ2ePE+25JlnR+f9x7ZVmWvNuy5fN+vfxyfHXv1aME5KPznOc8oqoYY4wxxpjJk5ftARhjjDHGzDQWgBljjDHGTDILwIwxxhhjJpkFYMYYY4wxk8wCMGOMMcaYSWYBmDHGGGPMJLMAzBhjxpmI7BWRveNwHxWRR8Y+ImPMVGMBmDEznIisFJFvichGEWkWkV73+zMi8j8iclqaa9a5wUHyV0hEdonILSKyJMNz7XXPTfu4e84j7jnnD3P8tyWN4cZBzntX0nmPDOfexhgzUSwAM2aGEseXge3AJwEFfgt8Hbgd6AE+CqwXkQ9nuM2jwI3u1/8BYeD9wEYRWTGxr2CAKPBeEfFlePz97jnGGJN1+dkegDEma74ErAMOAP+kqk+kniAis4FPAOUZ7vGIqq5LOj8PuBt4PfA54D3jO+RB/QV4E/A64J7kB0TkeOAs4I/AmydxTMYYk5ZlwIyZgURkGfAFIAJcli74AlDVelX9HE5WbEiqGgduc3981TgMdSR+iZO1e3+ax7xjt2a6WEQKROTfROQFEekWkXYReUxE3pbhfBGRj4jIVnf69ZCI/EBEMgWr3nX/JCIPi0iLe912EfmCiBQM94UaY6Y/y4AZMzO9B+f//1+p6tahTlbVkUzdifu9dzQDG4NW4PfANSIyT1XrwAmsgH/FmS59Kd2FIhIA7gfOA3YAPwSKgKuB34rIGjcQTfYd4GNAHXALzuu9EjgDCOAEt6nP82PgvcBB4E53zK8GvgpcJCIXj/Dv2hgzTVkGzJiZ6Sz3+0PjeVO3/uq97o+Pj+e9h+n/cALLdycdezNQ7T6Wyadxgq/7gBNV9QZV/TBwIrAP+HcReY13svvnjwG7gdWq+jFV/TSwGqfObF7qE4jIu3H+bv4IrFTV96nqp1X1LJwauvOBTLV2xpgcYxkwY2amue73Q6kPuCsU351yuFVVv5PmPueLyDr3z1XAxcBxwDacrM6kUtXHRWQ7cK2I/LeqKs70YwtwB7Agw6XvxVmE8KnkDJSq1ovIV3GmLq8FnnQf8mrb/lNVm5POD4nIvwMPp3mOj+MuFFDVnpTHvgp8BPhn4LvDfsHGmGnLAjBjZiZvmlDTPLYE+HLKsX04U26pznO/kj0PnK+qbWMZ4BjcCnwTuFBE9gEXAN93g6MBJ4tIKbAcOKSqO9Lcz8sSnpJ07FT3+6Npzn+MlNWWIlIEnAw0Ap9INw6cFaTHZ3hNxpgcYwGYMTNTHU6mqjb1AVV9BDdAE5F8Bq/lulFV17mrH2uBz+BMzf1ORC5zi/KTeT8PVv7gPZZ67XD9HPgvnIzVPpzXMtj0o1c0X5fhce94RZprjqaerKoxEWlKOVzpjqOGgcGtMWYGshowY2Ymb9XjReNxM1WNq+oBVf048AfgEpwptVReVqx6kNvNcr+3jnIsjfS1m3gv8JSqbhnkEm9MczM8Pi/lvOQ/z0k92a2DS3193vmbVFUG+xpknMaYHGIBmDEz020402RXuz2yxtOncabTviQiZSmPbXa/n5nuQhGpBla41+8cwxj+DyjAyTgNlv1CVTtwiulrMzSPvcD9vjHpmPfn1OlXgHNImV1Q1U5gK3CCiFQNOXpjTM6zAMyYGUhVdwP/gdMu4b7kFX4pKjIcH+ze+3GCnmqcYCzZbe73G0SkX0G8O435DZzg5deqGh7pcyd5GKclxJuB3wzj/J/gTBF+I7mTvojMAr6YdI7nNvf755MDKhEpBP5fhuf4Fs7f909EZMDfq4hUisipAy8zxuQiqwEzZub6Ck7Q8UXgCRHZADwLNOMEXkuA17rn/mOE9/4v4H3AJ0Xk++60IKr6iIh8DfgssE1E/oxTp1VG/xWUnxnD68Jd/XjXCC75H+AynKBts4jci9MH7K3AbODrqppoq6GqT4jI93G2atoiIn+grw9YC2nqyVT1J+6+mh8CdovI/cB+nNWjS4FzgZ8CHxjhyzXGTEMWgBkzQ7lByjoR+TXOL/0LgGuAYsCblrsJ+IWqbsx4o/T3rhORm4BPAf9OUiZMVf9NRB5zn/NinExZD86U4+eB76pq1xhf3oioakRELnbHew1OYBXFmTL9hKr+Os1lH8dp7Pph4HqgCaf27HP0TbWmPs+HReQ+nNf+WpxAtxknEPsGzh6cxpgZQJz3YGOMMcYYM1msBswYY4wxZpJZAGaMMcYYM8ksADPGGGOMmWQWgBljjDHGTDILwIwxxhhjJpkFYMYYY4wxk8wCMGOMMcaYSWYBmDHGGGPMJLMAzBhjjDFmklkAZowxxhgzySwAM8YYY4yZZBaAGWOMMcZMMgvAzJiJiIqI7epujJlQIvJ57/1GRI7N9niMGQsLwIwxxkx5IiLA+wDvw977szgcY8bMAjBjjDHTwSXAUuBnwFHgXSISyO6QjBk9C8DMpBORi0TkryLSLCIhEXlJRP5bRMrTnLtMRG4RkV0i0uNe86KI3Cwi1UnnBUTkYyKyUURaRKRbRPaKyJ9F5LWT+wqNMRPAy3j9H/BLYBbw5nQniohPRD4gIk+ISJv73rFLRG4VkRWjOVdEbnOnPpekeb7z3cfWpRx/xD0eEJEvichOEQmLyG3u4+UicoOIPCQiB0UkIiINInKXiLw601+EiBwnIj9x3+PCIlIvIo+JyAfdxyvd98DdbuYw3T3+4o7ttEzPYyZWfrYHYGYWEbkeuAnoAn4P1APnA58FrhCRs1S11T13HvAcUAbcC9wBFOJ8Cv4X4AdAk3vr24B/ArYAPwd6gPnA2cDrgL9N+IszxkwIEZkDvBF4SVWfFJF24FPAdcBvU84NAPcArwUOAL8C2oElOAHb48DLIz13jO4AXgXcB/wJ530P4HjgP4F/uONoARa5r/UyEblCVf+a8voux3nvLAD+CvwaqABOBv4/4CZVbRGR3wDvcV/bgyn3WIDzvrhBVTeMw+szo2ABmJk0IrIY+B7QCZyuqjuSHvsR8EHg6zhvqgBXA1XAJ1T1uyn3Kgbi7p/LgXcAG4AzVDWWcm41xpjp7D2AH+eDFqq6RUQ2AheIyHJV3ZV07jqcoONu4K2qGvYeEJECnA90ozl3LBYDq1W1MeX4dmB+6nE3QHoW+DZOkOUdn4UTJOYDF6rqo2mu8/wI5+/telICMOBawAf872hfkBk7m4I0k+mdQAD4QXLw5fo80AH8i/vGl6wn9Uaq2qWq3nEFBAjjBmUp5zalHjPGTA/uFNq1OP9v/zzpodtw/r+/NulcH/AhnPeMDyQHVACqGlbVhpGeOw6+mCb4QlXbMhw/CPwBOE5EFiU99C6coPCm1OAr6Trvz+uB9cCVIjLXO+6+7vfhvN/+evQvyYyVBWBmMp3qfn8o9QFVbQE24UwxHucevgsnW/ZDEblDRK4TkRNSaxpUtR3nE+xrgOfdWosLRKRool6IMWbSXAgcAzyoqoeSjv8KiADvFhG/e+w4oBx4QVUPD3HfkZw7Vs9mekBEzhKR34nIAbeey2vr81H3lNqk0726sPuG+bw/wsmWvTfp2OuBBcDtqto5zPuYCWABmJlMXpF9XYbHveMVAKq6DzgduBNnmuB/cWq89onIx1KufTtwIxB0vz8ENInIL9z6EWPM9OSVJNyWfNDNbN8NzAGudA9XuN+TA7VMRnLuWB1Jd1BE3oxT/3U5TgnFD4Cv4ryHeRmu5BmBkY75Nzh1Ze8XEe/3/fXud5t+zDILwMxkanO/z83w+LyU81DV7ar6dqAaWAv8G85/t98VkfclndejqutUdSVOEes7cQpo34mTyjfGTDMiUgO8yf3x19LXhNXLEr3FfcwL0lrd78lZo0xGci70lTekq52uSHMsQVUzNar+Kk4Wb62qvklVP62qX1LVdcDONOePaMxumcZtOIsKLkkqvn9GVTcP5x5m4lgAZibTJvf7+akPiEgFsAYI4RSm9qOqUVXdoKpfw1ntCH1vzKnnHlDVXwKX4qxgOtsK8Y2Zlt6FUze6Afhxhq8G4LUishTYgROknCQi84e490jOBSeTBLAwzWNrh3F9OsuBbara7z3PzVadneb8p93vl43gOW7CqZO9Hiu+n1IsADOT6XagF/ioiCxPeeyrOMWlt3vFsCJyeobpQ+9Yt3tejYickea8YqAUiOJ8yjTGTC9egf2HVPXadF84wYQA17oroH+EU4pwc+qCHrcfVw3ASM51eXVc708570Tg46N8fXuBFckBoFvj+mVgVZrzf4bTJuODInJu6oMpqyABUNWXgb8DbwA+gBN0/jb1PDP5JHNm1Jjhkb59IH82yGkfUtVuEfkQ8EOcFTi/w/n0eh5wJs4n0rNUtdm973eAD+PUQuzC+QR6DHAFzhvuBar6lIiswcmubQc24vTzKcN5w1kEfE9VR/sGaYzJAhE5H3gYeFFVTxrkvCXAKzh1VotwEgv3AhcB+4G/4LzfLMTppn+Dqt7mXhsYwbmFwAvACuAx4Bn3+a4E/gy8DbjRnT70xvYIcJ6qZmqGej1wM05fsDtwPqCehRN8/Q3nve4CVX0k6ZrLccoqAjjF+C/gvN+dBCxU1aVpnufNOLW0AN9X1dQaWpMNqmpf9jWmL5z09lBfFUnnXwI8gBNQhXGCq68nn+OedwZO+nwz0IyzXHwX8FOcnjreeRXAl3AK7w+596wDHsGZrpRs/x3Zl33Z18i+cLrdK/CxYZz7gHvum92f84GP4GStOnEaP78M3AIsT7l2JOcuxMkeee9HzwFX4ZRVKLAu5fxHcEvABhn7u4Hn3edtBP4InIjTo0yB89NccwJOS45DONn9ozgfVK/L8Bw+nA+7CpyQ7X9b+3K+LANmjDHG5DARWYbz4fUJVT0n2+MxDqsBM8YYY3LbZ3DKNn6Q7YGYPpYBM8YYY3KM20H/Gpyatffg1IqdqqoDdgsx2WF7QRpjjDG5Zxnw/3BWiz8IfNCCr6nFMmDGGGOMMZPMasCMMcYYYybZlJ2CnDVrli5ZsiTbwzDGTKINGzY0qmrN0GdObfb+ZczMM9L3rykbgC1ZsoT169dnexjGmEkkIvtGeP4q4Ps4jXxbgVtxmmHGhrjuBODbONu9dAO/x2m62Zl0zm04W+GkOl5Vdwx2f3v/MmbmGen715QNwIwxZjAiUonTLXwbTjfyY4Bv4pRWfGGQ68pxmva+BHgbvX8dZzP41P1Fd+CsIEu2d+yjN8bMdBaAGWOmqw/g7ON3laq2Aw+KSBmwTkS+7h5L50PudVeoaiuAiDQDfxaRtaqanLrqUtWn093EGGPGworwjTHT1WXA/SmB1m9wgqvzBrluDbDeC75c3lY2l4/7KI0xJg0LwIwx09VxOFOECaq6H6em67hBrivE2T8vWRSIA8enHF8lIu0iEhaRx0VksMDOGGOGLSenIDcfaGVvUxdXrqnN9lCMMROnEqfwPlWL+1gmu4BrRMSvqr3usdNwNiyuSjpvE/AMTo1ZDfBpnGnOs1X12bEO3hgzNcTjyo4jHTR0humJxGjpjnCopYdDrT184fLjqS4pmJDnzckA7OdP7eOxlxssADMm96XrJC0Zjnv+D/g48H0RWYdThP8jIOZ+OTdW/W6/m4rcgxOMfY6BxfqIyHXAdQCLFi0ayWswxkyyxs4wj73cwKM7G3js5UaauvonxX15wtyyQpq6IhaAjUSoN0ZP76Cr0I0x018LUJHmeDnpM2MAqOoON1j6NnA9ztTjLThB29FBrusRkXuBKzI8fot7H9auXWtbjBgzCWJx5UBzN3uaumjqjNDcFaauLcShlh46w1GCfh8F/jzCvXG6IzFae3pp6YpwpD0EQHVxgHNWzOLclTUsri6i0O+joijAnNIC8n0TW6WVswFYyAIwY3LdDlJqvURkIVBMSm1YKlX9iYj8Cmej4nqgEWjC6SM2FAuujJkkLV0RdjV0squ+k72NXTR1RWhO+jrSHiIS7b/FZVHAR21FkLKgn7aeXsLROIX+PIJ+H7UVhZxYW8bi6mLOXVHDCfPLyMuTrLy2nAzAwtE4vTElGotPeARrjMma+4AbRKRUVTvcY28HeoBHh7pYVUPAiwAi8i6cRUm/y3S+iARxVl5uGOO4jTFJQr0xXmno4lBrDwdbutlV7wRcuxs6aezsmxoM+PKoLglQWRSguiTA4uoi5pYVckxNCctqiqkpLaCqOEBJQT4i2QmqRiInAzAv+xWKximxAMyYXHUz8DHgThH5GrAMWAd8K7k1hYjsAh5V1fe5P5cBnwf+gbP68QKcAvv3q2qze0458Bfgdpyi/VnAJ4Fa4G2T8eKMyVWd4Sgb9rXw7J4mntvTwvMHWonE+rJYZYX5LJ9dwoXHzWbF7FKWzy5h+ewSaiuCWctWTYTcDMCiTgDWE4lRUpCTL9GYGU9VW0TkIuAHwN04dV/fxgnCkuXjrHD0xIBTgPfj9AzbArxVVf+UdE4YaMDpqD8bCAFPAeelNGo1xmTQ1tPrZLLqOxPTiC/Xd3CwpQdVp9B99fwy3n3WEk5aUM6CyiIWVAapLg5MiwzWWOVkdBLudSJpqwMzJrep6jbgwiHOWZLycxdwyRDXhICrxjo+Y3JZPK4cau1hV0MnB5q7E60bnKnEHho6wolzA/l5LJtVzMkLKrj61IWctriSUxZVUDyDkyQ5+cq9DJgFYMYYY8z4iETjHGkLselAC/dvPcKjOxvoivT9ng348phfUUhtZZALjq1hWU0Jy2tKWDGnhAWVRfhyaPpwPORmAOZmwKwVhTHGGDMyod4YbT299ERiNHSG+fv2eh7YdoQ9jV2ouwa4prSAK0+p5cTaco6pKWFJdRGzSgpyqkZrouVoANZXA2aMMcaYgY60hXhg2xH+8VIDR9vDidYOqcmL/DzhzGOqueKk+dRWBlk+u4Q1Cyos2BqjnAzAwlHLgBljjDEeVWVvUzePvdzAxn0tvHCojVcaugBYOquYxdVFrJhdQlVxgKqSAOVBP0UBHyUFfk5fUkV5kT/LryD35FwAFo9roimbNxVpjDHGzAS9sThbD7ezu77TKYh3C+P3NDp9tgDmlBVwYm0Fbzl1AZeeMIfls0uzPOqZKecCsHBSR1wrwjfGGJPLVJWdRzsSexpu2NfSb/ZnVkmA2oogaxZVcP15yzh3RQ1LZhVnccTGk4MBWN9/eDYFaYwxJpfE4sr2unae2dPMc3uaeW5vc2Ij6WPnlPL2Vy3kVUuqOH5eKfMrghT6fUPc0WRLzgVgydOOVoRvjDFmujvaHuKhHfU8urOBJ3Y30hGKArCgMsj5x87mjKVVnLuyhrnlhVkeqRmJHAzA+oKuUNQCMGOMMdOLqrLjSAeP7GzgwW1H2Li/FYD55YW84aR5vHpZNacvrWJeeTDLIzVjkXMBWL8aMMuAGWOMmeJUlS2H2nloRz0vHmpj88HWRBf5E+aX8ZlLVnLJCXNZMbtkRmzRM1PkXACWnAGzGjBjjDFT1YHmbu7afJg7Nx5kd0MXIrBsVjFnHVPNa5bP4ryVNcwps2nFXJXTAZi1oTDGGDOVtHX3cu+WOv648RDP7m0G4PQlVVx7zjIuWz2XiqJAlkdoJkvuBWBJU5CWATPGGJNtkWich3fW88eNh3hoRz2RWJxjaoq54dJjeePJ81lYVZTtIZosyLkALGxTkMYYY7JIValrC7FpfysPbjvC33fU0xGKMqskwDVnLOKqU509FK2ea2bLuQDMy4AV5OdZEb4xxphJs+VQG796dj8PbD1KY6dTRF9Z5Od1J8zl9SfN45zls8j35WV5lGaqyL0AzM16VRT5rQ2FMcaYCdMbi/PgtqM8sauRZ/Y0s6u+k4L8PC49YS6nLa5kdW05Jy8ot6DLpJVzAZjXhqKyKGCNWI0xxoy7znCUP248yM2PvsKh1h5KCvI5bXEl7zxjEW8+ZYFtXG2GJfcCMDcDVh700+52CzbGGGPGorU7wt+21/PXLXX84+VGItE4py6q4CtXnsB5K2ssy2VGLOcCsOQpSK+RnTHGGDMS0Vic9ftaeHZPM0/tbuLZvc3E4sr88kL++YxFXH7iPE5bXGmF9GbUci4AC0fjiEBZod9WQRpjjBmRlq4Iv99wgJ89uY9DrT2IOJtcX3/uMl63eq6tXjTjJucCsFBvjMJ8H8GAzwIwY4wxQ9rf1M3PntrLE7sa2Xm0A1U4fWkVn3v98Zy9fJbVdJkJkYMBWJxCfx5Bv8+K8I3JcSKyCvg+cCbQCtwK3Kiqg/7PLyJrgf8CTgME2Ah8XlWfSTrnNuBdaS4/XlV3jMsLMFnT1tPLhn3N3L25jrs2H8YnwhnLqnj9ifO48LjZrK4tz/YQTY7LwQAsRkG+j0K/j3A0Tjyu5OVZutiYXCMilcDfgG3AlcAxwDeBPOALg1y30L1uI/Cv7uEbgAdE5CRV3Zd0+g7gPSm32Dse4zfZsfVwG/993w4e39WIKgT9Pt571hLef84yZtu+i2YS5VwAFo46GbBCvy/xczDgy/KojDET4ANAELhKVduBB0WkDFgnIl93j6VzOVDqXtcKICJPAo3A64Gbks7tUtWnJ+wVmAmnquw40sELB1t5YlcTd79wmIqgn49euIIzl1VzyqKKxO8LYyZTzgVgod4YhX4fQb+zJLinN2YBmDG56TLg/pRA6zfA14DzgLszXOcHokBn0rFO95ily3PIvqYuPvfHF3liVxMApQX5XHv2Uj5y4QrKg1bXZbIr9wKwaJyC/LxE0BXKUIivqmw93G7z/MZMX8cBDyUfUNX9ItLtPpYpALsD+ArwTRH5T/fYl4AW4Pcp564SkXagAHgOp07s0XEav5kA3nv7PS/W8dMn9pCfl8cX37CKC46tYUl1sZWkmCkj5wKwcG+MAr8vkVLOtBLyqVeauOb/nuHBT57LijmlkzlEY8z4qMQpvE/V4j6WlqoeFpELgL8AH3MP1wGXqmpD0qmbgGdwasxqgE/jTHOerarPjsP4zTiqbw/x+w0H+e1zB9jf3E2ewKUnzOXLV5zA3HKr7TJTT84FYKFonPKgvy8Ay7ASsqWrF4DGzggr5kza8Iwx40vTHJMMx50HReYBfwA2ANe6hz8M3CMir1HV/QCq+t2U6+7BCcY+B7wpzX2vA64DWLRo0YhfiBmdxs4w337wJX773AGiceXMZdV85ILlvHbVHKqKA9kenjEZ5VwAFu6NUVhaQNA/+BSkd7yn17YrMmaaagEq0hwvJ31mzHMDznvf1araCyAiDwEvA5+hLyvWj6r2iMi9wBUZHr8FuAVg7dq1GQNAMz5iceWnT+zhO397mZ7eGNecvoj3nLWEZTUl2R6aMcOScwFYKGUKMtQbT3uet2l3TyT948aYKW8HTq1Xgttioth9LJPjgK1e8AWgqhER2YrTymIoFlxl2b6mLj7z+808t7eFC46t4fOXr2L5bAu8zPSScwFYOBqnMD8vkQHLVAMWjjrHuyOWATNmmroPuEFESlW1wz32dqAHGKxQfh/wehEJqGoEQEQKgNVkLtxHRII4Ky83jMfgzej8dUsdn/7dZvLyhG++9WSuOrXWtgYy01LOBWCJNhSBvjYU6SQyYLZdkTHT1c0404V3isjXgGXAOuBbya0pRGQX8Kiqvs89dCtO7dcfReRHODVjHwbm4U4hikg5TpH+7cAuYBbwSaAWeNuEvzIzQCyufOdvL/H9h3axZmEFP/rnU5lfEcz2sIwZtRwMwJw2FIVD1ICF3anJbtuuyJhpSVVbROQi4Ac4matW4Ns4QViyfMCXdN0GEXkd8GXgF+7hF4GLVXWz+3MYaMDpqD8bCAFPAeep6voJeUEmoyd3NfIf92xnW107b1u7gK++aTUF+dbf0UxvORWAqSrhqJMBGzIAc6cgbb9IY6YvVd0GXDjEOUvSHPs78PdBrgkBV411fGZs4nHl8396kV8/e4DaiiDf/6dTeMNJ82zK0eSEnArAemNKXElsxg2ZAyybgjTGmKnt6/fv5NfPHuC6c5fxqYtX2pZBJqfkVAAWcrNahcNoxOplxqwI3xhjphZV5SdP7OXmR3fzz2cs4t8vO86yXibn5FQA5tV1FeTn4csTAr68IdtQWA2YMcZMDbG48qdNh/jx43vYVtfOxavm8JUrV1vwZXJSTgVgXlarwM1+FfrzBqkB8/qAWQBmjDHZpqr82x0v8PsNB1k5p4T/vupErjp1AT7bu9HkqJwKwMJJU5AAwYAvcw1YohO+BWDGGJNt337wJX6/4SAfvXA5n7p4pWW9TM7LqQAslDQFCU4g5tWFpbIpSGOMyT5V5ceP7+F7D+3i7WsXWvBlZoycCsAGZMD8g2TArA2FMcZkVUtXhM/e8QIPbDvKJavm8B9vtnovM3PkVADmZcAKkzJgQ3XCt1WQxhgz+bYcauP9P19PY2eYL1x+PO89ayl5Vu9lZpAcC8D6Z8AGK8L3gjXLgBljzOS6f+sRPvGb56ks8nPnB8/ixAXl2R6SMZMuL9sDGE9eVqvA77ysoN+XCLQe3HaUA83dSedaEb4xxky2Ozce5AO3b2Dl3FL+9BELvszMlVMBWCIDlp+0CrI3Rmc4yvW/WM/Pn9qbONf2gjTGmMn11O4mPnvHC5y5rJrfXvdqZpcWZntIxmRNjgVgbg2YNwWZ7xThbz7QSlyhM9wXbHnZsnA0Tiyukz/YYQpHYzy5qzHbwzDGmDHZVd/J9b9Yz+LqYm5652m2rZCZ8XIqAPOmFRNtKAI+wtEYG/a1ANCTVHAfTmpPMZWnIf+65QjX3PoMh1p7sj0UY4wZlZauCO/72XME8vP46btfRXnQn+0hGZN1ORWApWbAvDYUiQCst38GrKTAWYMwlQvx23p6AWjqDGd5JMYYM3K9sTgf/OUG6tpC3PKva1lYVZTtIRkzJeRYAG74JMYAACAASURBVNY/AxZ021Bs2u8EYF69l6oSicapKHI+hU3lAMx7Te091i7DGDP9fPmurTz9SjNfe8uJnLqoMtvDMWbKmPYB2IHmbn748C5auiKEojECvrxEL5lCfx5xhfaQE7x4gZZX/1VZFACgu3fqBjdeVs/LhBljzHTxy2f28atn9vOB847hzacsyPZwjJlSpn0Adqi1h2/cv5PnD7YS7o0nWlAA/Yo8j6kpTmTAvBWQXgZsrCshf/jwLj79u81jukcm3rRpe8gCMGPM9PHc3mbW3bWVC46t4YZLj832cIyZcqZ9ALa6thwReOFAG+ForF/QFQw4f64qDnDcvLLEdJ5XgO9lwMY6Bbl+bzPP7W0e0z0y8cZsGTBjzHRxpC3EB2/fyILKIr7zjlPwWYd7YwaY9gFYSUE+x9SU8MLBVkK9cQqTM2BuP7BTF1VQHPD1ZcASU5DjUwPWFYlN2EpKm4I0xkwnkahTdN8TiXLLv5xmKx6NyWDaB2AAJy0oZ/PBNkK9MQryB2bATl1cSVEgP7Hvo5cBq0jUgI0xAAtHCU1QIX9fEb4FYMaYqe8/79nGpv2tfOOtJ7NiTmm2h2PMlDWsAExElovI/4rIZhGJicgjw7yuXER+KiItItImIr8UkeoxjTiNkxdU0NgZZm9Td78MWHWxE2CdsbQ60RUf+rJKfRmwsRXhd4WjE5gBsylIY8z08OfnD/Gzp/bx/nOW8voT52V7OMZMacPNgJ0AvB54yf0art8C5wPXAu8GXgX8aQTXD4u3l9iOI+2JaUeA05dWcd/Hz+G0xZUE/T56Y0pvLN43BekGaGMtwu+KxIjGnXuPt0QGLDR1V2oaY8zR9hBf+NMWXrWkks++7rhsD8eYKW+4AdjdqrpQVd8KbB3OBSJyJnAp8C5VvUNV/wi8EzhbRF47uuGmt2peGfl5gir9VkGKCMfPKwOgyJ2O7OmNEXaDGq82YazZq66wExyFJiAL1mMZMGMyEpFVIvJ3EekWkcMi8hURGXSPGxFZJyKa4evfk867LcM5Fl2kUFU+/8cX6Y3F+cbVJ5Pvy4nqFmMmVP5wTlLV0aR2LgOOquo/ku7zrIjscR/72yjumVah38exc0vZerh/BiyZVw/WE4klMmBlQT8iYyvCj8c1kUHr6Y1RWji+BafedKnVgBnTn4hU4ryPbAOuBI4BvonzwfILg1x6K/DXlGNvAj4L3JdyfAfwnpRje0c34tx11+bD/G17PV+4/HiWzCrO9nCMmRaGFYCN0nE4b16ptruPjauTFlQ4AViGDV69DFh3JJYowi/M91Hk941pCjK5gD8UmcApSAvAjEn1ASAIXKWq7cCDIlIGrBORr7vHBlDVg8DB5GMi8kVgh6o+n3J6l6o+PQFjzxmHWnv48l1bOWVRBe85a2m2h2PMtDGReeJKoDXN8Rb3sXF1klsHljwFmSzoH5gBK/DnEQzkjykA86YfYWI29U4uwlfVcb+/MdPYZcD9KYHWb3CCsvOGexMRqQIuBn49vsPLfeFojA/dvoFoTPnmW0+2fl/GjMBET9Snixgkw3FE5DoRWS8i6xsaGkb0RIkALOMUpLvxdm800Qm/ID+PooBvTKsgOyc8AHPGGo3rhK20NGaaGpBlV9X9QDcjy7JfDfhxgrdUq0SkXUTCIvK4iAw7sJsJbrx7G5sPtvE/bz2ZZTUl2R6OMdPKRAZgLUBFmuMVpM+Moaq3qOpaVV1bU1MzoidbOaeUkoL8xPZCqdJOQfp9iQ27R6s73HftRGzqHYrGCLibi1shvjH9jFeW/R3ARlVNXeG9Cfg0cAXwz4APZ5rz9FGMNefc+tgriX0eX7d6braHY8y0M5E1YDuAc9IcP44JaEXh9+Vx54dew5zSwrSPe1OQ3clTkPl5BANjqwFLzoBNxCrIUG+M2aUFHGzpob0nyrzycX8KY6azEWXZB5woMg9nuvKzA26s+t2Uc+/BKfj/HE7Rfuq9rgOuA1i0aNFwnn7auvWxV/iPe7Zz2eq5fOaSldkejjHT0kRmwO4D5orI2d4BEVkLLGPgSqNxsXJOKeUZMmDeKshQbywRKBXk+9wpyPGpARvvAExVCfXGmVPmBJWWATOmn0xZ9nIyZNnTeBtOwPbboU5U1R7gXuDUDI+POoM/nfzqmf2J4Ot7/3SKtZwwZpSGlQETkSKcRqwAtUCZiFzt/nyvqnaLyC7gUVV9H4CqPiUi9wM/F5HPAHHga8DjqjpuLSiGq/8UZBwR8PuEooCP1u7RBzZdkYmrAfMydXPKCgALwIxJsYOUWi8RWQgUk34FdjrvwHlPOjCC552xq2EONHfzlb9s5ZwVs/jeP52C34IvY0ZtuFOQs4Hfpxzzfl6K0xcnH6dGItk7gG8DP8HJtv0F+NhoBjpWRX7npXoBWEF+HiJC4RhrwLqSa8DGOQDzMmqz3WlVa0VhTD/3ATeISKmqdrjH3g70AI8OdbGILAFeDXxoOE8mIkGclZcbRjPY6U5V+dKft5Anwn+/5SQLvowZo+E2Yt2Lk6Yf7JwlaY614jQxTG1kOOn6GrFGCSdt2j2eU5Dp7nP70/uoa+vhhktH3vrMC+hsCtKYtG7G+UB3p4h8Dae8YR3wreTWFKnZ+STvAKLAH1JvLCLlOB8Ybwd2AbOAT+LMALxt3F/JNHDfliM8vLOBL1x+PLUVwWwPx5hpb8Z8hPH7BF+e9MuAARQF8ukeQxuK5CnIdDVgD247yl9eqBvVvb0WFDWlzhRke8gCMGM8qtoCXISTeb8buBEn4/7llFPTZefBCcD+rqrpet6EgQacjvr3Arfg1JWdp6rrx+UFTCOh3hg33r2VVfPKePdrlmR7OMbkhIlcBTmliAhF7nRjOBpPdMwPBsY6BRkl6PcRicXT3qczHKVzlBtpewFdSYGPkoJ8y4AZk0JVtwEXDnHOkgzH1wxyTQi4akyDyyG/fGY/R9vDfPcdVnRvzHiZUf8nBd3pxnA01pcB8/vojSm9sdFtI9QZjlFckO/0E0uzFVFnKErHKAMwL6Ar8PsoD/pp7xl9ps4YY0Yj1Bvj5kd3c+ayal69rDrbwzEmZ8yoAKzI7fkV6o0ntixK1IaNMgvWHYlSXODLWMzfGY4SicVH1aLCuybo91FaaBkwY8zk+9Uz+2noCPPx167I9lCMySkzKgDz9n10MmB9U5Aw+i72XeEoxYF8goE8wmmCrA63bms0WTBvy6TCRAbMAjBjzOQJ9ca4ybJfxkyImRWA+fMI9cYI9yYX4ff1BxuNznCUEm8KMiUAU9VEp/yOURTQe/cr9Oc5AZgV4RtjJtFdzx+moSPMxy6y7Jcx421GBWDeisfkVZDBRH+w0dVXdYVjFGWYguzpjRF3WzYmb1k0XN4UZGG+j7Kg36YgjTGT6o6NB1k2q5hXL6vK9lCMyTkzKgDz9n0c1ynISJTignwnAEu5R/Lqx9FMQXptKIIBm4I0xkyuA83dPLOnmatOrUVk0DaQxphRmFEBWFEguQ1F/ynI0Rbhd4WjlAScKcjUQvuOcHIANvLgqV8GrNBPVyQ26tWaxhgzEn/adAiAN51Sm+WRGJObZlQAFnSzVE4NmC9xDEZfA+ZNQaarAUvOgLWPIgPW14Yij/KgM1VqWTBjzERTVe7cdIhXL6tiQWVRtodjTE6aWQGY2wcsFI0l2lAUjWEKUlXpirhF+GkauibXfY2mGWu4N4YIFOTnUV7kB0YXyBljzEhsOtDKnsYurjp1QbaHYkzOmjGd8MHtA9Ybwx+XflsRwegyYD29MVRJ1IB5NVuejrHWgEXjFOb7EBHKCp0AzArxjTET7ffrD1CQn8dlq+dmeyjG5KwZFoDlE4srsbgOmIIcTQ2Yl+EqDjhTkKHUIvwx1oD1RGKJWrXyoJsBswDMGDOBDrf2cMeGQ1y9dgGl7gc/Y8z4m1FTkN7+j0BfG4rEFOTIM1TdYSfgcjJgeWlqwJxgKZCfN8pVkLFEgFgWtAyYMWbi3fTIbhTlQ+cfk+2hGJPTZlQA5tV7AYkasEB+HgHf6AKkRAbMbcQajfffU9J7fG5ZIR3hUayCTNo0PJEBs2asxpgJUtfWw2+fO8Bb1y604ntjJtjMDcDy+/68fHYJ2+raR3y/rsQUZH7aPSU7wlEC+XlUFQdGFeD1RGIUpARgrd0WgBljJoZlv4yZPDMqAAsmTUF6tVUAaxZVsPlAK3GvbT0Ma/Nsr3Df24wb6FcH1hmKUlqQT2lh/uj2goz21YAV+n2UFuTT0BEe8X2MMWYo9e0hfvPsAa4+bYFlv4yZBDMrAMuQAVuzoIL2UJQ9TV0APLmrkRPX3c+h1p5B7+dNMXp7QUL/DFhnOEpJYT5lhf5RN2JNDhprSgto6LQAzBgz/n765F6i8TjXn2vZL2Mmw4wKwPpPQfbPgAE8v78VgLtfOExvTDnY3D3o/bwpyKKC9FOQnSGnR9hoM2A9vbF+CwdmlRZYBswYM+46Qr3c/vQ+Lls9jyWzirM9HGNmhBkVgHkbb0NfET7AMTUlFAd8bD7Yiqry8I4GYOimp13udKO3FRHQrxdYR7gvABvdZtzxflOlNSUFNE5SANYdifLe257jxYNtk/J8xpjs+c2zB+gIRbnu3GXZHooxM8aMCsAyFeH78oSTFlTw/IFWttW1c6Q9BAzdu6svA+ZLBHQ9qTVghfmUFPjpjsSIjnAfx1BKBmwypyAf3tHAQzvqeXZv86Q8nzEmOyLROD9+fA9nLqvm5IUV2R6OMTPGjArAghmmIMGZhtxe185ftxxJHBuq6WmXu8rR78tLyoCl1IC5GTDv55FwMmD9A7COUHRYCwTG6r4tdcDoGsgaY6aPuzcf5kh7iOvOs+yXMZNpBgdgvn6Pnbyggt6Y8rMn93L8vDJg6O2DvH0gk++drgjfC8BGWgcW6o1RmDTOmpICgAmvAwv1xnh4Rz0wuj0sjTHTg6py6+N7WDmnhPNX1mR7OMbMKDMqACvK0IYC4BS3EL89FOXiVXMI+n1DNj3tCscoLkjZ0iiSWoTvT2znMdImqqHeGMFA3zhnlQYAaJzgacjHXm5M1LeNZvGAMWZ6eGp3E9vr2rn27GWISLaHY8yMMqMCsHyf0/UeBmbA5pQVMq+8EIALj5tNWXDolYud4SjF7mbeqW0owtEYkVic0sJ8yrwpyBEEM72xONG4pmTAnPFNdAbsvi11lBXms7i6aFSLB4wx08Otj+9hVkmAN66Zn+2hGDPjzKgADPqmCgv8A1/6aYsrmV1awEm15ZQW+ofMWHVHohS7U5CFgf41YF6wVVKQT8kopiC9+6TWgAETWogficb527ajXLxqLpVFAdv6yJgctau+k4d21PMvr17S733GGDM5Zl4A5r7RpBbhA9z4xhP43fVnkpcnlGXo3bX1cBsX/M8jvNLQSWc4lgjAUovwvcxRaWF+YgpyJPtBeu0skqdKq0vcKciOyLDvM1JPv9JEeyjKZavnjrp9hjFm6vvRI7sI5OfxzlcvyvZQjJmRZlwA5rWiSJ2CBKguKUg0ISwt9KddBbnlUBt7Gru48e5tdIWjFLv38/vy8OVJYgqyIykDNpoi/HQZML8vj8oiPw2doWHfZ6RePOT0/XrN8upRN5A1xkxtz7zSxJ0bD/Hes5ZS7S7uMcZMrmEFYCKySkT+LiLdInJYRL4iIoPmrEVkiYhomq/fjM/QR8ebggykyYAlKwv60zZibepysk+PvtTAKw2diQwYOFmwnoiTuUpsUzTKVZDpAjBwe4FNYA1YQ0eY0sJ8igL5lBTk2ypIY3JMJBrn83/awoLKIB+/aEW2h2PMjJU/1AkiUgn8DdgGXAkcA3wTJ3j7wjCe4zPAE0k/N458mOOnKODD7xN8eYOv+HGyPwMzYC1dEQry81hYVcSu+s5EGwpwgqWelBqw0gI/Bfk+Ar68EQZg3hTk5AZgR9tDzHZrzUpHuYelMWbquuUfu9lV38lP3/Oqfq15jDGTazgZsA8AQeAqVX1QVW8GbgQ+JSJlw7h+p6o+nfS1aywDHqtCv6/fysJMygr9tPekz4DNKingS29YBdAvAAsG8gbUgHkF+JkCukxCUec+wZQAbFZJAY2dE1cDVt8RZnaps9qypCCfrkiMWFwn7PnMyMXiSiQ6sl0VjAGnsfIPHt7FZavncsGxs7M9HGNmtOEEYJcB96tqe9Kx3+AEZedNyKgmUFHAl3YFZKrSwnwisfiArvPNXREqi/2cu7KG775jDe84fWHiMWcK0q0BC/fVgHn3G0kGzLtPar+ymhInA6Y6MUFRfUeIOWVeBmx0HfzNxPrWgzt56/8+le1hmGnoga1HCfXGufacpdkeijEz3nACsOOAHckHVHU/0O0+NpSfikhMROpE5FsiEhzFOMdNedDfL2uVSVkwffPUlq4IVcVOgHLlmloWVBYlHgumm4JMZMBGNp03WA1YT28s0Sh1PKkq9e1hZpc5GTALwKamXfWdvNLQOezz69p6JmX7KjP13bX5MLUVQU5dVJntoRgz4w0nAKsEWtMcb3EfyyQM/BB4H3AR8L/AB3GyZ1nzideu5AfXnDrkeWUZCuebuiJUFwfSXtOvBizcS36eJNpdjLSlQyg6sA0FOFOQAI0TUAfWHooSjsb71YCB7Qc51bT19NIZjhIfxtRwLK687juP8e0HX5qEkZmprLEzzOO7GnnjmvnW9d6YKWC4bSjSvdNLhuPOBap1qvoRVb1LVR9R1XXAp4A3isiadNeIyHUisl5E1jc0NAxzaCMzvyLI6tryIc8r87YPSmlF0dwVobIocwAWTsqAlRTmJ97oSgpGNgUZimTOgMHENGNt6Aj1ew4vU2grIaeWtp4oqs5epEM50h6iraeXe16sm7BpazM93PtiHbG4cqV1vTdmShhOANYCVKQ5Xk76zNhg/uB+T5uCUtVbVHWtqq6tqcnuxrDpWkeEemN0R2KJhqipkqcgO8LRflOdzhTkSDJgQwRgE5ABO9ru3NMrwh/tJuKTqSsc5dO/28yB5u5sD2XSeB8KhvPvsq+pC4CDLT3sPNoxoeMyU9ufnz/MsXNKOW7ucNZOGWMm2nACsB2k1HqJyEKgmJTasGHQlO9TVroasGa3B1hVhinIYKB/DVj/ACx/yG19VJWv/3UH2+vaM9aAJaYgxyEDFuqN8fb/fYr1e5sBpwAfGFCE3zGFa8D+tv0od2w8yE+f2JvtoUyathEEYPub+gLTB7cenbAxmantQHM3G/a12J6PxkwhwwnA7gMuFZHSpGNvB3qAR0f4fFe73zeM8LpJly774wVgg01BJjdi9e4BTk1ZZzg66DTQ7oYufvTIbr7395f7+oClNIytKg6QJwMzYJv2tyRWTg7X8wdaeWZPMw9ud34x13sZsEQR/tSvAXt0pzNV/efnD9Eby/3WDNFYPFFLOJx/l33N3fh9wskLyhP/zmbm+ckTe/DlCW86pTbbQzHGuIYTgN2MU1B/p4i8VkSuA9YB30puTSEiu0Tkx0k/rxORb4rIVe51XwG+Ddypqi+M78sYf+lqwLwAbLApyOQ+YMkZsJLCfLduJ3OQ5GWi/r69niPtIfw+Id/X/5/IlydUl/RvxlrfHuItNz3JT57YM5KXyKb9zgzyy0edFXX1HWGKAr7EuKd6DVg8rjz6UgNzywpp6ookgrFclvyBYLgZsAWVRVy6ei4vHGzjSNvEbWNlpqb6jhC/emY/V51SS21FVhehG2OSDBmAqWoLzipGH3A3ThPWbwNfTjk13z3HswOnT9hPgXuBa4BvuN+nvKKAD1+ejHAKMo+e3hiq6hbh+xOPDSeb9NzeFgK+PCKxOH/ZfDhjw9ialABs4/5W4upspD0Sm/a3APCSWxvkNGHt2xeuKOAjT6ZuDdiWw200dUX41CUrqS4OcMfGg9ke0gCxuI5rC4i2pA8EQ01pA+xr7mJRVRGXrJoDMGQW7GBLN9f/Yj1dU3ja2YzMrY/toTcW58MXLM/2UIwxSYa1ClJVt6nqhaoaVNV5qvpFVY2lnLNEVd+d9PNv3IL6clUNqOpyVf2Sqk7cPjrjSEQGNE/19oGsyjAFGfT7iMWV3pgOKMKvLHICsKZButiv39fM+cfWsHJOCe2hKIUZtgmZW17IgZa+2p7nDziZrI37WogOcxpOVdnkXnewpYeucNTdhqgwcY6IOPtBTtFfxo/sbEAELjxuNleuqeXv2+tp7Z64XQJG44cP7+KK7z8+bvdLDsCGCoxVlX1N3SyuLuKYmhKWVBfx4LbBA7Andzdx/9aj7DhiBfu5oLkrwu1P7+ONJ89nyazibA/HGJNkuG0oZqTSwvx+U5AtXRF8eUJ50J/2fK9gPhSN0RnqXwM23039H27tSXttfXuIfU3dnL60iqtOXeDeL/0/z2mLK3npaGciC/b8gRZEnOnN4f7iPNwWoqEjzFnLqwGnuWdDR5jZZQX9zist9A8r05INj+ys56TacmaVFPCW02qJxOLcvflwtofVz84jHexu6By37ZxGEoC1dvfSEYqyqKoIEWHtkipeGuK/D+8DgpftNdPbbU/soac3xkcutOyXMVONBWCDKEtpHdHUFaGyyE9eho28vQDsi3/aQk9vrF+9hffnQxkCsPX7nOnAtUuquHLNfETIOAV59vJZADy5u5FYXHnhYBsXH+9MMT3n1pGl880HdnLj3VuBvunHt611tlJ66WgH9SkZMHAbyE7BKciWrgibDrRynruf3ap5ZSypLuIfL2d1r/cBGjvDxJVxy8yNZApyn9uaY3G1k/moKg7QMsQ4mtzVtc1d0yJRbQahqty56RDnrKhh+ezSoS8wxkwqC8AGkdo6orkrnHEFJPRtnP3n5w9z7dlLueaMRYnHqooDFPrzONSSPgB7bm8zhf48TphfxrzyIBccO5u55YVpz11dW0550M/jLzfy0tEOuiMxLjtxLrUVQdbvbck4vj9scNo1bK9rZ9P+Vgry87j0hLkE8vPYdKCVrkhsQAZspA1kJ8s/Xm5AFS441ukXJyIsnVWcMcM4Wl/68xb+sGH0tWVeu5Cmccoo9c+ADRGAuT3AFlc722VVFPkJR+ODrpb1xjle4zXZ88LBNg629HDFSfOyPRRjTBpDb4o4g5UV+tmf1OCzpas3YwE+wMo5pSyuLuLfLzuO163u/6YnIsyvCHK4rS9AuGPDQbbVtXPDpcfy3N5mTllYid9d9fjDa04lnqFlhS9PeM0x1Tyxq5FTFzu7Qa1ZWMmrllTy5O4mVHXAViONnWHq3BVw33/oZY60hThpQTmFfh/H1JTw5C4nc5RchA9OENo4SN1aNkRjcW56ZDe1FUFOWtDXI3h+RTBRDzde7tx4iL1N3Vx92oJRXe/93TV2hlk5Z+xZCC8Am1NWMGRg7PUAW1TlBGDeh4eW7gjBQPrVcF7g1TzF/s3NyN3zYh1+n3DJqrnZHooxJg3LgA2itNDfrwasqSucsQUFwIkLynn0hgsGBF+e2opgvwzYz5/ay48f38M/3/oM2w6386olfVtrBgM+igfZNPys5bM43BbijxsPUVHkZ0l1EWuXVFHfEWZ/czed4Sibk4KRLYfaADh9aRX3vniEFw62cYq7Ie/KOSXsdX9Zp05BloxwE/HJ8POn9rHjSAdffMMqfEnTwfMrgrR099I9jC16hqMnEqMzHB3RxtfJItF4ImAabPHFSLT39BLIz2NWydAB2L7mbuaUFSSmxr2FIK3dmf89+6YgLQCbzlSVe16o45wVNZQXpa9ZNcZklwVggygL5g9oxDrYFORQFlQGEzVgqsruhi5W15bx4qE24urUfw3XOSucOrBn9zZz8oIKRITTlzrX/379Qd70wye48odPsKveCR62HnZatn3zrSdTUpBPNK6cstDJHiVnZuYMKMLvWwXZE4mxYV/mKc7JUN8R4tsPvsR5K2u49IQ5/R6rTSx0GJ9eV9704aHWnlG1kkgOYsYroGnr6aU86HdX6A4eGO9v6mZxVd/Ktwr3v93B6tESRfhTbDWpGZlNB1o51NrD5Sfa9KMxU5UFYIMoK/TTEY4SiyuxuNLa00v1IFOQQ6mtCNLYGSHUG+Noe5jOcJS3r13Ir649g3eduTgRQA3HoqoiFlQ6AccaN5BaXlNCedDPDx7elVgh+cjOegBePNjGkuoiFlYV8d6zl+LLk8T05YrZJYn7DijCL8in3Q1Cf/H0Xt5685Pj2urhga1HuPqmJ4fdPuPrf91JOBpn3RtPGDDNOtRK05Gqd/8OVWFf08j3mkzeLqppnDZP7wvAht5bdF9zF4vc+i9InoJMH7ipKk1dlgHLBfe8UEfAl8fFKR9SjDFThwVgg/DaSHSGorR2R1DN3IR1OOYnrYT0MlPH1JSwdkkVN165esC+j4MRkUQWbM0iJwDLyxPecNI8TllUwV8+ejbLZ5fw6EtOd/gth9s4obYcgI9ftIIHPnkuc9wth7wMWCA/j7Jg/2nP0sJ8ItE44WiMbYfbiSscaR+/bur3vFjH+n0tifq0wURjce57sY63nLaApWl6Gs2vcF7PeAVgyQHUaKYhG5Kub5yQDFjmAMwL8hdX9QVgFe5UVKaVkO2hKL0xp+4wecr0f+7fyQd+MeV3DzOueFy598U6zl1Zk9jRwxgz9VgANojkDbkT+0COMQMGToCw2/2Fvjwp+zRSV66pZeWcEk5b3Fc79p9vPpE/fugsFlYVcd7KGp7Z00xdWw8HW3pYPd8JwHx5wjE1fc+7sKqIgvw8ZpcWDMgqJW9HtNPbsqg9czanJxLjX378DFsPtw3rNXhF88PJMG2ra6crEuM1x1SnfXxOWSF5Mn4BWPJuA680do34+kb3+qKAb9wzYGVD9GfzFo8kZ8AqEjVg6QOwxFZbxYF+GbCnX2ni8V2Ng+5jaqaOTQecDzSXn2TF98ZMZRaADaLMzYAlB2DVxQWDXTKoWnfK8FCLkwErLcynpnT093v1+oebRwAAG+hJREFUsmoe+OR5GT/lnreyhkg0zo8fc/aIPNHNgKXy5Qkr55QyL03bC28Lpdae3kTQWN+ROZjYVtfGYy83cu+LdUOOv6kznAi89jUPHeA8u8fpcZZpqtbvy2NOWSGH0tSAffD2DXznby8N+RzJvAzYrJICXmkYeQDmrShcMad03IrwkzNgneEo8QwNXve4AeOS6r5MYUG+j6KAL2MRvhckrphTQk9vLNGu4nBrD53h6JRbDWvSu+eFIwR8eVx0vE0/GjOVWQA2iLLE/o3RIfeBHI65bobGm4I8pqZkQMZpPJ2+tIpCfx6/enY/ACfML8t47v+76kS+fMUJA46XuEHo1sPtRKJOnVZ9R+bpwt1uoLL5QPoM2MM76hMF7ZsP9q3S3D+MDNhze5tZVFWUmDpNZ35FcEAGrD3Uy1+3HuFnT+6ld5i1ZuBkwKqKA6ycU8IrjSOfgmzsCBP0+1hYGRy3mqr2pADM2dw9/TTk9rp2RJxgKlllUSBjDZgXYHlT0k1dYaKxeGLK2esrZqaueFy5b0sd566cZdOPxkxxFoANwsv+tPf09u0DOYYALN+Xx9yyQg61OFOQY5l+HI5Cv49XL6umOxJjQWVw0OnT1bXlrE6TIfPq4DYmrX4cbArSyxS9cLB1QHZmd0Mn77ntOX78uJORe35/K3kC88sLh5yCVFXW723hVUOsFE3ttQawaX8rqk7x+eO7ht8pv6EjzKySAEtnFScySiPR2BlmVmmAWSUF/erJmrsio1pVGY87e4yWuUX4kHk7ou117SytLqYo0L+mr6LIn3EK0ivAX+EGYM1dEY52OJ38gUSrkuH6+/ajw8qEmvGz6UArdW0hXm+rH42Z8iwAG4RXkN4RitKSqAEb26fK2sog2490UN8RnvAADJxpSCBR/zVSpQXO692wz9lvcn55Yb/aqFResXp7KMrelIyJF5z9YcPBxGbgx84t47h5ZQPOTbW7oYumrginL60c9Lz5FYXUtYb6BX8b9jaTJ04wedfzw98rsrEzTE1pActqSmjt7h1xFquxM0J1cQHVxQHaQ1Ei0TiqyhXff5xvPTiy6VBw/jtUJZEB846ls72ug+PmDWz8WlHkz1iE702Teqtim7oi/frWjTQDdtuTe7n50d0jusaMzb0vOqsfX7vKph+NmeosABtEIgMWcjJgpQX5FGTYn3G4aiuCbK9zenIlF8JPFC8AO3HBKAMw9xf9trp2FlUVsai6aNApyFcauxJb3yRPMULfL/A9jV1s3N/C8wdaWbOwgkVVRexv7h60yNur/xoqA1ZbESQSi9OYtJfh+n0trJpfxutXz+OBrUcG3YonWUNnmFklBSxzV1yOdCVko3t9ldu8t7krQmNnhEOtPaPqp+Y1dS3vlwEbOJ3YEeplf3M3x88dOOVcURTIWAPW3BWhtDCfue4Ub3NnJDGd6/fJiDNgh1p7+u2HaiZWPK7c92Id56yw6UdjpgMLwAbhBR/fuH8ntz25d0wF8x6vEB/GtgJyuJbVlPCz957Ov565eFTXezVgsbiyYnYps0sLMxbhR2Nx9jV1ccmqORQFfAPqwPY1dVMc8FHoz+Mb9++kIxTllIUVLK4uojsSG7TI+7m9zYnpwMHML+/fjDUai/P8gVbWLq7ijWvm0xWJ8dCO+iFft6rS2BGhpqSAZTVuADbCacjGzgg1pYHEwo3GznCi/ciOuvaMBfSZeAFYWWH+oBmwnUc6ADh+3sAArHKQDFi6gNFrHLxmYQV7R/D6VZXDFoBNqod21HO4LcTltvejMdOCBWCD8PvyePdrlvDa4+fw6YtX8t13nDLme9ZWONmhgC+PhZWT88vpvJU1iYzJSHm/6AGOnVvC7NICjraH0marDrb00BtzArXV88sHZsCauzlmdgmvO2EuT7/iZLROWVSRyJjtH2Ql5LN7mvn/27v38KjqM4Hj33cmmUxmcp8khBBCEm4B5CYUUKGI4lpo0Vbtqmtd3Wqr7eO2tRfXurai3e3a9ml9erFr7faiq7vVtV5bfaggahXFQgHlapEQJIGQhCSEyT1z9o8z52QmmSQTyG1m3s/zzPOQM3OYc+Ywhzfv7/29vyWlOYNOWujdjHXfMXOx8kVTsllW5iMvPYXnd1UNet7+jm5aO7vJS0+hKNtDslP6zIRsaunst5arO2Bw0m8GNLkhAc3BYBbN39HNhw19M0qf+vmb/PbNioh/Z2gGLHSGbm9WhnVWhEkX2R4XTa2ddvC3/vk9vH2oHjCHIH1eF+kpSSQ7hXq/mQHL8bqYFRwmjrYVRb2/g7bOQNgvHGrkfFB7mtuf3El5QTpr+lkKTSk1vmgANoj1l83hJ9cu5J8vnn7Gw3ihrGahJbkekpzj/+NPSXLiCh7njAnp5Gek0NYZoLm9b+bFmilYludl/uRM9lSfCpt1WFnvpzjHw1WLJgNml/2peWkUB5fL6a8Qv7qxlarG1kGHHyG81xqYmTOAxSXZOB3C2nMK2HyglvaugYchrR5euWkpOB3CFJ83bAjSMAzW/ewNVnx/M09u+7BPNquhpYOAYfbU8qWZGbB6fzsHa5rt11iBkqW2uZ0dRxrZ8kF9xGOyAzDPwEX4e481k+FOojBCW5Esj4uA0VPX+Nsth3l86xH7+HxpLkSEHK+Lk/52qhpbKcxyM8XnNfcJDl8+v6vazo5FYtWOaQZs5DW2dHDzI9twOR381w2LSXWdXZmEUmp0jP8IIM5YyweNxvDjcLGGIWdMSLeXKoo0E9LKEJXlpTGvKIuOroA9HNbZHaCqoZUSn5fzpvqYlJXKwinZOBzC5JxURPoPwAbr/xUqIzUJr8tpBwfbKxuYlJXKxODQ5LIyHx1dAfZWnxror7G72FvDzmW9ZkIeqvMH69bgjqfeZd3P3rAzSdBT0J6bnmIv4F5/2syAzZyQjkPMQCmU9Vn1NyEhPAPWfwC279gpZk3MiJgtzA7phl8RfB9rhmv96Q47WMzxpnAymAErzEylJJilPFzvp7Lez5f+dwe3/Pe2ftt6WJ+/ZsBGlmEYfOOpd6lqaOUX1y+iKNsz+E5KqXFBA7BRNinLHM4qj1AgPV6lu5NwOoSyPC/5wYAkUiH+B7V+sj3J5Hhd9vqU1jBkdWMrXQGDYp8Hp0P4n88t5XtXzgXMLFthZqrdvb23rRX1pLuTovrMRMTuBWYYBtsqT4atFLCw2PzzjiM9w6PVja19hvKsmZ5WADazIJ1DdX47CNoaHEJ94pZl/OTahTS2dHLNw2/zhce209LRFdbE1RrSqzvdwcETp5kzKYPSXG+fIHD/cfPnyvqWiPVhoQGYO9lBkkP6FOF3BwwOHG+OWP8F4csRVQQD5qpghvFkS4e91mmON9meBTkpO5UpPitL6eePwdYSu6tO8dNXDkZ8HysDVpSlAcFIeuHdY7y8t4avXzqDxVFkiJVS44cGYKMs1eXk9184n88uLx3rQ4laWkoSJT4PKUlO8jPMgCRSK4pDtacpC87sLMpOJduTzM4j4UsNWWsTTvF57awUmIuL95f52Vpxko+U5OB0RNe0tjArlSMnW3lky2FqTrWzuKQnACvIdFOY6WZHcAmkQMDgyv/cwuce2RZW3xQaQAFcODOP7oBhr625taLebFGR6+Wy+YVs+tpKvrJ6Oi/tPs7vtx8N219E8HlTOFznp+ZUO9Pz05k1MaPPEOT+YAasvSvAsQjrbTa1dpLsFFKTnYgI6e6kPoFjZb2f1s5uZvcbgJkBVmNLZ9jn/cr+ExjBIVMwM2CH6/z4O7qZlJVqZykr6lp48b1jLJicxRULJ/Hg5oPs+rCxz/tUNbaSlpLUZ21RNXzqT7ez/vk9zJ+cxU3Ly8b6cJRSQ6QB2BiYV5Rlr7EYCz61cBLXLzNnUeYNNARZ57dbNogIi0tyeOtQPYZh2C0oSvqZxTjF54nYDb+2uZ1DtX6WRjH8aCkMtvpY/8JelpbmcPn8SWHPLyzOZscRc9ht11GzceXWipNs2HM87H0d0tN4d8HkbHxeF5v21WAYBlsPnWRpyKQAd7KTr6yewcwJ6Ty3s9oOUK0CfF+ay65Hm5afxuzCDKoaW+2sFpgZME+wfqcywoxDaxki6z3T3cnB3mAGn35oC198fDubD5gBYn8ZsGwrAGvt4FCdn0lZqbiTHfwpeO7WEKTP29MxvzAr1c5Svv5+LburTvHxuRO557I55KencPsTO/H3qgm0WlCM5EoPiSwQMLj72d00t3Xyg6vmRf3LiVJq/NAATA3q5hVl3HiBmbHLcCeRkuToMwTZ3NZJbXO7nQEDM2t0NNj1v7K+BXeywx7C7K3Y56He38HpXv+RD6X+K/R9FxZn8YvrF/G7zy8j0xM+A3RhcRZHG1o50dzGxn019vDqd1/cbxfn151uxxcswAdzvcxV5fls3n+CQ3V+jp9qY2lZ30XBL1tQyLbKBt492kSyU8gMLujuS0uxV1OYlp9mB0j7g1mwru4A79ecZlV5PoBdnxXqVGunvUA8mEPDzW1dHDxxmr8cbuDF947znT/sxemQPksQWewaMH8nFbV+ZkxIY96kLLt+zapXC13xwZpZWpLrsRdPXzO3gMzUZB64egGH6/3c/ezusAyiNXSphl9HV4AvP7GTl3Yf5+t/N9NeOkopFVs0AFNDIiLkZ6T06QXWU4Dfk+G6cKYZTGzeX8vh+ham5Hj7zYiUhNQYhXqnoh6PyxlxmaT+XDqngGe+eAGXzimI+H4Li836tJ1HGtm49wRLSnJYv24OR0628MiWw4C1DFF4sLh6Vj6n2rp4cLNZ97QsQlB42fxCwOxI7vOm2O+fGwxoXElm+xFriNAahjxc30JHV4ALZ+SRkuSI2HPLyoBZzACsk7eDQepjNy3lktkT+Ng5BbiTI8+Ey3AnI2LWgB2u91OS6+XcKdl0dpvBU65dhB8agJlZT6sObMHkLLvYe1mZjy9fPINndlTxf9uO2vtoE9aR0dbZzece3cYLu6q5c005t6ycOtaHpJQ6QxqAqSHLT3fbQ5D+9i5ee7+Wx7dWAjA1JACblJXKjAlpvPr+CY6c9FPs678g2+oF9vRfq8IK0LdWmEX0ycPYsmNOYSbJTuG5XdUcqGlm9ewJfHRGHqtm5vHTVw7S1NJJ7emOPo13V0zPw+V08MyOKnxeV8SZrJNzPJxbnEVXwCA3vSeIsQKaslwvSU4zE5jjdbEvOBPSKsCfNTGDKT4PFXV9h2P7BmDmEOTWQ/UUZLi5YJqPX/7jYh78h3P7PXeHw8zKHThu9kcry/WGTVKwjtOqBXM5HeQGG8mWBgOwT/Rq9HnbRdM4f6qPbz+/mxPNbZxu76KptVMzYCPgJ5v+xmvv13L/FXO5VYMvpWKaBmBqyPLTUzjRbDZj/cyvtnLDr9/hyW1Hg8FDeI3Xqpn5vFNxksP1LXYrg0hmT8zgqkVF/OqNCm55bDun2jppbOlg//Fmlgzz7C53spPZEzP447vmbL7Vs8xM3R0fK6e5rYtf/vkQdcGFuEN5U5JYNtWHYTBgU9jLF5g1Z1YHfOiprZoaDNpEhFkT09kbzIDtP9aM0yFMy0+jxOeNOCGhqbUzbIkZawgy2ia1lmyPi78GJ0eU5qZxbjAjKNJTI2YFYoVZbhzBYdhlZT5Kc72sC2b5LE6HcM+6ObR1Bti074T2ABshB4438/Drh7hqURHXLCke68NRSp0lDcDUkJkBWDvbKxvYcaSR21fPYOe3L+GlL6/ok6laOTOPzm6Djq4Axb7+lxESEX5w1TzuWTebV/afYMm/b+SG3/wFIGKt1dmy2lHMmJBmB42zJmbw8XkT+c2bFZxobou49JQVrA00KWDt3Ik4HRI2hGnVVk0PyZqdV+bjvaomthysY//xZspyvbiTnZTmejlS30J3SCbQMAwaWjrCMmAZ7mSqm1o50dzO0rLog9QsT7I9S7M0z4svLYXSXC85Hpdd82Ydb2FIEDW3KJPNX7+QCRl9G7zOmJBGUXYqm/bVUNVoZu80AzZ8AgGDu555j3R3EnetnTXWh6OUGgYagKkhy89w25mi9JQkbl5Rarc36G3xlBx7xqfVgqI/IsI/XVDKM188n79fPJmapjZy01zMG4YVCHqz6sBWz5oQtv321dNp6eyms9sgL61vALZuXiGfmDeRtXP7X+4lLz2FH356Pp9dXmJvs7JpocOWNy0vo8Tn4c6n32N3VRMzC8xi6pJcLx3dAY419XSa33vsFM1tXcwJWV4o3Z2EVfe+tDT6INXKcqUkOZgYDKbWnFPQayjSPPfCKLNYIsLF5fm8cbCOD06Y2bsizYANm0ffOsz2ygbuWjsrrD5PKRW7YqcXgho3rMzQhj013Hh+Cd4BWmq4khxcMM3Hhj01dqH9YOYVZTGvKIt7L5tDZ7eBK2n4f09YPi2XJSU5XLmoKGz7tPx0Lp9fyLM7qyNmwLK9Ln42QI2V5ZMLw1tfLC7J4dolk1kxPc/elupycv+V87jm4beBntYR1ud0uK7FLnZ/eW8NInBxSMBordOZm5YSVns3GKsZa4nPaw8v3vGx8vDXpCaT7UmmvCD6GXYXzZrAI29V8tT2o2btWIQAVg3d87uqufcPe1k1M4+rev17VUrFLg3A1JCFtpL4TLA/2ECuWzqF1s6APZsuWiKCK2lk+hv50lJ48tbzIj731UtmUlHnt7v5D4cMdzL/ccW8PtuXlfm4bmkxj289Ygc7Jblm0FVR72f59FzADMDOLc4OCwqt9SCXDqH+C3oyYKX99GQDs1h/09cuDFuMfTBLS3PwuJwcqGmmxOexgzt15jbsOc7tT+zkIyU5/Py6RdpXTak4ElVqQURmi8gmEWkRkWoRuU9EBl3xVUQyReQ3ItIgIk0i8riIDH9BjxpV1nqQF0zzRbWm5Udn5PHoZ5fExOLjYPYke+625X0mFIyUu9bO4t7L5tjZsQnpbtzJDrsZa3VjK3uqT3HJ7PDhUis4Gkr9F5jZLTDrvwaS43UNafapO9nJimDAqPVfZ6erO8CP/nSALzy2nXMmZfLrGz+ii2wrFWcG/fVWRLKBjcBe4HJgKvBDzODt7kF2fwKYCdwMBIDvAc8CK878kNVYK831Mr8ok9tWTR/rQ4kL3pQkbji/xP7Z4ZCwmZAb99UA9AnAygsymJSVyqpgv7VoZQVriEpHIMC8uHwCG/bU6AzIs7Drw0bu+8Netlc2cOW5Rdx7+ZyYWjlDKRWdaL7VtwKpwBWGYZwCXhaRDGC9iHw/uK0PETkPuBRYaRjG68FtVcBWEVltGMbG4TkFNdpSXU6eu235WB9GXCvxednxYQNH6lt4eW8NZXlepuaFZxun5afx5p0XDfnvtnp8lQ2hbixaF5bn4XRIv0tOqcgMw2BrxUke3HyQP/+tjixPMj++ZoHd0kQpFX+iCcDWABt6BVq/w8xmrQReGGC/Giv4AjAM4x0RqQg+pwGYUv24dmkxbxys45IHXqM7YHDTiuFbvP2i8nzuv2Iu5xZnD/7iIcpPd/PCbcvtxrpqYIZh8OqBWh7cfJBtlQ3kpqXwzTXlXLdsima9lIpz0RR4lAP7QzcYhnEEaAk+F/V+QfsG2U+phLdyRh4bv7qSi2flY2C2vxgu7mQn1ywpHrEi+dmFGQPOjFU92rsCfOOpdznW1MZ9l8/hjX9ZxS0rp2rwpVQCiOZbng00RtjeEHzuTPYri+J9lUpoBZlufn7dIlo6uvC49D/keOROdvL4zUspzfWOSLsVpdT4Fe033oiwTfrZfsb7icjnRWSbiGyrra2N8tCUim8afMW3mQXpGnwplYCi+dY3AJEaImUSOcM12H5Z/e1nGMbDhmEsNgxjcV5eXqSXKKWUUkrFvGgCsP30qtkSkcmAl8g1Xv3uF9RfbZhSSimlVEKIJgB7CbhURELXJLkaaAVeG2S/AhGx+xWIyGLM+q+XzuBYlVJKKaXiQjQB2ENAO/C0iKwWkc8D64EfhbamEJGDIvIr62fDMN4CNgCPisgVIvJJ4HHgDe0BppRSSqlENmgAZhhGA3Ax4MTs+XUv8ABwT6+XJgVfE+oazCzZr4FHge3Ap87ukJVSSimlYpsYxmATGceGiNQClVG+PBeoG8HDUaNPr2l8ifZ6TjEMI+Zn4Azx/gX67z3e6PWMP9Fc0yHdv8ZtADYUIrLNMIzFY30cavjoNY0vej0Hpp9PfNHrGX9G4ppq8xmllFJKqVGmAZhSSiml1CiLlwDs4bE+ADXs9JrGF72eA9PPJ77o9Yw/w35N46IGTCmllFIqlsRLBkwppZRSKmbEdAAmIrNFZJOItIhItYjcJyK9e5GpcUhEbhQRI8Lj1pDXiIjcJSIfikiriLwuIgvG8riVSUSmicgvRGSXiHSLyKsRXhPV9UvU73Ginnc80PtXbBsv96+kYTiXMSEi2cBGYC9wOTAV+CFmUHn3GB6aGpqLMJe1shwK+fOdwLeAb2CuH/pVYKOInGMYxvHRO0QVwRxgLfA24OrnNYNev0T9HifqecchvX/FpvFx/zIMIyYfwDeBBiAjZNsdQEvoNn2MzwdwI2AAaf087waagG+HbPMCtcC/jfXxJ/oDcIT8+Sng1TO5fon6PU7U846Xh96/YvsxXu5fsTwEuQbYYISsRwn8DkgFVo7NIalhdD6QATxpbTAMw4+5HNaasTooZTIMIzDIS6K9fon6PU7U804Uev8ax8bL/SuWA7ByzLSgzTCMI5iRZ/mYHJE6Ex+ISJeIHBCRW0K2lwPdwN96vX4fen1jQbTXL1G/x4l63vFG71/xaVTuXzFbAwZkA40RtjcEn1Pj2zHM8fV3MBdxvxZ4SEQ8hmE8gHkNTxuG0d1rvwbAIyIuwzA6RvWI1VBEe/0S9XucqOcdL/T+Fd9G5f4VywEYmGPwvUk/29U4YhjGBmBDyKaXRCQFuFtEfmy9LMKuMsBzanyJ9vol6vc4Uc875un9KyGM+P0rlocgG4CsCNsziRyRqvHvKSAHKMG8vukRpvNmAS2GYXSO8rGpoYn2+iXq9zhRzzue6f0rfozK/SuWA7D99BpjFZHJmDMV9kfcQ8UKA/MaOoFpvZ7rM+auxqVor1+ifo8T9bwTgd6/Yt+o3L9iOQB7CbhURNJDtl2N2ZPltbE5JHWWrgTqgEpgC3AK+LT1pIh4gHWY116Nb9Fev0T9HifqecczvX/Fj1G5f8VyDdhDwJeAp0Xke0AZsB74Ua8poWocEpHfYxawvov5m8bVwceXglOE20TkfuBbItJATyM8B/DTsTlqZQnejNYGf5wEZIjIVcGfXzQMoyXK65eo3+NEPe+4oPev2DZu7l9j3RDtLJupzQZewYw2jwHfAZxjfVz6iOrafRc4gDldtxXYDlzf6zUC/CtwNPiaPwMLx/rY9WGAWedi9PMoGcr1S9TvcaKedzw89P4V24/xcv+S4F+glFJKKaVGSSzXgCmllFJKxSQNwJRSSimlRpkGYEoppZRSo0wDMKWUUkqpUaYBmFJKKaXUKNMATCmllFJqlGkAppRSSik1yjQAU0oppZQaZRqAKaWUUkqNsv8HNa0Wa9reRtMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 3))\n",
    "plt.suptitle('GRU Model', fontsize=20, y=1.1)\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(np.arange(len(train_loss)), train_loss)\n",
    "plt.yticks([0.0, 0.5, 1.0], fontsize=15)\n",
    "plt.xticks([0, 50, 100], fontsize=15)\n",
    "plt.title('Loss', fontsize=20)\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(np.arange(len(train_acc)), train_acc)\n",
    "plt.yticks([0.75, 0.85, 0.95], fontsize=15)\n",
    "plt.xticks([0, 50, 100], fontsize=15)\n",
    "plt.title('Accuracy',fontsize=20)\n",
    "plt.subplots_adjust(hspace=1)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:05:34.557769Z",
     "start_time": "2020-07-28T11:05:34.551096Z"
    }
   },
   "outputs": [],
   "source": [
    "#loading LSTM transfer learning result\n",
    "lstm_transfer = pd.read_csv('lstm_transfer', index_col=0)\n",
    "\n",
    "gru_transfer = pd.DataFrame(train_loss)\n",
    "gru_transfer.columns=['train_loss']\n",
    "gru_transfer['train_acc'] = pd.DataFrame(train_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:10:21.954621Z",
     "start_time": "2020-07-28T11:10:21.708305Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(gru_transfer['train_loss'], label='GRU')\n",
    "plt.plot(lstm_transfer['train_loss'][:100], label='LSTM', color='orange', linestyle=':', linewidth=3.0)\n",
    "plt.xticks(fontsize=15)\n",
    "plt.yticks(fontsize=15)\n",
    "plt.title('Loss', fontsize=20)\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(gru_transfer['train_acc'], label='GRU')\n",
    "plt.plot(lstm_transfer['train_acc'][:100], label='LSTM', linestyle='--', linewidth=3.0)\n",
    "plt.xticks(fontsize=15)\n",
    "plt.yticks(fontsize=15)\n",
    "plt.legend(fontsize=15)\n",
    "plt.title('Accuracy', fontsize=20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:06:06.869456Z",
     "start_time": "2020-07-28T11:06:06.739318Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "95.85779517286366\n",
      "[[1449   89]\n",
      " [  38 1490]]\n"
     ]
    }
   ],
   "source": [
    "# evaluation with test dataset\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "\n",
    "targets = list()\n",
    "preds = list()\n",
    "correct = 0\n",
    "model.load_state_dict(torch.load('SmartFall_gru_transfer_learning_to_MobiAct.pth'))\n",
    "with torch.no_grad():\n",
    "    for X, y in test_loader:\n",
    "        X, y = X.cuda(), y.cuda()\n",
    "        output = model(X.float())\n",
    "        pred = output.max(1, keepdim=True)[1]\n",
    "        correct += pred.eq(y.view_as(pred)).sum().item()\n",
    "\n",
    "        targets += list(y.cpu().numpy())\n",
    "        preds += list(pred.cpu().numpy())\n",
    "\n",
    "test_acc = 100. * correct / len(test_loader.dataset)\n",
    "confusion_mtx = confusion_matrix(targets, preds)\n",
    "print(test_acc)\n",
    "print(confusion_mtx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:06:07.938225Z",
     "start_time": "2020-07-28T11:06:07.924026Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.94      0.96      1538\n",
      "           1       0.94      0.98      0.96      1528\n",
      "\n",
      "    accuracy                           0.96      3066\n",
      "   macro avg       0.96      0.96      0.96      3066\n",
      "weighted avg       0.96      0.96      0.96      3066\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(targets, preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T11:06:09.120684Z",
     "start_time": "2020-07-28T11:06:09.091571Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9436352121595947\n",
      "0.975130890052356\n",
      "0.9591245574509173\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score, precision_score, recall_score\n",
    "\n",
    "print(precision_score(targets, preds))\n",
    "print(recall_score(targets, preds))\n",
    "print(f1_score(targets, preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}