iui-group-l-name-zensiert/2-second-project/tdt/DataViz.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9c890798",
   "metadata": {},
   "source": [
    "# Change Scenario here.\n",
    "\n",
    "|     | GameType | HeightNorm | ArmNorm |\n",
    "|:---:|:--------:|:----------:|:-------:|\n",
    "| SYY |  Sorting |      ✅     |    ✅    |\n",
    "| SYN |  Sorting |      ✅     |    ❌    |\n",
    "| SNY |  Sorting |      ❌     |    ✅    |\n",
    "| SNN |  Sorting |      ❌     |    ❌    |\n",
    "| JYY |   Jenga  |      ✅     |    ✅    |\n",
    "| JYN |   Jenga  |      ✅     |    ❌    |\n",
    "| JNY |   Jenga  |      ❌     |    ✅    |\n",
    "| JNN |   Jenga  |      ❌     |    ❌    |\n",
    "\n",
    "Weights for the corresponding scenario are loaded automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1c9e114c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Possibilities: 'SYY', 'SYN', 'SNY', 'SNN', \n",
    "#                'JYY', 'JYN', 'JNY', 'JNN'\n",
    "cenario = 'SYN'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3c8b624",
   "metadata": {},
   "source": [
    "## Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5f120a31",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'  # this is required\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '2'         # set to '0' for GPU0, '1' for GPU1 or '2' for GPU2. Check \"gpustat\" in a terminal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3be386b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "glob_path = '/opt/iui-datarelease3-sose2021/*.csv'\n",
    "\n",
    "pickle_file = '../data.pickle'\n",
    "\n",
    "pd.set_option('display.float_format', lambda x: '%.2f' % x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "375756bc",
   "metadata": {},
   "source": [
    "# Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fe73e572",
   "metadata": {},
   "outputs": [],
   "source": [
    "create_new = False\n",
    "checkpoint_path = f\"training_{cenario}/cp.ckpt\"\n",
    "checkpoint_dir = os.path.dirname(checkpoint_path)\n",
    "\n",
    "win_sz = 5\n",
    "stride_sz = 1\n",
    "\n",
    "epoch = 50\n",
    "\n",
    "# divisor for neuron count step downs (hard to describe), e.g. dense_step = 3: layer1=900, layer2 = 300, layer3 = 100, layer4 = 33...\n",
    "dense_steps = 3\n",
    "# amount of dense/dropout layers\n",
    "layer_count = 3\n",
    "# how much to drop\n",
    "drop_count = 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0173497c",
   "metadata": {},
   "source": [
    "# Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ef82a419",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "def pplot(dd):\n",
    "    x = dd.shape[0]\n",
    "    fix = int(x/3)+1\n",
    "    fiy = 3\n",
    "    fig, axs = plt.subplots(fix, fiy, figsize=(3*fiy, 9*fix))\n",
    "    \n",
    "    for i in range(x):\n",
    "        axs[int(i/3)][i%3].plot(dd[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "556c7dde",
   "metadata": {},
   "source": [
    "# Loading Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "51195751",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "from tqdm import tqdm\n",
    "\n",
    "def dl_from_blob(filename, user_filter=None):\n",
    "    \n",
    "    dic_data = []\n",
    "    \n",
    "    for p in tqdm(glob(glob_path)):\n",
    "        path = p\n",
    "        filename = path.split('/')[-1].split('.')[0]\n",
    "        splitname = filename.split('_')\n",
    "        user = int(splitname[0][1:])\n",
    "        if (user_filter):\n",
    "            if (user != user_filter):\n",
    "                continue\n",
    "        scenario = splitname[1][len('Scenario'):]\n",
    "        heightnorm = splitname[2][len('HeightNormalization'):] == 'True'\n",
    "        armnorm = splitname[3][len('ArmNormalization'):] == 'True'\n",
    "        rep =  int(splitname[4][len('Repetition'):])\n",
    "        session =  int(splitname[5][len('Session'):])\n",
    "        data = pd.read_csv(path)\n",
    "        dic_data.append(\n",
    "            {\n",
    "                'filename': path,\n",
    "                'user': user,\n",
    "                'scenario': scenario,\n",
    "                'heightnorm': heightnorm,\n",
    "                'armnorm': armnorm,\n",
    "                'rep': rep,\n",
    "                'session': session,\n",
    "                'data': data \n",
    "            }\n",
    "        )\n",
    "    return dic_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "457bc16f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "def save_pickle(f, structure):\n",
    "    _p = open(f, 'wb')\n",
    "    pickle.dump(structure, _p)\n",
    "    _p.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9482bc78",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_pickles(f) -> list:\n",
    "    _p = open(pickle_file, 'rb')\n",
    "    _d = pickle.load(_p)\n",
    "    _p.close()\n",
    "    \n",
    "    return _d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "230fb3b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data...\n",
      "../data.pickle found...\n",
      "768\n",
      "CPU times: user 572 ms, sys: 2.57 s, total: 3.14 s\n",
      "Wall time: 3.14 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "def load_data() -> list:\n",
    "    if os.path.isfile(pickle_file):\n",
    "        print(f'{pickle_file} found...')\n",
    "        return load_pickles(pickle_file)\n",
    "    print(f'Didn\\'t find {pickle_file}...')\n",
    "    all_data = dl_from_blob(glob_path)\n",
    "    print(f'Creating {pickle_file}...')\n",
    "    save_pickle(pickle_file, all_data)\n",
    "    return all_data\n",
    "\n",
    "print(\"Loading data...\")\n",
    "dic_data = load_data()\n",
    "print(len(dic_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "effa570d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 393 µs, sys: 0 ns, total: 393 µs\n",
      "Wall time: 397 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Categorized Data\n",
    "cdata = dict() \n",
    "# Sorting, HeightNorm, ArmNorm\n",
    "cdata['SYY'] = list() \n",
    "cdata['SYN'] = list() \n",
    "cdata['SNY'] = list() \n",
    "cdata['SNN'] = list() \n",
    "\n",
    "# Jenga, HeightNorm, ArmNorm\n",
    "cdata['JYY'] = list() \n",
    "cdata['JYN'] = list() \n",
    "cdata['JNY'] = list() \n",
    "cdata['JNN'] = list() \n",
    "\n",
    "for d in dic_data:\n",
    "    if d['scenario'] == 'Sorting':\n",
    "        if d['heightnorm']:\n",
    "            if d['armnorm']:\n",
    "                cdata['SYY'].append(d)\n",
    "            else:\n",
    "                cdata['SYN'].append(d)\n",
    "        else:\n",
    "            if d['armnorm']:\n",
    "                cdata['SNY'].append(d)\n",
    "            else:\n",
    "                cdata['SNN'].append(d)\n",
    "    elif d['scenario'] == 'Jenga':\n",
    "        if d['heightnorm']:\n",
    "            if d['armnorm']:\n",
    "                cdata['JYY'].append(d)\n",
    "            else:\n",
    "                cdata['JYN'].append(d)\n",
    "        else:\n",
    "            if d['armnorm']:\n",
    "                cdata['JNY'].append(d)\n",
    "            else:\n",
    "                cdata['JNN'].append(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad62c63",
   "metadata": {},
   "source": [
    "# Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "55619c6e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def drop(entry, data=True) -> pd.DataFrame:\n",
    "    droptable = ['participantID', 'FrameID', 'Scenario', 'HeightNormalization', 'ArmNormalization', 'Repetition', 'Session', 'Unnamed: 0']\n",
    "    if data:\n",
    "        centry = pickle.loads(pickle.dumps(entry['data']))\n",
    "    else:\n",
    "        centry = pickle.loads(pickle.dumps(entry))\n",
    "\n",
    "    return centry.drop(droptable, axis=1)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d7be5822",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "left_Hand_ident='left'\n",
    "right_Hand_ident='right'\n",
    "\n",
    "def rem_low_acc(entry, data=True) -> pd.DataFrame:\n",
    "    if data:\n",
    "        centry = pickle.loads(pickle.dumps(entry['data']))\n",
    "    else:\n",
    "        centry = pickle.loads(pickle.dumps(entry))\n",
    "    \n",
    "    centry['LeftHandTrackingAccuracy'] = (centry['LeftHandTrackingAccuracy'] == 'High') * 1.0\n",
    "    centry['RightHandTrackingAccuracy'] = (centry['RightHandTrackingAccuracy'] == 'High') * 1.0\n",
    "    \n",
    "    left_Hand_cols = [c for c in centry if left_Hand_ident in c.lower() and c != 'LeftHandTrackingAccuracy']\n",
    "    right_Hand_cols = [c for c in centry if right_Hand_ident in c.lower() and c != 'RightHandTrackingAccuracy']\n",
    "    \n",
    "    centry.loc[centry['LeftHandTrackingAccuracy'] == 0.0, left_Hand_cols] = np.nan\n",
    "    centry.loc[centry['RightHandTrackingAccuracy'] == 0.0, right_Hand_cols] = np.nan\n",
    "\n",
    "    return centry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "da77d0a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "\n",
    "def pad(entry, data=True) -> pd.DataFrame:\n",
    "    if data:\n",
    "        centry = pickle.loads(pickle.dumps(entry['data']))\n",
    "    else:\n",
    "        centry = pickle.loads(pickle.dumps(entry))\n",
    "        \n",
    "    cols = centry.columns\n",
    "    pentry = pad_sequences(centry.T.to_numpy(),\n",
    "                                        maxlen=(int(centry.shape[0]/stride_sz)+1)*stride_sz,\n",
    "                                        dtype='float64',\n",
    "                                        padding='pre', \n",
    "                                        truncating='post',\n",
    "                                        value=np.nan\n",
    "                                       ) \n",
    "    pdentry = pd.DataFrame(pentry.T, columns=cols)\n",
    "    pdentry.loc[0] = [0 for _ in cols]\n",
    "    return pdentry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ac13ea7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def interpol(entry, data=True) -> pd.DataFrame:\n",
    "    if data:\n",
    "        centry = pickle.loads(pickle.dumps(entry['data']))\n",
    "    else:\n",
    "        centry = pickle.loads(pickle.dumps(entry))\n",
    "        \n",
    "    return centry.interpolate(limit_direction='both')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2f6b0535",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.preprocessing import timeseries_dataset_from_array\n",
    "\n",
    "def slicing(entry, label, data=True):\n",
    "    if data:\n",
    "        centry = pickle.loads(pickle.dumps(entry['data']))\n",
    "    else:\n",
    "        centry = pickle.loads(pickle.dumps(entry))\n",
    "        \n",
    "    return timeseries_dataset_from_array(\n",
    "        data=centry, \n",
    "        targets=[label for _ in range(centry.shape[0])], \n",
    "        sequence_length=win_sz,\n",
    "        sequence_stride=stride_sz, \n",
    "        batch_size=8, \n",
    "        seed=177013\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "be9a3bee",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:05<00:00, 16.33it/s]\n"
     ]
    }
   ],
   "source": [
    "acc_data = pd.DataFrame()\n",
    "\n",
    "for e in tqdm(cdata[cenario]):\n",
    "    acc_data = acc_data.append(e['data'], ignore_index=True)\n",
    "\n",
    "ddacc_data = rem_low_acc(drop(acc_data, False),False)\n",
    "\n",
    "eula = ddacc_data[[c for c in ddacc_data if 'euler' in c.lower()]]\n",
    "posi = ddacc_data[[c for c in ddacc_data if 'pos' in c.lower()]]\n",
    "eulamin = eula.min()\n",
    "eulamax = eula.max()\n",
    "eulamean = eula.mean()\n",
    "eulastd = eula.std()\n",
    "posimin = posi.min()\n",
    "posimax = posi.max()\n",
    "posimean = posi.mean()\n",
    "posistd = posi.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bf571416",
   "metadata": {},
   "outputs": [],
   "source": [
    "def minmaxscaler(entry, minimum, maximum):\n",
    "    return (entry-minimum)/(maximum-minimum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "dc70c74b",
   "metadata": {},
   "outputs": [],
   "source": [
    "euler_ident = 'euler'\n",
    "pos_ident = 'pos'\n",
    "\n",
    "def norm(entry, data=True) -> pd.DataFrame:\n",
    "    if data:\n",
    "        centry = pickle.loads(pickle.dumps(entry['data']))\n",
    "    else:\n",
    "        centry = pickle.loads(pickle.dumps(entry))\n",
    "        \n",
    "    euler_cols = [c for c in centry if euler_ident in c.lower()]\n",
    "    pos_cols = [c for c in centry if pos_ident in c.lower()]\n",
    "    \n",
    "    centry[euler_cols] = minmaxscaler(centry[euler_cols], eulamin, eulamax)\n",
    "    centry[pos_cols] =   minmaxscaler(centry[pos_cols],   posimin, posimax)\n",
    "    return centry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "45877405",
   "metadata": {},
   "outputs": [],
   "source": [
    "def drop_acc(entry, data=True) -> pd.DataFrame:\n",
    "    droptable = ['LeftHandTrackingAccuracy', 'RightHandTrackingAccuracy']\n",
    "    if data:\n",
    "        centry = pickle.loads(pickle.dumps(entry['data']))\n",
    "    else:\n",
    "        centry = pickle.loads(pickle.dumps(entry))\n",
    "\n",
    "    return centry.drop(droptable, axis=1)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d7a30d7b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:14<00:00,  6.67it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 13 s, sys: 1.93 s, total: 14.9 s\n",
      "Wall time: 14.4 s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "classes = 16 # dynamic\n",
    "\n",
    "def preproc(data):\n",
    "    res_list = list()\n",
    "    \n",
    "    for e in tqdm(data):\n",
    "        res_list.append(preproc_entry(e))\n",
    "        \n",
    "    return res_list\n",
    "        \n",
    "def preproc_entry(entry, data = True):\n",
    "    entry2 = pickle.loads(pickle.dumps(entry))\n",
    "    entry2['data'] = drop(entry2, data)\n",
    "    \n",
    "    entry3 = pickle.loads(pickle.dumps(entry2))\n",
    "    entry3['data'] = rem_low_acc(entry3, data)\n",
    "    \n",
    "    entry1 = pickle.loads(pickle.dumps(entry3))\n",
    "    entry1['data'] = norm(entry1, data)\n",
    "    \n",
    "    entry8 = pickle.loads(pickle.dumps(entry1))\n",
    "    entry8['data'] = drop_acc(entry8, data)\n",
    "    \n",
    "#     entry5 = pickle.loads(pickle.dumps(entry4))\n",
    "#     entry5['data'] = pad(entry5, data)\n",
    "    \n",
    "#     entry6 = pickle.loads(pickle.dumps(entry8))\n",
    "#     entry6['data'] = interpol(entry6, data)\n",
    "    \n",
    "    entry7 = pickle.loads(pickle.dumps(entry8))\n",
    "    entry7['data'] = slicing(entry7, entry7['user'], data)\n",
    "    \n",
    "    return entry7\n",
    "\n",
    "pdata = preproc(cdata[cenario])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c88f53a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb1087bc370>]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAA8rklEQVR4nO2deXxU5dX4vyf7DgmEAGEJ+ypliYgbbqC4VOhbW7VVqdWqtdq+9u3b2rr+1Nrt7b7j0mKtu1VREQVcURGCIKtsYQsQEgjZyJ55fn/cO2Gyzkwyk7kzc76fTz6Ze+9z75w8ufc59znnPOeIMQZFURQleokJtQCKoihKaFFFoCiKEuWoIlAURYlyVBEoiqJEOaoIFEVRopy4UAvQHfr372/y8vJCLYaiKEpYsW7duqPGmOy2+8NSEeTl5VFQUBBqMRRFUcIKEdnX0X41DSmKokQ5qggURVGiHFUEiqIoUY4qAkVRlChHFYGiKEqUExBFICKPi0iJiGzu5LiIyB9EZJeIbBSR6R7HForITvtnYSDkURRFUXwnUDOCfwLzujh+MTDG/rkJ+CuAiGQB9wGnATOB+0QkM0AyKYqiKD4QkHUExpj3RSSviybzgSeMlfN6tYj0FZFBwLnAcmNMGYCILMdSKE8HQq6w5thu2Pgs+JomXASmXAn9RgVXrnDHGFjzCJwo9f2c+GQ47WZISA2eXL5SXQrr/gHNjaGWxHdiEyD/m5DaL9SSKJ3QWwvKcoEDHttF9r7O9rdDRG7Cmk0wbNiw4EjpJNY+Bqv/DIiPJxior4J5PwumVOFPxQF443/tDV/61lbEOZNh7IXBksp3tr0C7/zU3vD13ggldv+lDYAZavl1KmGzstgYswhYBJCfnx/51XRMMyT1gTv3+9b+58PB1RxcmSIBdx8t+BtMvdp7+0PrYdG51v/DCbhc1u8f7oGUrNDK4gtVxfDrcc7pP6VDeitq6CAw1GN7iL2vs/2KoihKL9FbimAJcJ0dPTQLqDDGHAbeBC4UkUzbSXyhvU/pVgnRyJ8o9Zxu9pFjSro6RQ4/cUz/KR0RENOQiDyN5fjtLyJFWJFA8QDGmL8BS4FLgF1ADXC9faxMRB4E1tqXesDtOFbALxuwhIO92EH43F/arz1D+y8cCFTUUJfGVjta6DudHHsceDwQckQW3XiD0rcu73S7jxzSt2H7Pw5XuaMDXVmsKIoS5agicDJ+mXt0Cu4fPvaXU01uTpWrLeEiZ5SjisCpqLPYWTjGJOMUOfzEMf2ndIQqAkVRlChHFYGj0aihoBH2UUNOlast4SJndKOKwLFo1FBQ0KghRWmHKgJFUZQoRxWBk9GooSCiUUO9QrjIGeWoInAqGjUUJDTFREhwTP8pHaGKwNGos1gJd/S+DAdUETgWfYMKKuEaNdTyZu0wubyi97OTUUUQSej02zvhHjWkKEFAFYGTUWexEu6oyTIsUEXgVPTt3hk4biCz7wvHyeUFvZ8djSqCiEIfNu+Ee9SQogQeVQSORqOGFEUJPqoIHIu+gQYVjRrqZfR+djKqCCIJNV94R6OGFKUdAVEEIjJPRLaLyC4RubOD478VkQ32zw4RKfc41uxxbEkg5IkYNGooiGiKiV4hXOSMcnpcs1hEYoE/A3OBImCtiCwxxmx1tzHG3OHR/nZgmsclao0xU3sqR8Shb/dKh4TpfaH3s6MJxIxgJrDLGFNojGkAngHmd9H+auDpAHyv0g592LyjUUOK0pZAKIJc4IDHdpG9rx0iMhwYAbztsTtJRApEZLWILOjsS0TkJrtdQWlpaQDEDgc0aihohKuzuAWnytWWcJEzuultZ/FVwAvGmGaPfcONMfnA14Dficiojk40xiwyxuQbY/Kzs7N7Q9YQo4VpgkK4O4vD9n8crnL3PqVV9Ww+WEFNQ1OvfWePfQTAQWCox/YQe19HXAV8x3OHMeag/btQRN7F8h/sDoBc4Y86i5VwR2eqfnHj4gJWbDvSsv3sTbM4bWS/oH9vIGYEa4ExIjJCRBKwBvt20T8iMh7IBD722JcpIon25/7AmcDWtudGJWH75hcuhGvUkKaYiFReXn+wRQn8z9yxAFy5aDUlVXVB/+4eKwJjTBNwG/AmsA14zhizRUQeEJHLPZpeBTxjTKs7YgJQICKfAe8AP/eMNlL8RR8276izWHEmv3pzOwBrfnIBt18whrsvnQDAHc9uCPp3B8I0hDFmKbC0zb5722zf38F5HwGnBEKGyESdxUq4o/elL2wvruJgeS2zx2YzICMJgBvPHsnDS7fx4a5j1DQ0kZIQkOG6Q3RlsWPRN9CgEq5RQ5piIiK57alPAfjOua1jZR5cMBmAl9Z35nYNDKoIIgl91rzTiyYel8tQXBF8+64S3lTVNbKzpJr+aYnMHJHV6thXZlhxOG9uOdLRqQFDFYGT0aihsKGx2cWKrUe4cfFafvq65eb6/cqdzPrZSoqO14RYuhCiJkuv/OVdK0jyhxeNQ9r0V0JcDEOzknl/RymlVfVBk0EVgVPRt/sgE7ioIWMML64r4sYnClixrYRHPtgDwPKt1ltceU1jl+c3Nbtoanb5Jo9GDUUcj62y7pcLJ+V0ePxL04YA8MHO4C2kVUUQUejD5p3ARg19dqCcGxYXcOd/NnVbomkPLmfmwyu7fb4Svhwsr6WhycVX84fQNyWhwzbfOCMPgE/3Hw+aHKoIHI1GDTmdqx9Zzdufl7TbX1hazdbDlT5do6quibITDYEWzSHofdkVi96zzEILpnaYlQeArNQEslITeL6gKGhyqCJwLPp2H1QCFDVU09Dc4f7zf/1ey2e3icgbzS4f/ucaNRQRLN96hE8Kj7H4430AzPKyejivXwr1TS7qGju+33qKKoJIQu2w3glQriFjDLf8a51PZ/5+5U6e+mS/13Zj7lrKwfLabkmnhBffeqKAKxetBuCKGUOIielasV95qhU99J9PgxNGqorAyWjUkGNpbDYs21Lsc/ufvOTdh+AyRF64qZosvXLtrOFe21w2ZTAAb231/Z7zB1UETkXf7oNMz6KGXH7+f+JjBePDOd7baNRQJJHbN5kpQ/p4bZeaaK0q3nLIN7+Tv6gicDT+OItB7bC+EJioIX8VQWOz8SkO3Cc/QVgRZgqrl/nJJRParR3ojBvPGkFpVX1Q1qWoInAskTYgBJeSyjr+/M4uKrzE7LfQwzfq7gzYB3x4gL1etuV4uA2wej+7OW5HiOX1S+HiyQN9Pu+SKYM4a3R/nxWHP6giUCKCf3y0l1+9uZ3XNx0O+nc9V3CAGxYX+H3ejiPVXtv4Yj5SwpvvPrMegFvPHe3VSezJ9GGZPHnjaeT2TQ64TKoInIxfil+i2g57ot6q5tTobYVuAKKGfvjCRtbsKfP7Cj/+zyZcXl75myPtfxhuvowgU1pVzwc7jwLwlfwhIZbmJKoInEqkDQiOo3cL05w7ziqv+s729ovPPPFucVJncTjzkJ2H6q9fnx4UE093UUUQUejD5p3QFKZ55Lp8kuNjWbXraJftvM0YlPDFGMMrGw4BMM8P30BvoIrA0WiKiUghPjaGtKQ4rytD/Y1Gcj56X7px5wq6/sw8R80GIECKQETmich2EdklInd2cPwbIlIqIhvsnxs9ji0UkZ32z8JAyBMZRNqA4DBCUJgmMS6GusaufRheo5E0xUTY8uRqa3W5u8aAk+hx7TMRiQX+DMwFioC1IrKkg9rDzxpjbmtzbhZwH5CPdaess88NXpq9SCbi3iaDQIBSTHSHpPhYrykk1DIUmRhjeGn9QfqnJTJxcEaoxWlHIGYEM4FdxphCY0wD8Aww38dzLwKWG2PK7MF/OTAvADJFBppiIqy4/AuDO9x/ml11KiMpjjV7yrj0Dx/wzw/3dNg24kxDDjOBhIqPC48BcMkpzvINuAlENeRc4IDHdhFwWgftviwis4EdwB3GmAOdnNt5PtZoItIGhCBSXd9EQ5NlcvE9Dj+wUUO/+PIpXHnqMP5w9TRKqurYVFRBRW0jY3PSGZOTBsCvvvIFlmw4xO9X7mTLoa28tvEwT97Y+lHxrgg0aigccWeg/fpp3vMKhYJAKAJfeBV42hhTLyI3A4uB8/25gIjcBNwEMGzYsMBL6Ej8dRZHx8NmjKHsRAP90hIBOO//3m1J3+BDNp/ufmmnh+6+dAJXnnrynhyQnsQFE5LatRuVncYdc8dy/Zl5zPnNexTsO86Ee5e1ahN5pqEwU1hB4sV1RcTGCOMGpodalA4JhGnoIODp/Rhi72vBGHPMGONOtPIoMMPXcz2uscgYk2+Myc/Ozg6A2Eq48tSa/cx4aAXv2AVhPHP4uAfSGxev5aHX2rqpAs/VM4dy49kj/Tqnb0oCa34yh+vPzGunX15Zf5B/rd7HxqJyXWUcIVTXN1FZ18QF4weEWpROCcSMYC0wRkRGYA3iVwFf82wgIoOMMe61/5cD2+zPbwIPi0imvX0h8OMAyBQB6CDQGe4MjB05Xt2D54ptlpK4+7KJHV8kQFFDd1/ayfW9EBMj3PfFSfz3BWP50YsbWbu3jGMnGli16ygrbQWX2zeZa2YN5+bZI0+mIjBhahqK4vv5ve1WreHTR3VdfCaU9FgRGGOaROQ2rEE9FnjcGLNFRB4ACowxS4DvisjlQBNQBnzDPrdMRB7EUiYADxhj/F+7H6n46yyOsjfIl9YfbFcO0quNvdtdZJ3oWVeg4O45LemBu0uflHj+du2Mlm1jDIcq6nhrSzE/fX0bv1j2OZsOlvOXr8/o4ioOJuwUVuB5fp3lBv1iJ8EETiAgPgJjzFJgaZt993p8/jGdvOkbYx4HHg+EHBFFlA3q3WHdvuOs29c60jiYNvb7l2xpqTS25q4L6G/7KAKJiJDbN5nrzxzB1TOHMf6eZSzdVMxf3t3FreeOJmzfrMNU7EDgNl32S+24OL0T0JXFSkg5Vl3PJ4XHeHNLMat2Hm2p0HW4opaj1d7z97fF9/BL395U3Vd7eOk2/vnRXgA+/vH5DEhv7wwONEnxsXz8Yyum4pfLtrPtcHCKkijBo6HJxZZDlSyYOthxq4k96a2oIaVbRGbUUF1jM399dzfLNhez/UhVu+MXTszhra1H6J+WwNq75vDs2gPMGJ7JmBzvERed6YET9U18tPsYZyU14k8S36r6ZjKAhFjh0imD+OmCyfRN6b03u0F9Tkp78e8/YO9FvfbVAcK5g19v4PZj5WYGPnV0IFFF4FjCY1D3l2WbD3PLk58CMGZAGv89ZwzTh2WSlZpAZV0jX3vkE96yY66PVjewu/QEd/5nEwMzklj9kwu8Xt/lMq3SNCz57BAf7z7G02ssk86fZjdzmR/yup3Pp43oxw+unO7HmcGhuKIWZy5J8kZk3s/e+M3yHQDk52WFWJKuUUWg9BrPFRzghy9sBODB+ZO49vQ8r+c8uXofAMWVddQ3NZMYF9tle5ehZXEZwHefXk96Uhwz87JYs7eMRvcxH6fpxn6jdcqsvqquiYFR/pYdTmwvriQhNobZY5wd8q6KwMlEUNRQ0fGaFiXw4rfPYMbwzC7bx8cKjc2mxS4PsH5/ObNGdh2C98e3d/LbFTtatv/f5ZP42mnDaGx2MfHeNzF+vpm6fQ4x4oy+DbsUFE7RoCFiz9ETjBuYTqwflchCgTqLnUq4PfBeuNEu7fjg/EldKoGrZw6lT3I8m+6/iBXfn03flPiWY79ZvoN3tpdQVt3Q6flNtlno1nNHsfWBi1h4Rh7xsTGI+y3az251D7xOcfS5XF4qsDmVCLuffaGippHGZsM5Y509GwCdESi9wPbiKj4vrmLS4Ayv5qCHv3QKP11wCjExwugB6Wy490LqGpv5zr8/ZeXnJR2WiLzlnFFcNmUQEwdlMPInVhTzreeNJiXh5O3dfhz30zTkU+vg4zIm6t+yw4VlW6w1tMOzUkMsiXdUETiayIgauuflzQDcf/kkr21FpN04lxQfy6ML8ymurKPoeC3HqutxGTgltw9Ds1I6vE5yfMe+hO6ahpwy9jY781/cBQ7puBDw0W4r4+ilUwaFWBLvqCJwLGH3xHdI2YkG1uwto39aIqf2IHJCRBjUJ7lVOGVHPLRgMh/vPubdJuvj+OQyVkOn2FCNy0V4Dq6RcT/7Sn1TMxuLKgBISeg6wMEJqCJwMhHgLHaHbd5yjn+J2brLNbOGc82sLlL9+tlHxvY5OGXo9UywFxY4ZSrVy+Q/uIKq+iaumDHEMf6lrnDKi47SFgcO6t3hE9um/5X80Jbn6+6z2FIYMoTPcqrHG6XXUpZOJULuZ19odhmq6psAZ6eV8ERnBEpQeX9HKTNHZNEnOd574yAi7d7pfRvZ3eNuKBXB4m/OZMuhSl797BA1J5qi9i07XGhsPhnZ9ZX8ISGUxHdUETia8HYWl1RaeYPGDEgLsSQnMca/8MsWZ3EwhPGR/Lws8vOyWF14jJrjzUH5DpfLIBKEMNkoVFqeiiAnI/g5qQKBmoYci7MG9e7wpp0qwtsisN6gu+ORE2YEbgakJ1JeU0+Ty7B+/3HvJ/jBzU+uI/+hFSzbXMyukvb5n3pO+N/PvtJkh3bdefF40pNCOxP2FZ0RKEHj9Y2HALhwUk6IJfHAT6O/u3mMAzRBdrqV9tpl4Kt//5hvnjmCO+aOJamTUNnOMMa0evNvbHa11NS95cl1AFw9cxirdpUyb9JA7upm8Z1oxT0jSOthrYreRGcETibMo4bcKaW95QfqDdw96W8PtcwIHPBGe+GkgQzMSCIuNoYLJw3k7+8X8v3nNvjlQK6qa+TsX77Dfa9sbtm3vdiaATy0YDKPfyOfuRNzeHrNfg6U1fLIB3t4Y9Phzi6neGCMYe3eMg4crwEgITZ8htfwUVnRhsMGdX+pa2xm77Earu0qlLMX6a7t27TkGgqkNN1jbE46Y6fnwkfw569NZ9rQQh56fRsNTQUkJ8Qxb9JAr4uXXl5/kKLjtSz+eB/xsTH86OLxrD9QDsA5Y7MZmpXCeeMGcLC8lv5piVy5aDU/fHEjk7tYvOcTYX4/+8Kukmq+8rePW7b7pISHWQhUEShBYnWhtaoyy2nhcy3jkY9RQy2fHKAJ3NhK7cazR1JZ18Rf3tlFk8vw6meH+L+3UhmVncp9X5zUbuCuqGnk18t3kD88k0F9k3l01R6eXXuAqvomMpLiGGLnzBcRhmRa5/7p6mlc8ocPuO3p9Tx/8+kkxIXPW25v4w4ZBYiNEeZOcJBJ1AsB+a+KyDwR2S4iu0Tkzg6Of19EtorIRhFZKSLDPY41i8gG+2dJIOSJHMI3auhQuWUWckqd1pOmIf+ihtwvsk4d/r4/dyxbH5jHurvnAFa2yw92HuVbTxRQ19g6wmjZlsOU1zRyz2UT+f2VU3nkunxmj7MSop0zbkCHs6ahWSn84stT+OxAOY9/uKebUjpIiQYRTxPdyP6pxDhhGukjPZ4RiEgs8GdgLlAErBWRJcaYrR7N1gP5xpgaEfk28EvgSvtYrTFmak/liDycM6h3B3fB7v5pDpsR+El1nTWYxsU65KHuwMSSEBdDv7RE3rpjNnExwt5jJ/jmPwt4es1+rj9zREu7pZuKGdQniSlD+iAizJ2Yw9yJOfzsvxq7tGdfcsogpg3ryxubDnPLOaO6K3g3zwsfmjwSQU3O7RNCSfwnEC86M4FdxphCY0wD8Aww37OBMeYdY0yNvbkaCI9VFkq3ibGLsPdmWceukLbeYh99BkV2qUFnKbSOZR+bk87I7DTOH5/DrJFZ/G7FzpaUFOv2lfHejlKumTW83Zt/RlK818ijC8YP4LOiCkqq6gLzJ0QgnjOCYT3xp4SAQCiCXOCAx3aRva8zbgDe8NhOEpECEVktIgs6O0lEbrLbFZSWlvZI4LAhTKOG6puaWbfvOKc46K1I2mkC3zhWbQ2kaUnh5U57aMEp1DY0c+8rm2l2GR58bRvZ6Ylcf2Zet653/njL3r1ia4n/Jzsg9LY3aPKoFXHFjPB61+1V06eIXAPkA7/y2D3cGJMPfA34nYh0OPc0xiwyxuQbY/Kzs51f6KHHOGRQ7w6FpScA6J/upLdoC3979dgJqwhOvGPsvb79BaMHpPHfc8fwxuZiLv3DB2w4UM5dl0xoVaPBHyYMSmdcTjr/+HBPO9+DT4Tx/ewLyzYX8/rGk2G24bKi2E0gFMFBwDOj2BB7XytEZA5wF3C5MaYlhaIx5qD9uxB4F5gWAJkiBH+dxc6gzB48501yYB72lgHJt/5yKwJH4eP/+pbZo7hg/AA+L67i5tkjmT+1+457EeH2C0azs6Sa+17Z4u/Z3f7ecOGWJ9fx/LoiAF78dvhFVwVivrsWGCMiI7AUwFVYb/ctiMg04O/APGNMicf+TKDGGFMvIv2BM7EcyUoY83yB7Sh22IxAxP8h6Zi7LKZT3mj9kCMmRnh0YT7V9U0BSXVw2ZTBbNhvRQ99a/YIRg9I9/ncwtJq3nx3N98+t7vO5vAhLTF81g+46bHaMsY0AbcBbwLbgOeMMVtE5AERudxu9isgDXi+TZjoBKBARD4D3gF+3ibaSAlDmu1qiuNyfB8oeovumobCFREJaL6bm88ZRXJ8LI+t8i+U9I3Nh/nFss/ZWFQeMFmcSlJ8eM0GIEALyowxS4Glbfbd6/F5TifnfQScEggZIhJ/ncUOwBhrYZM7RNFJtJLGR9mOVjc4cBFB6Po1Oz2R6cMz2XSwwveTRFruhYeXbuOZm04PknShJz5Wwi5iCBx4iys23TFFOMB8UVHbCOCYsNF2+NFHJ+qbqGkITtrn7hP6//GEQRnsOFLdKt2yN7Lt8NvVhWXdczaHCXMm5DjuBcgXVBEoAeVAmRV3/0UHFuwWEY/i9d4f1qPV9RiHzLRaEeKBZlxOOg1NLvYdq/HeuAPcPqRI5LbzR4dahG6hisDR+BM1FDwp/GH51mLAmQtq/O2isKsP3EuMybEKDflet8DK3XrW6P4AvLs9PNcB1TU289HuozxfcIBvPVHA5oMVuFympQDTtbOGM2mwc9bO+EN4rZKJKrpjAgi92aC63pr2n+aAYjQd4odpqJUicIDZDXCEHKOyLUWw80g18yb7do4YF4lxMYzMTmXl5yUcKKvpWTbTXmRTUQW3PrWuZbbrZvnWI6QlxlFtJ5s7bWRWKMQLCKoIlICy8vMjzss4atPKouKDecUyDTmR0E7/UhPjyO2bzM6Sap/PMVhdfv2ZI7jn5c28sfkwN812fijpcwUH+OELG1u2vz93LP3SEjhR30RKQhzbDlfS2Ozi7DHZXDbFGQkWu4MqAifj1/PujBQTSXGxJKQ61+LoTw+VVtV71CEIfd86iTE5ab4rAnGX9RGumD6Ee17ezPs7jjpeEby28VArJXDtrOF894IxIZQoeDj3iY12HDCo+0tlXSPbj1QxdWjfUIvSIYL4NZ6XVtfTNyUxeAKFMWMGpLG7tNr36mjGIALJCbHkZCSyatdRXH5UVuttymsauO2p9QBkhFmeqe6gikAJGFsPVQI41/YrnW50yNHqBmeauRwQnjhmgBU5dKDM98gh9+zqutPzAHjVrmntRF781MqSc/PskZw7bgDgiG4PGqoIHE14FaZZs6cMgPPHDwipHF3hT2GaitpG0pPtVblhOEMLJqPtyCHfzEOWaUjs+/ma06y6VC/YuXmCRbPLcNtTn/Klv3zI9f9Yw8ptR3w6z+Uy/MMuwvM/F44LpoiOQRWBYwm/gWezvdp0aKYzZwT+vtBV1jY6zyzgEIU0eoClCHYc8S2EVGzTEFi1fAekJ/LBzqPsPXoiKPIZY7j8T6t4beNhdpdU8872Um5YXOBTyOt7O0opOm5FCMV7FCSK4AmBKgJHE2YpJtbuLePUvExnF+32ozBNVV0TaUkONA054H+dkRRPbt9kPi/2QRHYzmLPLr/z4vEAfOMfa9o1X/T+br7814/40l8+ZPFHe7sl390vb2bLoUr6psTz6T1z+ds10wH4Xw/nb2f8a/U+D9Elok1CblQROJUwSzFRWlXP8ZpGp7ywdoj1QPsuYGVtI+ktMwKn/GFOkQMmDc5gi485h6wZwckR9b+mD2FgRhJ7j9W0SmD3/Wc38PDSz1m37zibiiq4b8kWFvz5Q78cyyWVdfz7k/0ArPrR+cTFxjBv8iCGZCazfn85e7zMQt7+vBvFd8IcVQRKQNh62HIULzwjL7SCdIH48Sbd7DJU1TeRnugw05CDmJzbh8KjJ1oWVHWF5SNozQvftpLPPfjaVp4rOMAt/1rHf9ZbTtqCu+ew6f6LSEuMY8OBcq557BOflcHVj6wG4LdXfoE0j//ffV+cBMADr3ZeT+HVz9o7sN1yh2MOIV9RReBowqcwzdu2I86dfsCpGB8L01TVWcnzMpIdaBpyyIA0OTcDgG32S0DnWPK2HUiHZKbw2MJ8AH74wkaWbSkmPlbYcO9c+qclkpwQy6f3zCUhNoaPdh/ja4+u9irTR7uPsrv0BFmpCXxpWutykXMn5hAbI3y461in5z/6QaHX74hEVBE4lvBKMfHyhkNkpycyfmBGyGTwhj+FaSprrbfcFtOQU2xeTpEDmGzn1dnsk3mo4/R9F0zIYcO9c/n9VVP53ZVT2XT/Ra0y1ybExbD27jkkxMawurCMeb97n/KazmtE3PXSZgCe+ObMDo9/59xRNDS7+HDX0XbHKmob+ayogmFZKSy/YzYvfjty02W3RRWB0mMamlxU1DbSz4kx923wdRyttGcE6U6LGnIQAzKSyMlI5NP95V7btnUWe9I3JYH5U3NZMC2XpPjYdsf7JMez8f4LGd4vhc+Lq5j6wHIKS9uHrf52+Q72HD3BrJFZTM7tOPnbl6Zbs4S/v9/+zf8p269w5alDGZOTzozhVu6gSDYJuVFF4GTCJGrog51WNsmvnzYsZDL4QquVFl761l1XId2JpiEHRA25OW1EPz7efczD5NYBYqU/ienBgJoUH8u7PziX68/MA+D8X7/XalXzym1H+P3KnQD88erpnV4nr18KsTHC+zvaZ0BdttkqPn9rFJTTbIsqAqcSRlFD7mpVs8dmh+T7fUVEEB/NZ5W2IsjQqKEuOX1UP45W17O7gzd0N75XgOgaEeG+L07iklMGAjD3N+/R0OTiydX7uGFxAQBP3nAa2emdpwUREb6aPxSAdzyig45U1vFZUQWn5HZeWS+SJwYBUQQiMk9EtovILhG5s4PjiSLyrH38ExHJ8zj2Y3v/dhG5KBDyKL3Lym0lxMcKw/ulhloUr/g6jJ40DTl4TYQDON1ON/7x7s4dsHWNzVTVNQVsIvP7q6aR2zeZwqMnGHv3G9z98km/wFlj+ns9/9pZ1srmGxavbZnJfOnPHwLwzbPy2rWP4PG/hR4bQEUkFvgzMBcoAtaKyJI2RehvAI4bY0aLyFXAL4ArRWQicBUwCRgMrBCRscaYyK1l5xfOjxpyuQybDla0rDR1MtLFVltaTENOVAQOGpmG90thUJ8kVheWca2dQ8iTZpfBbcHxJ3y3K+JjY3j/h+fx2sZD7DxSTW5mMpdOGUSGj/+riYMzuGLGEF5YV8S5//cuaYlxHKqoIycjkQVTcwMiY7gRCE/YTGCXMaYQQESeAeYDnopgPnC//fkF4E9izb/mA88YY+qBPSKyy77exwGQqz1v3gUH2q9kdCSl26Gfn7bKA2vg0bnBkacTahuaeDGhiqzGBHjU2TOCf1FO7oHOI048qaxtIkYgNcF2Xq7+G2x5OXjC+Ur5Pu9tehERYfrwTDYWlXd4/EhlHX2A+bEfUrbjJng0MFFlsViDBwAHAO8LhlvxS2O4OeMENSeaiamB9Mw4hmWlII/9ol3b24+d4OsJDQz4PBGOOCB9yhWPQd/A+uMCoQhysf4VboqA0zprY4xpEpEKoJ+9f3WbcztUySJyE3ATwLBh3eyEuCRIcPZg1ULudJhwme/tp34dtr0aPHk6YX9ZFSdMEuOy+kKCsyNsaqSOyvg+ZI+YAgPGd9m2tKqerNREYpL7wPSFUL6/l6T0woCJkDsj1FK0YtLgDF7feJij1fX0T2ttn3/0gz30b76IybKHhGZxzPMXA4wZ4tsstiHGxQkTQ0NMskPkD/yU0NlPrgfGmEXAIoD8/PzuecwuuCeQIjmLU2+wfnqR+qZmLr57GakJsWy+8SLHe9Nuuf9N/mvMEO6/fJLXtrtLqxmZnWr9TZf/oRekC19mj8nml8u28/a2Er566tCW/Sfqm3h14yES06+n6HgtfePj2XDdhSGUtHv8/bkN/OfTg9wwbgT3XDYx1OIEhUA4iw8CQz22h9j7OmwjInFAH+CYj+c6mtc3HuasX7zNF/+4yq/c7JHAs2utieA1pw+PuFjr3aXVLbV5la6ZNDiD3L7JvLW1dZrnpz7ZT2lVPd86eyQAzc3OinjylUD5NpxMIBTBWmCMiIwQkQQs5++SNm2WAAvtz1cAbxvLXb8EuMqOKhoBjAHCxIgPNQ1NfOepTyk6XsumgxVc0Ca2OdJ56PVtANx+fniU7/NVWS3bXMzxmkay05y4hsB5iAhzJ+awalcpNQ3Wiuyahib+/v5uTh/ZryWsuCmKno1wo8eKwBjTBNwGvAlsA54zxmwRkQdE5HK72WNAP9sZ/H3gTvvcLcBzWI7lZcB3wili6B8f7gXgu+eP5qzR/WlodvGzpdtajtc2NPPoB4UcKq/167obDpTz+sbDXS/SCTEFe8toaHJx7rjsVom9nI67T+sam/nnh3uobWimur6Ju17axJV//5hdJdUU7LUK7MyfFp0RJN3hsimDqGt0sej9Qg6U1XDHsxs4Wt3ADy4aS5xdmixcX5Lc7w+RPC8IyBNsjFkKLG2z716Pz3XAVzo596fATwMhR2/zr4+tCI7/njOWhmYX4+9ZxqOr9nDj2SMZ2CeJ1XuO8dDr29h6uJLffHWqz9f92dJtfLKnjEtOGchfvu4sx6CbJ+y//SeXTAixJL4jHiWL//T2Lv70zi5SEuJ4a2sxK7ZZi4uu/+caDpTVMiA9UU1DfpCfl8WlUwbxuxU7+d0Ka4Xv/KmDmTE8i+KKOgCaXL5Xh1N6l/B5lQsAiz/ayxr7bW/GsExmj83udvx7fVMzxZV1zB6bTUyMkBQTy++vmsr3ntnAZX9cRcHdc6hrsCY3x6p9C1l0435zWrqpmI92H+WMUd4XyfQm1fVNLPnsEPGxwtic9FCL4zOeb3TulbCPf7iHz4ur6JMcz1mj+/P6JivNQElVfQgkDG/uvWwi+46dYNrQTL519kiGZiUDJ6t8xcWGdyKDCHODtSKqFMH6/cd5faP1oLt/f2FIH35xxRS/s2ZuO2xVZsofntmyb/7UXH65bDsHy2t5ZUP3fd4uYzg1L5Oi47X8ctl2Xrq1n6OcsUvtvrvy1KFeWjoPt7XNXZzk8+Iq+qUmsOauOcTGCHeUVDHnN++HUMLwJScjidduP7vd/ozkeCYOymDhGcNDIFXPcc6TFzzCW0X7ye+umtZu32dFFcz73Qfc9dImv2zyP3/D8gW0XdK+5LYzAfjeMxsotd8q/R3Dmw0kJ8Rx67mj2HCg3LdygL3IWntW9YMwK+ztVqZNzS4KS09WqZo5IotY2449ekA6f/raNF67/ayQyBiJxMfGsPR7Z3Plqc5OShjNRJUi6IjXv3sWKQmx/PuT/Vy5aLXPymDzwUoyU+KZNrRvq/390hL5/tyxwMmoGn9xuQyxAueOGwCcHHidgDGG59cVkds3uVXe+HChtKqey/64ioZmF7l9LdPFqXlZrdpcNmVwp2mMleijxVnsoFl5oIl6RTBpcB/W3T2XuBhhzZ4yfr7sc6/n1DVakSZTh/bt8Oa4/fzRjPOwnR8qr6WusZnKukb2H6vh3e0lvLu9hE8Kj1F0vP3ag2aXITZGGJKZzMCMJNbscY4iWH+gHICzRjvLb+ELAizbUtwyw7pixhBE4Mww/FsUJZBElY+gM5ITYtlw34VMvu9N/v5eIV+ZMbRLJ/KqnVZ1o4smDezwuIiw9Htnc8uT61i+9Qg7jlQz/p5lnV7vvHHZ3PvFSYzoby1fd9m520WEWSOzeG9HKQ1NLhLiQq+33X/712eF3zS/rc7+9rmjWDAtt6XfFaUrInc+oIqghbTEOP52zXRuefJTbn96PW98r73Ty80qu8zdLDsFb0fExgiPXJfPgbIaVm47womGZhLjYkhNjGNUdhpxsUJFbSP/Xr2PFdtKeGf7u9xyzijuvHh8y4wArIpKL284xKufHeLLM4Z0+n29xaL3C4mPFaYM6RtqUfzGs8j6r66YQlJ8rCoBxSvRsLJYFYEH8yYPIj5WOFzR9QKwp9bsJyUhljwfBpGhWSl848wRnR4/b9wANh+s4LI/ruJv7+0mNSGWZmOIsRXB7DH96ZeawIe7j3apCB5euo0zR/fnnCAWh6lvskxinpFS4URdoxXHfumUQXwlP/winhQlWITe1uAwvjZzGOU1jVz59487dBwXHa+hockV0AF3cm4f1vzkAgB+vXwHhaUniLXtGO40v+v2He/0/H3HTrDo/UJuf+rTgMnUEU/bNV0vnJQT1O8JNv9jO/MVxRdaTIoRPDFQRdAG95v4J3vKWPzR3nbHH19l7VsQ4PQDAzKSeOKbM1u23aYhsKpA7TtW02lSu+V2sq8JgwKT670zth+xnKzXdzHDCQdyM5NDLYKiOApVBF1w/6tbWypVuXl+nZVx8/zxAwL+fbPHZjPSNjd51oCdPdaKanH7Jtqy9XAlQJe1WgPBhgMVJMXHEB/mK0QT42JDLYIShkSyryC8n+gg4k6kdsu/1rXs+2j3Uarqmrj8C4ODNhguus7KLTR92Ek7/KjsNDJT4vnMDt1si3uV7GsbDwc1sZcxhkmDwze+vn9aAmNzNH+Q4h8RvHygBVUEnXDLOSOJixE+LjzWYp+/+yWrSPbt548O2veOHpDOurvncK9HAQwRYVR2WsuA74kxptUq2UKPmUQgKams4/PiKoZnOaBUXzdZ+r2zef7mM0IthqI4DlUEnRATIzx5o1Vx88t//YjHVu2h8OgJ8vqlMCbIidb6pSW2+CrcDO+Xyr5j7X0Ee4/VUFHbyHnjLOd1fVNwMjy6ldCUIeE7IxiQnkSfFAcWo1ccjjtwI8RiBBFVBJ0QI8IXPGLlH3xtKwB/vSY0aaGH90uhuLKO2obW5RrcufPdGUobmoOjCAptRTBtWHiGjiqK0jm6jqATYkVavQHcfekELpw4kGH9QmMaGWabZIqO17SakWwsqiAtMY6Jg62IoYYgzQgOHrfWVmjEjRKtRPCEQGcEnSHSeip449kjQ6YEgJbc7gfa5CbaeLCCybkZJNrpJ4KlCGobm0lJiKV/WnAjkxTFaUSySciNKoJOEBFHhYsNtWcEB8pOrnp2uQw7iquYMCiDpHgrJHKpXVgl0Cz57BCpYVSSUlEU3+mRIhCRLBFZLiI77d/tDMgiMlVEPhaRLSKyUUSu9Dj2TxHZIyIb7J+pPZEnEHguJnbSm0B2WiJJ8TGtFpUdLK+ltrGZsTnpjB8YXAd2RW0jMQ7qD0XpLVoWFkfw/d/TGcGdwEpjzBhgpb3dlhrgOmPMJGAe8DsR6etx/H+NMVPtnw09lCdgCJbD2CmICHn9UtlRcjI8dMshayHZ2Jx04mJjyMlIJBj17l0uQ0OTSwuLKEqE0lNFMB9YbH9eDCxo28AYs8MYs9P+fAgoAYKXGS2AOEcNWMwYnsmn+463LBpbt6+MhLgYJudajmJBMAReExwst8xRqQm6IldRIpGeKoIcY4zbKF0MdJmNTERmAgnAbo/dP7VNRr8VkU49kSJyk4gUiEhBaWlpD8X2DQdNCACrpGJ1fRPb7JQSn+4vZ0pun5aUCSIEZUbwoZ3aYnBfjRhSoo+WCmWOezUMHF4VgYisEJHNHfzM92xnrFSdnQ5DIjII+BdwvTHGHdryY2A8cCqQBfyos/ONMYuMMfnGmPzs7OBPKKyoIWf9490lFT/ZU8bhilrW7z/OGaNO1kSIEQnCfABq7LULZ4/RSl6KEol4DQMxxszp7JiIHBGRQcaYw/ZAX9JJuwzgdeAuY8xqj2u7ZxP1IvIP4Ad+SR9lDO6bzNCsZNbsOUaMgMu0z4LqCsKUYJedtiIlQaOGlOhDdGWxV5YAC+3PC4FX2jYQkQTgJeAJY8wLbY4Nsn8Lln9hcw/lCRjBMLEEgrNGZ/P+jqM88fE+xgxIY2T2ySRqInQxJ+s+7++wTHFOKJWpKErg6emT/XNgrojsBObY24hIvog8arf5KjAb+EYHYaL/FpFNwCagP/BQD+XxykiPqmL9UhPaHc+zF40NyHDmwqlrZw2ntrGZPUdPcN3pw1sdEwmKHiBGhDNHd16WU1GU8KZHc31jzDHggg72FwA32p+fBJ7s5Pzze/L93eGV286kocnFp/vLGd7BSuFrT8/jjNH9GdNF8fpQMnFwBpecMpCyEw3tSlcK0mFVtZ5S09DMsCyt7atEJyedxZFL1Bl905Os7JNzJ3Yc4BQbI4wNcnbRnvKXr3ec+C4YM4IDZTUcra4nKV7NQooSqejTHUHEiATct7HLXsAWzgVpFKUntMwEIthbrIogghACHzXkDh09JVcVgaJEKqoIIokgmIbW2vUOUnRVsaJELKoIIgiBgGuC3fYaAk0/rUQr7oWlkWsYUkUQUYgEPtdQfZOL00ZkkawzAiVKCUYkntNQRRBBCIFfCFfT0KRKQFGIaF+xKoJIItBRQxU1jWw+WElCrN4mSvTitJxjwUCf8AhCJLBRQ8WVdQBMGJQRsGsqiuI8VBFEGIG0DNU0NAEwdWjfAF5VUcKTqE5DrYQPEmDT0BF7RuCuh6wo0Yg6i5WwwnpfCdxNu+eoVR+5f1r75HyKEm1EsqtAFUEEEegKZc0uq35QXn9NOKdEL+osVsKKQFcoq2loJi5GiNeoIUWJaPQJjyACHTX0/LoiVQKKYhPJ8wJ9yn1gaFZ4FG0P9IIyYyA1MeoylStKK6LBWaxPuRdWfP+c8Em4FmDTUH1jM1fkD/HeUFGigEh2FfRoRiAiWSKyXER22r8zO2nX7FGmconH/hEi8omI7BKRZ+36xo5i9IA0BvcNpxlBYFSBy2Woqm8KHyWoKEFCncXeuRNYaYwZA6y0tzui1hgz1f653GP/L4DfGmNGA8eBG3ooT1QTyPv1g11HAYiNUeuhokQ6PX3K5wOL7c+LgQW+niiWmj0feKE75yvtCWSuobIT9QBcesqgwFxQUcKcSJ4Z9FQR5BhjDtufi4GOCwFDkogUiMhqEVlg7+sHlBtjmuztIiC3sy8SkZvsaxSUlpb2UOzIJJAVytyVyfqmxAfkeoqiOBevzmIRWQEM7ODQXZ4bxhgjIp2NQsONMQdFZCTwtohsAir8EdQYswhYBJCfnx/5bvxuIHKyxnBPWba5GEBTUCtKFOBVERhj5nR2TESOiMggY8xhERkElHRyjYP270IReReYBrwI9BWROHtWMAQ42I2/QbGprG2ipKqe2obmHg/gVXXWRC1dw0cVJeLpqWloCbDQ/rwQeKVtAxHJFJFE+3N/4Exgq7HCW94BrujqfMV3rphhhXpW1jX2+Fq1Dc1cNCknou2iiqJY9FQR/ByYKyI7gTn2NiKSLyKP2m0mAAUi8hnWwP9zY8xW+9iPgO+LyC4sn8FjPZQnqhmQYdUVPlxR16PrGGPYfqSKlASdDSiKm0h+J+rRk26MOQZc0MH+AuBG+/NHwCmdnF8IzOyJDMpJ+iRbjt3C0uoe1RDYfqQKCGy6CkVRnIsGiUcQ7kpitY3NPbpO2YkG4KSpSVGUyEYVQQThzgu0bu/xHl3H7Sh2zzAURdEKZUqYkGpHCjU0u3p0nWfXHgCgb7LjMn4oihIEVBFEECLCKbl9OFHf5L1xF8SIECMwrF9KgCRTlPAnkp3FqggijNTEWN7ZXsrR6vpuX6OwtJrpwzrMH6goSgSiiiDC+MKQvgDsPNK9FcaVdY0UHj2hEUOKEkWoIogwLpsyGIDqbpqHyqqtiKFLNNmcorQigi1DqggiDXeSuA/tNNL+ssNeQzA0S/0DihItqCKIMIZkWkV0Yrrp2fpkTxkAI/unBkwmRYkE1FmshA0iwsCMJN7cUtyt82samumXmsCYnPQAS6YoilNRRRCBuIzhYHktJZX+5xx6f0cpaUmaY0hRoglVBBHIXZdOAOB4jf9ZSONjI3n9pKJ0n0h+MlQRRCCZKdaK4O6Yhw5V1HHG6P6BFklRFAejiiACmT7cWgxWUuWfaWjzwQoamlwkxOptoShtUWexElakJcaR1y+FpZv8mxEcLK8F4MKJnZWeVhQlElFFEKHExAhlJxpo8iMBXcFeK3R0SKauIVCUaEIVQYSy8PQ8AHaXnvD5nK2HKwHITk8MhkiKojgUVQQRyugBaQC8s73E53NqGpo5a3T/Hhe+VxQlvOiRIhCRLBFZLiI77d/tUlaKyHkissHjp05EFtjH/ikiezyOTe2JPMpJzhjVj4TYGI7XNPjUfseRKtbvLyctUdcQKEpHSAR7i3s6I7gTWGmMGQOstLdbYYx5xxgz1RgzFTgfqAHe8mjyv+7jxpgNPZRHsRERslITOFbtmyLYXmzlGLposjqKFSXa6KkimA8stj8vBhZ4aX8F8IYxpqaH36v4QGZqAi+sK2qpQdwV6/ZZ5S3PHKVrCBTFk36p1rqctMTINZn2VBHkGGMO25+LAW+vk1cBT7fZ91MR2SgivxWRTr2UInKTiBSISEFpaWkPRI4ezh+fDcBaOxqoK9xpq/ulqaNYUTy56ZyR/OfWM/iv6UNCLUrQ8KoIRGSFiGzu4Ge+ZztjjAE6rWYiIoOAU4A3PXb/GBgPnApkAT/q7HxjzCJjTL4xJj87O9ub2Apw9cxhAGw5VNllu/qmZl5YV8SEQRnExkSuHVRRukNiXCzTh2USH8ELLb16Bo0xczo7JiJHRGSQMeawPdB3FaLyVeAlY0xLAhyP2US9iPwD+IGPcis+MCQzheT4WP6wcie3nTeahLiOb+SttqIYaqewVhQluuipilsCLLQ/LwRe6aLt1bQxC9nKA7Hc8QuAzT2UR2nDxZMHArBy25FO27hrENx63uhekUlRFGfRU0Xwc2CuiOwE5tjbiEi+iDzqbiQiecBQ4L025/9bRDYBm4D+wEM9lEdpwx1zxwLw1/d2d9pmm72QbOKgjF6RSVEUZ9GjoHFjzDHggg72FwA3emzvBXI7aHd+T75f8c7QrBQGpCeysaiC4ycayLQjIDzZcaSalITYTk1HiqJENvrkRwH3XDYRgD+8vbPdseKKOrYdruTcceqAV5RoRRVBFHDZlEEA/OPDvTS7Wgd2PfJBIQDnj9eFZIoSragiiAJEhK/mWzHQj60qbNlfWlXPY6v2ACeVhaIo0Ycqgijhrkst89DDSz/nL+/uoq6xmasfWQ3AnRePJyk+cldNKorSNaoIooQ+yfE8tjAfgF8u2874e5axq6SarNQEbp49MsTSKYoSSjTVZBRxwYQcdj98CSu2HWHVzqOM6J/KN87Ii+isioqieEcVQZQRGyNcNGkgF00aGGpRFEVxCGoaUhRFiXJUESiKokQ5qggURVGiHFUEiqIoUY4qAkVRlChHFYGiKEqUo4pAURQlylFFoCiKEuWIVWo4vBCRUmBfN0/vDxwNoDiRivaTd7SPfEP7yTd6o5+GG2Pa5ZwPS0XQE0SkwBiTH2o5nI72k3e0j3xD+8k3QtlPahpSFEWJclQRKIqiRDnRqAgWhVqAMEH7yTvaR76h/eQbIeunqPMRKIqiKK2JxhmBoiiK4oEqAkVRlCgnqhSBiMwTke0isktE7gy1PKFERPaKyCYR2SAiBfa+LBFZLiI77d+Z9n4RkT/Y/bZRRKaHVvrgISKPi0iJiGz22Od3v4jIQrv9ThFZGIq/JVh00kf3i8hB+37aICKXeBz7sd1H20XkIo/9Ef08ishQEXlHRLaKyBYR+Z6933n3kzEmKn6AWGA3MBJIAD4DJoZarhD2x16gf5t9vwTutD/fCfzC/nwJ8AYgwCzgk1DLH8R+mQ1MBzZ3t1+ALKDQ/p1pf84M9d8W5D66H/hBB20n2s9aIjDCfgZjo+F5BAYB0+3P6cAOuz8cdz9F04xgJrDLGFNojGkAngHmh1gmpzEfWGx/Xgws8Nj/hLFYDfQVkUEhkC/oGGPeB8ra7Pa3Xy4Clhtjyowxx4HlwLygC99LdNJHnTEfeMYYU2+M2QPswnoWI/55NMYcNsZ8an+uArYBuTjwfoomRZALHPDYLrL3RSsGeEtE1onITfa+HGPMYftzMZBjf472vvO3X6K1v26zTRqPu80daB8BICJ5wDTgExx4P0WTIlBac5YxZjpwMfAdEZntedBYc1KNLW6D9kun/BUYBUwFDgO/Dqk0DkJE0oAXgf82xlR6HnPK/RRNiuAgMNRje4i9Lyoxxhy0f5cAL2FN1Y+4TT727xK7ebT3nb/9EnX9ZYw5YoxpNsa4gEew7ieI8j4SkXgsJfBvY8x/7N2Ou5+iSRGsBcaIyAgRSQCuApaEWKaQICKpIpLu/gxcCGzG6g93RMJC4BX78xLgOjuqYRZQ4TG1jQb87Zc3gQtFJNM2kVxo74tY2viMvoR1P4HVR1eJSKKIjADGAGuIgudRRAR4DNhmjPmNxyHn3U+h9qz35g+WV34HVrTCXaGWJ4T9MBIrSuMzYIu7L4B+wEpgJ7ACyLL3C/Bnu982Afmh/huC2DdPY5k2GrFssTd0p1+Ab2I5RncB14f67+qFPvqX3QcbsQa0QR7t77L7aDtwscf+iH4egbOwzD4bgQ32zyVOvJ80xYSiKEqUE02mIUVRFKUDVBEoiqJEOaoIFEVRohxVBIqiKFGOKgJFUZQoRxWBoihKlKOKQFEUJcr5/8rkhou4w5iwAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = drop(cdata[cenario][0]['data'], False)\n",
    "a['left_OVRHandPrefab_pos_X'].plot()\n",
    "plt.plot((a['LeftHandTrackingAccuracy'] == 'High')*1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b9518087",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb1086d6820>]"
      ]
     },
     "execution_count": 22,
     "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": [
    "b = rem_low_acc(a, False)\n",
    "b['left_OVRHandPrefab_pos_X'].plot()\n",
    "plt.plot(b['LeftHandTrackingAccuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "09687aab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb108669be0>]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAaDUlEQVR4nO3de5RcZZnv8e/T3bmSzrU7kEvnQghoAxqgBUZAcVRMokNwCUq8IYMywyLncI7OuFAchoNrnXXUc5zRIeNMGB3UGY0MHjSjYTLKMBOYQzDNLVdCQhJIh4R0rgRy7e7n/FE7odKpTu3q1K7a767fZ62sVO3aXfX0u9/69a5377e2uTsiIhK+umoXICIi5aFAFxHJCAW6iEhGKNBFRDJCgS4ikhEN1XrhpqYmnzJlSrVeXkQkSE8//fROd28u9FjVAn3KlCm0t7dX6+VFRIJkZi/39ZiGXEREMkKBLiKSEQp0EZGMUKCLiGSEAl1EJCOKBrqZ/cDMdpjZqj4eNzP7rpltMLMVZnZx+csUEZFi4uyhPwDMPMXjs4Dp0b9bge+dflkiIlKqouehu/tSM5tyilXmAD/y3PfwLjOzkWY2zt23lavIYB1+A363AI4ejP8zk98N096XXE1Z8eIS6ChhHoPVwTs/AaPPTq6muHp64Km/gYN7ql1JaVqvhbMurHYVcgrlmFg0AdiSd78jWnZSoJvZreT24pk0aVIZXjrlNi2FR/9HdMdi/IDn3jDTnkiyqmxY/Cew9xXitSuAw9EDcM3Xk6wqnl3rYclXojtx6682hz2b4WP3V7sQOYWKzhR19wXAAoC2trbsX1nDu3P///ET8fZsFn4Kdm9Ktqas6OmBGZ+G6+bHW/9/TgDvSbamuHqifnHDD+H866paSmx/dclb/VlSqxxnuWwFWvLuT4yWiYhIBZUj0BcBn43Odrkc2KfxcxGRyis65GJmPwWuBprMrAP4c2AAgLv/DbAYmA1sAA4ANydVrIiI9C3OWS5zizzuwO1lqyhL+nUB7uwfWiiPfrRTai6InpY6SpSa9pO+aKaoiEhGKNArIuapaRbKKWwpUVJzpbBtg9reIdVauxToIiIZoUAXEckIBXqiQj5wl3IhH3AOdhuHWnftUKCLiGSEAr0SYh/80oGn0pTQXqk8AJnGmvqQyvaT3hToIiIZoUAXEckIBXqSgj34JckKtF+oP6eeAj119KaJR2cQifSmQK8IzRRNREntlcK2DWp7h1Rr7VKgi4hkhAJdRCQjFOiJ0pitFBDsWH6oddcOBXraBPtmr7CQp/6LJESBXgmaKSoFBbS9gzqAW7sU6BKwUqb+J1eFSFoo0EVEMkKBLiKSEQr0JOnAXYJCnimaljpKlJr2k74o0CtCM0WlgKC2d0i11i4FuoQr9Kn/ImWmQBcRyQgFuohIRijQE6WDSFJAsAcXQ627dijQ0ybYN3uF6QwikZMo0CtBU/8TootEV0wq2096U6CLiGSEAl1EJCMU6EnSeLgUFGi/UH9OvViBbmYzzWydmW0wszsLPD7JzB4zs2fNbIWZzS5/qbVCb5p4Qp76L5KMooFuZvXAfGAW0ArMNbPWXqt9DXjQ3S8CbgT+utyFhk1T/6WAoLZ3SLXWrjh76JcCG9x9o7sfARYCc3qt48Dw6PYI4NXylSjSB039FzlBnECfAGzJu98RLct3D/BpM+sAFgP/pdATmdmtZtZuZu2dnZ39KFdERPpSroOic4EH3H0iMBv4sZmd9NzuvsDd29y9rbm5uUwvLRIYjeVLQuIE+lagJe/+xGhZvluABwHc/UlgMNBUjgJrjt7s8WimqMhJ4gT6cmC6mU01s4HkDnou6rXOK8D7Aczs7eQCXWMqx2imqBQU0PYO6gBu7Soa6O7eBcwDlgBryZ3NstrM7jWza6PVvgR8wcyeB34KfM5du5qStNCn/ouUV0Ocldx9MbmDnfnL7s67vQa4oryliYhIKTRTNEn6kCIFBdov1J9TT4EuIpIRCvSKKGWmqPaC4snA1P+gxvVDqrV2KdAlXJopKnICBbqISEYo0EVEMkKBnqiUjdlKOgTbLYItvGYo0CuhlJmiaTtwl1aZmPof0Lh+QKXWMgW6iEhGKNAlYJr6L5JPgS4ikhEK9CRpPFwKCrRfqD+nngI9TTRTtASaKVpZIdVauxToIiIZoUCXcGnqv8gJFOgiIhmhQE9UysZsJR3SNpYfW6h11w4FuohIRijQK0FT/8tPU/8rK6gzcmqXAl0CppmiIvkU6CIiGaFAT5KGT6SgQPuF+nPqKdBFRDJCgV4Rukh0+WVh6n+1CyhFUMXWLAW6iEhGKNAlXJr6L3ICBXqiUvYRX9IhbUM/sYVad+1QoIuIZIQCvRJKmimaaCXZ0a92SlvjBjQMpIlZQVCgi4hkRKxAN7OZZrbOzDaY2Z19rPNxM1tjZqvN7CflLVOkEE39F8nXUGwFM6sH5gMfBDqA5Wa2yN3X5K0zHfgKcIW77zGzsUkVHJRgD35JsgLtF+rPqRdnD/1SYIO7b3T3I8BCYE6vdb4AzHf3PQDuvqO8ZYqISDFxAn0CsCXvfke0LN+5wLlm9p9mtszMZhZ6IjO71czazay9s7OzfxUHqZSZolIzgtreIdVau8p1ULQBmA5cDcwF7jezkb1XcvcF7t7m7m3Nzc1leums0cfaeDIw9V+kzOIE+lagJe/+xGhZvg5gkbsfdfdNwIvkAl4kOZopKnKCOIG+HJhuZlPNbCBwI7Co1zq/ILd3jpk1kRuC2Vi+MkVEpJiige7uXcA8YAmwFnjQ3Veb2b1mdm202hJgl5mtAR4D/tTddyVVdDj0EV8KCHboJ9S6a0fR0xYB3H0xsLjXsrvzbjvwxeif9FbKTFGpIQFt76AO4NYuzRRNm2D33iosExeJFikvBbqISEYo0CVgmvovkk+BniQNn0hBgfYL9efUU6CLiGSEAr0i4k79h2D33iquPzNFy1/FaQlqGCikWmuXAl1EJCMU6BIuTf0XOYECPVFp+4wvqRDswcVQ664dCnQRkYxQoFeCpv5LQQFt76AO4NYuBXraBPtxvMI09V/kJAp0qQ3aw5QaoEBPkva2paBA+4X6c+op0EVEMkKBXhG6SLQUENT2DqnW2qVATx19rI1HF4kW6U2BLiKSEQr0RGmPMFGhTv0P9pNCqHXXDgW6iEhGKNArQTNFpaCAtndQB3BrV0O1C5Begv04XmEBzxR943AXw4CHn+3ggqH7OWfsMKwMgbno+Vf5/hObuGLaGMaNHMLlU0cfz+Fzxjae9vNL+inQRSps38EjDAN+1t7Bf//dUqaPHcZN757C2U1nMG7kEKY2nXHKnz/S1cOfL1rF5p0HuOMD07l0ymi63fnGIy+wde9BVnbspafX365PtLXwldlvY+TQgcn9YlJ1CnQJWPy92kPdPdR39zAgwWrimjByKAD3zb2IJQem85OnXuFrv1h1/PGrpjfRuf8wv/+2sdz+vnM4Y9Bbb9MjXT186u+WsXzzHgCeXLCLQQ11uMOR7h6+f1Mb757WxM43DrN0fSeDG+p58bX9/N0Tm/jt2te475MX83vTxlT2F5aKUaAnScMnqXDgSBe79x/mtY59XFLtYoBjQz9NwwbxqQsn88lLJ/F8xz7ePNzFv6zazn+82MmZwwfxvf94if/csJP7PnkxLaOHcuhoN19+aAXLN+/hf9/wTmZdcBa/XfsaKzv2se61/QwfMoD3nTeWujqjZfRQPnXZ5OOvOGfGBP7rwme5+YHf8c/zrmT6mf0YglF/Tj0FekVopmg1rezYx3iH8SMHV7uUE0Xb28yY0TISgCvOaTr+8L+u3s6XHnye2d95nJuvnMqja19jzbbX+dMPncf1l0wEckE9Z8aEoi/VOn44P/n8Zcz6zuPc9o/P8Pefexcto4eWUmwJ60q16CwXybyVW/cBMCqw8eNrzj+LxXdcxblnNfLdR9ez843D3P+ZNm5/3zn9er6xwwfzlzfO4JVdB5j9ncd5Yv3OMlcs1aY99NTRx9p44rfTyq37mF1nDG4Ib/+lZfRQfn7bu9n1xmFGDR1IXd3p7SlfNb2ZR7/0Xm5+YDm3/+QZnvrq+xk8oL5M1Uq1hdfDRY6JOUS1smMfAxrCDq0xwwaddpgf0zJ6KPfOOZ99B4+yZPX2sjynpIMCPVHa2662/YeOsnHnmwxM0955Cg4uXj51DONHDOaXz71awk9Vv245tRT1cpHyW7X1dQAG1uugXr66OuMPZoxn6Yud7H7zSLXLkTKJFehmNtPM1pnZBjO78xTrfczM3MzayldiBmjqf9Ws2RYFepr20I+r7vae884JdPU4v14RYy9dZ2AFoWgvN7N6YD4wC2gF5ppZa4H1GoE7gKfKXWRNScHH8SDEbKeXd71J46AG6szQkMGJ3j6ukXPPHMbPn9la7VKkTOLstlwKbHD3je5+BFgIzCmw3teBbwCHylifyGl5edcBJo0Zqs8+BZgZn3jXJJ7bspdV0amdErY4gT4B2JJ3vyNadpyZXQy0uPuvT/VEZnarmbWbWXtnZ2fJxQZHe9sJKx7Tr+w+wOQxQ1M2ZJCefnH9JRMZMqCeH/6/zcVXVn9OvdMeWDSzOuDbwJeKrevuC9y9zd3bmpubT/elRU6pu8fp2HOASaNP/WVXtWzEkAHc0DaRh5/dyqadb1a7HDlNcQJ9K9CSd39itOyYRuAC4N/NbDNwObBIB0bzaep/Nby69yBHuz23h55GKdne837/HAY21PHNf3mhz3Uc6NYeeurFCfTlwHQzm2pmA4EbgUXHHnT3fe7e5O5T3H0KsAy41t3bE6k48/Smiad4O23eldvjnHzsO0sUSAWNbRzM5686m0dWbWfDjjdOenzL7gOs2vo6m3cdqEJ1Uoqige7uXcA8YAmwFnjQ3Veb2b1mdm3SBYr018+Wb6HO4PwJI6pdSup95vLJNA5u4KsPr6Qn78vUO/YcYO79yzjc1cOIIWn48mE5lVjf5eLui4HFvZbd3ce6V59+Wdng7jq7IkGO8U/Lt3DZ2aMZ2ziY7z+xkRe27+ejF02guXEQv1qxjUunjI6CKEVbIoWfFJobB/FnH2nlyw+t4KsPr+RD55/Fyq37+IdlL3PwaDfnnjmM4YF9uVkt0pdzJei5LXu5CPjRk5v5zAfHluUyY/KWTTvf5MuPruBtZzVy6Gj38SGBX63YdnydP/vISVMmpA83XDKRF7fnLoaxcHnuxLbzxw/n2x+fwfDF2jsPgQI9QRdMGAEr4bv/9hJDRo/nhraWIj+hwI/Lgec79gLwwvb9NNQZ93+2jXPPHMbj63fytV+somnYIC6cmObhlnRtbzPjax9p5cPvGMfrh7qY0TLyrWEW7YwEQYGeoAHR94e0jm/kL3+7nlkXjmPYoCJNnsKP42lzuKubuu5utu07xFXTm3h8/U5uaGvhg61nAjB5zBl8vK2FI909vX5SbRvHRZNGVbsE6ac0fsFF5tzx/ulsf/0Qd/58xSnX27LnIIe7enCF+ikNaqinzoyB9XXcc+35PHDzu7jrw28/YZ2BDXXF/3iKZIwCPUlRMF8yeTS3vXcav1qxrc8p1rvfPMKTG3dx8Gg33b0v2S4nqTfjlqvOZlrzMK4+b2zx8E7VkEGg21c7GqmnQK+QL7znbEYNHcC3lqwr+Pgvn9vK4aPdDBvUQEO9NkscaYpokTRQclSEMWLIAD59+WQeX9/J3gMnfv+0u/PQ0x2MGDqQhjJdlUYCkKpPDcWEVGvtUqBX0NXnjaXHYWmvi/MuXb+T1a++Tuu44VWqTESyQIFeQTNaRtLcOIh/fv7ECwr8w7KXaRo2iKlNZxDs+GrF9aOdNAYsGadAr6D6OuO6GeN57IUdxy/7tWX3Af593Q4+etF46jXcUhuC/cMSat21Q4FeYddf0kJXj/NA9P3T/+uRF6ivM/7wyqnVLSxEJY1B64+lZJ9O1K2EvOA576xGPvyOcSxY+hIHj3Tx65Xb+OIHz2XciCEodGpNQNvbLOBPFrVDe+hVcNfst9M4eAD3P76JK84Zw21XT6t2SSKSAdpDr4LxI4fw4B/9Hss27uK6GRMYkH/eufaC4ulXO6ltJdsU6FUytemM6KwWEZHy0JBLkrS3nbASxqBTNYkn0H6h/px6CvSK0DVFpQBtbykzBbqISEYo0FNHH2vj0UxRkd4U6CIiGaFAT5T2CBMV6kzRYLtFsIXXDAW6iEhGKNArIfaeZIr2IqUCAtreOiMnCAp0EZGMUKCnjc7EiEdT/0VOokBPksJZCgq0X6g/p54CXQIW6tR/kWQo0NNEoVNbgtreIdVauxToIiIZoUBPHY1TxqOp/yK9xQp0M5tpZuvMbIOZ3Vng8S+a2RozW2Fmj5rZ5PKXGiIFiBQQ7B+WUOuuHUUD3czqgfnALKAVmGtmrb1WexZoc/d3AA8B3yx3oSInCXXqv0hC4uyhXwpscPeN7n4EWAjMyV/B3R9z9wPR3WXAxPKWGTjNFJWCAtreQR3ArV1xAn0CsCXvfke0rC+3AI8UesDMbjWzdjNr7+zsjF+liIgUVdaDomb2aaAN+Fahx919gbu3uXtbc3NzOV86OzRMmSA1rmRbnItEbwVa8u5PjJadwMw+ANwFvNfdD5envMAFe/BLkhVov1B/Tr04e+jLgelmNtXMBgI3AovyVzCzi4C/Ba519x3lL1OkEM0UFclXNNDdvQuYBywB1gIPuvtqM7vXzK6NVvsWMAz4JzN7zswW9fF0NUoXiZYCgtrcQRVbs+IMueDui4HFvZbdnXf7A2WuS0RESqSZoiIiGaFATx0deCqqvwfndFBPMk6BnigFSKJCnSka7B+WUOuuHQr0StBMUSkooO2tA/ZBUKCLiGSEAl1EJCMU6GkT7PhqBfW7jdS2km0K9CQpnKWgQPuF+nPqKdAlYJr6L5JPgV4RmvovBQS1vUOqtXYp0EVEMkKBnjoapyxOM0VFClGgJ0oBIgUE+4cl1LprhwJdwhXq1H+RhCjQKyGog19SOQH1C/XhICjQRUQyQoEuIpIRCvQk9efgV7AHzCoo+DYKtP7g2z37FOgSMM0UFcmnQK8IzRSVAoLa3iHVWrsU6CIiGaFAFxHJCAV6ovpzEEkHnooLfOp/WuooWah11w4FuohIRijQK0EXiU5GSc2VxrZNY019COoAbu1SoIuIZIQCXUQkIxToSdJM0WQEf5HotNRRIvXN1FOgi4hkhAK9IjRTNBmlTP1Prop+C2p7h1Rr7VKgi4hkRKxAN7OZZrbOzDaY2Z0FHh9kZj+LHn/KzKaUvVIRETmlooFuZvXAfGAW0ArMNbPWXqvdAuxx93OAvwC+Ue5CRUTk1BpirHMpsMHdNwKY2UJgDrAmb505wD3R7YeA+8zM3BM4LP7Mj+HJ+8r+tIk4sKv0n+k6CPMvK38tWeI9/fu5TUvT0baH91e7gv7ZsTYd7ZcF7/0yXPCxsj9tnECfAGzJu98B9N6qx9dx9y4z2weMAXbmr2RmtwK3AkyaNKl/FQ8dDc3n9e9nq2HUVBgwJN66rdfB3lf6H1i15KwL4bzZ8de/7DZYvyS5eko1+APQdG61q4jvks/BgMHVriI7Bo9M5Gmt2E60mV0PzHT3z0f3PwNc5u7z8tZZFa3TEd1/KVpnZ6HnBGhra/P29vYy/AoiIrXDzJ5297ZCj8U5KLoVaMm7PzFaVnAdM2sARgD9GG8QEZH+ihPoy4HpZjbVzAYCNwKLeq2zCLgpun098G+JjJ+LiEifio6hR2Pi84AlQD3wA3dfbWb3Au3uvgj4PvBjM9sA7CYX+iIiUkFxDori7ouBxb2W3Z13+xBwQ3lLExGRUmimqIhIRijQRUQyQoEuIpIRCnQRkYwoOrEosRc26wRe7uePN9FrFqoUpHaKR+1UnNoonkq002R3by70QNUC/XSYWXtfM6XkLWqneNROxamN4ql2O2nIRUQkIxToIiIZEWqgL6h2AYFQO8WjdipObRRPVdspyDF0ERE5Wah76CIi0osCXUQkI4IL9GIXrK4lZrbZzFaa2XNm1h4tG21mvzGz9dH/o6LlZmbfjdpthZldXN3qk2NmPzCzHdGFV44tK7ldzOymaP31ZnZTodcKWR/tdI+ZbY361HNmNjvvsa9E7bTOzD6Utzyz70kzazGzx8xsjZmtNrM7ouXp7E/uHsw/cl/f+xJwNjAQeB5orXZdVWyPzUBTr2XfBO6Mbt8JfCO6PRt4BDDgcuCpatefYLu8B7gYWNXfdgFGAxuj/0dFt0dV+3erQDvdA/xJgXVbo/fbIGBq9D6sz/p7EhgHXBzdbgRejNoilf0ptD304xesdvcjwLELVstb5gA/jG7/ELgub/mPPGcZMNLMxlWhvsS5+1Jy38ufr9R2+RDwG3ff7e57gN8AMxMvvoL6aKe+zAEWuvthd98EbCD3fsz0e9Ldt7n7M9Ht/cBactdQTmV/Ci3QC12wekKVakkDB/7VzJ6OLsANcKa7b4tubwfOjG7XetuV2i613F7zouGCHxwbSkDthJlNAS4CniKl/Sm0QJcTXenuFwOzgNvN7D35D3rus57OS+1F7XJK3wOmATOAbcD/qWo1KWFmw4CfA//N3V/PfyxN/Sm0QI9zweqa4e5bo/93AA+T+/j72rGhlOj/HdHqtd52pbZLTbaXu7/m7t3u3gPcT65PQQ23k5kNIBfm/+ju/zdanMr+FFqgx7lgdU0wszPMrPHYbeAaYBUnXrD7JuCX0e1FwGejo/CXA/vyPjLWglLbZQlwjZmNioYdromWZVqv4yofJdenINdON5rZIDObCkwHfkfG35NmZuSumbzW3b+d91A6+1O1jyL346jzbHJHml8C7qp2PVVsh7PJnVHwPLD6WFsAY4BHgfXAb4HR0XID5kftthJoq/bvkGDb/JTccMFRcmOVt/SnXYA/JHfwbwNwc7V/rwq104+jdlhBLpzG5a1/V9RO64BZecsz+54EriQ3nLICeC76Nzut/UlT/0VEMiK0IRcREemDAl1EJCMU6CIiGaFAFxHJCAW6iEhGKNBFRDJCgS4ikhH/HyJEX7uYuMpYAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "c = norm(b, False)\n",
    "c['left_OVRHandPrefab_pos_X'].plot()\n",
    "plt.plot(c['LeftHandTrackingAccuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9ae9b71e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fb1085d5700>]"
      ]
     },
     "execution_count": 24,
     "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": [
    "d = interpol(c, False)\n",
    "d['left_OVRHandPrefab_pos_X'].plot()\n",
    "plt.plot(d['LeftHandTrackingAccuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "29e9063e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 234 µs, sys: 0 ns, total: 234 µs\n",
      "Wall time: 252 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(48, 48)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "train = np.array([x['data'] for x in pdata if x['session'] == 1])\n",
    "test = np.array([x['data'] for x in pdata if x['session'] == 2])\n",
    "\n",
    "len(train), len(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a52352aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:36<00:00,  2.62it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(57800, 5, 336) (57800,) (37106, 5, 336) (37106,)\n",
      "CPU times: user 1min 48s, sys: 14.9 s, total: 2min 3s\n",
      "Wall time: 37 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "X_train = list()\n",
    "y_train = list()\n",
    "\n",
    "X_test = list()\n",
    "y_test = list()\n",
    "\n",
    "train = list()\n",
    "test = list()\n",
    "\n",
    "for x in tqdm(pdata):\n",
    "    if x['session'] == 1:\n",
    "        train.append(\n",
    "            {\n",
    "                'label': x['user'],\n",
    "                'data': list()\n",
    "            })\n",
    "        for y in x['data'].unbatch().as_numpy_iterator():\n",
    "            if not np.isnan(y[0]).any():\n",
    "                X_train.append(y[0])\n",
    "                y_train.append(y[1])\n",
    "                \n",
    "                train[-1]['data'].append(y[0])\n",
    "        if len(train[-1]['data']) == 0:\n",
    "            del train[-1]\n",
    "    if x['session'] == 2:\n",
    "        test.append(\n",
    "            {\n",
    "                'label': x['user'],\n",
    "                'data': list()\n",
    "            })\n",
    "        for y in x['data'].unbatch().as_numpy_iterator():\n",
    "            if not np.isnan(y[0]).any():\n",
    "                X_test.append(y[0])\n",
    "                y_test.append(y[1])\n",
    "                \n",
    "                test[-1]['data'].append(y[0])\n",
    "            \n",
    "        if len(test[-1]['data']) == 0:\n",
    "            del test[-1]\n",
    "            \n",
    "X_train = np.array(X_train)\n",
    "y_train = np.array(y_train)\n",
    "X_test = np.array(X_test)\n",
    "y_test = np.array(y_test)\n",
    "\n",
    "print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8c85c181",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key: 1: 1347\n",
      "Key: 2: 1583\n",
      "Key: 3: 8568\n",
      "Key: 4: 3034\n",
      "Key: 5: 1960\n",
      "Key: 6: 3311\n",
      "Key: 7: 3971\n",
      "Key: 8: 1407\n",
      "Key: 9: 1135\n",
      "Key: 10: 7466\n",
      "Key: 11: 6494\n",
      "Key: 12: 1813\n",
      "Key: 13: 3596\n",
      "Key: 14: 3260\n",
      "Key: 15: 2825\n",
      "Key: 16: 6030\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([<AxesSubplot:ylabel='0'>], dtype=object)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Xy_train = list(zip(X_train, y_train))\n",
    "Xy_test = list(zip(X_test, y_test))\n",
    "train_dict = {\"1\":[], \"2\":[],\"3\":[], \"4\":[], \"5\":[],\"6\":[], \"7\":[], \"8\":[],\"9\":[], \"10\":[], \"11\":[],\"12\":[], \"13\":[], \"14\":[], \"15\": [], \"16\": []}\n",
    "\n",
    "[train_dict[str(e[1])].append(e[0]) for e in Xy_train]\n",
    "[print(f'Key: {k}: {len(v)}') for k, v in train_dict.items()]\n",
    "pd.DataFrame.from_dict({k: len(v) for k, v in train_dict.items()}, orient='index').plot.pie(subplots=True, legend=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "92991de2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key: 1: 790\n",
      "Key: 2: 59\n",
      "Key: 3: 4330\n",
      "Key: 4: 0\n",
      "Key: 5: 545\n",
      "Key: 6: 348\n",
      "Key: 7: 5245\n",
      "Key: 8: 3558\n",
      "Key: 9: 2565\n",
      "Key: 10: 4163\n",
      "Key: 11: 3654\n",
      "Key: 12: 2868\n",
      "Key: 13: 2130\n",
      "Key: 14: 2360\n",
      "Key: 15: 2390\n",
      "Key: 16: 2101\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([<AxesSubplot:ylabel='0'>], dtype=object)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Xy_test = list(zip(X_test, y_test))\n",
    "test_dict = {\"1\":[], \"2\":[],\"3\":[], \"4\":[], \"5\":[],\"6\":[], \"7\":[], \"8\":[],\"9\":[], \"10\":[], \"11\":[],\"12\":[], \"13\":[], \"14\":[], \"15\": [], \"16\": []}\n",
    "\n",
    "[test_dict[str(e[1])].append(e[0]) for e in Xy_test]\n",
    "[print(f'Key: {k}: {len(v)}') for k, v in test_dict.items()]\n",
    "pd.DataFrame.from_dict({k: len(v) for k, v in test_dict.items()}, orient='index').plot.pie(subplots=True, legend=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "419d603a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 355 ms, sys: 13 ms, total: 368 ms\n",
      "Wall time: 367 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "\n",
    "\n",
    "lb = LabelBinarizer()\n",
    "yy_train = lb.fit_transform(y_train)\n",
    "yy_test = lb.transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "da224750",
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in test:\n",
    "    e['label'] = lb.transform([e['label']])\n",
    "    e['data'] = np.array(e['data'])\n",
    "\n",
    "        \n",
    "for e in train:\n",
    "    e['label'] = lb.transform([e['label']])\n",
    "    e['data'] = np.array(e['data'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "073c2c51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(57800, 5, 336)\n",
      "(57800, 16)\n",
      "(37106, 5, 336)\n",
      "(37106, 16)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(yy_train.shape)\n",
    "print(X_test.shape)\n",
    "print(yy_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cee9b1c3",
   "metadata": {},
   "source": [
    "# Building Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "75c9ba6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow.keras.regularizers import l2\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Flatten, BatchNormalization, Dropout\n",
    "from tensorflow.keras.callbacks import ModelCheckpoint, ReduceLROnPlateau\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "\n",
    "def build_model(shape, classes):\n",
    "    model = Sequential()\n",
    "    \n",
    "    ncount = shape[0]*shape[1]\n",
    "    \n",
    "    model.add(Flatten(input_shape=shape, name='flatten'))\n",
    "    \n",
    "    model.add(Dropout(drop_count, name=f'dropout_{drop_count*100}'))\n",
    "    model.add(BatchNormalization(name='batchNorm'))\n",
    "    \n",
    "    for i in range(2,layer_count+2):\n",
    "        neurons = int(ncount/pow(dense_steps,i))\n",
    "        if neurons <= classes:\n",
    "            break\n",
    "        model.add(Dropout(drop_count*i, name=f'HiddenDropout_{drop_count*i*100:.0f}'))\n",
    "        model.add(Dense(neurons, activation='relu', \n",
    "                        kernel_regularizer=l2(0.001), name=f'Hidden_{i}')\n",
    "                 )\n",
    "    \n",
    "    model.add(Dense(classes, activation='softmax', name='Output'))\n",
    "    \n",
    "    model.compile(\n",
    "        optimizer=Adam(),\n",
    "        loss=\"categorical_crossentropy\", \n",
    "        metrics=[\"acc\"],\n",
    "    )\n",
    "    \n",
    "    model.summary()\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8f71c4bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint_file = './goat.weights'\n",
    "\n",
    "def train_model(X_train, y_train, X_test, y_test):\n",
    "    model = build_model(X_train[0].shape, 16)\n",
    "    \n",
    "    # Create a callback that saves the model's weights\n",
    "    model_checkpoint = ModelCheckpoint(filepath=checkpoint_path, monitor='loss', \n",
    "\t\t\tsave_best_only=True)\n",
    "    \n",
    "    reduce_lr = ReduceLROnPlateau(monitor='loss', factor=0.5, patience=5, min_lr=0.0001)\n",
    "\n",
    "    callbacks = [model_checkpoint, reduce_lr]\n",
    "    \n",
    "    history = model.fit(X_train, \n",
    "                        y_train,\n",
    "                        epochs=epoch,\n",
    "                        batch_size=32,\n",
    "                        verbose=2,\n",
    "                        validation_data=(X_test, y_test),\n",
    "                        callbacks=callbacks\n",
    "             )\n",
    "    \n",
    "    model.load_weights(checkpoint_path)\n",
    "    return model, history"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "77e0fc90",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded weights...\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "flatten (Flatten)            (None, 1680)              0         \n",
      "_________________________________________________________________\n",
      "dropout_10.0 (Dropout)       (None, 1680)              0         \n",
      "_________________________________________________________________\n",
      "batchNorm (BatchNormalizatio (None, 1680)              6720      \n",
      "_________________________________________________________________\n",
      "HiddenDropout_20 (Dropout)   (None, 1680)              0         \n",
      "_________________________________________________________________\n",
      "Hidden_2 (Dense)             (None, 186)               312666    \n",
      "_________________________________________________________________\n",
      "HiddenDropout_30 (Dropout)   (None, 186)               0         \n",
      "_________________________________________________________________\n",
      "Hidden_3 (Dense)             (None, 62)                11594     \n",
      "_________________________________________________________________\n",
      "HiddenDropout_40 (Dropout)   (None, 62)                0         \n",
      "_________________________________________________________________\n",
      "Hidden_4 (Dense)             (None, 20)                1260      \n",
      "_________________________________________________________________\n",
      "Output (Dense)               (None, 16)                336       \n",
      "=================================================================\n",
      "Total params: 332,576\n",
      "Trainable params: 329,216\n",
      "Non-trainable params: 3,360\n",
      "_________________________________________________________________\n",
      "CPU times: user 80.5 ms, sys: 3.3 ms, total: 83.8 ms\n",
      "Wall time: 79.5 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "if not os.path.isdir(checkpoint_dir) or create_new:\n",
    "    tf.keras.backend.clear_session()\n",
    "    model, history = train_model(np.array(X_train), np.array(yy_train), np.array(X_test), np.array(yy_test))\n",
    "else:\n",
    "    print(\"Loaded weights...\")\n",
    "    model = build_model(X_train[0].shape, 16)\n",
    "    model.load_weights(checkpoint_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e6f8ad",
   "metadata": {},
   "source": [
    "# Eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "b7ede2b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(model, entry):\n",
    "    p_dict = dict()\n",
    "    predictions = np.argmax(model.predict(entry), axis=-1)\n",
    "    for p in predictions:\n",
    "        if p in p_dict:\n",
    "            p_dict[p] += 1\n",
    "        else:\n",
    "            p_dict[p] = 1\n",
    "    prediction = max(p_dict, key=p_dict.get)\n",
    "    return prediction+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "a71bb247",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.36 s, sys: 529 ms, total: 3.89 s\n",
      "Wall time: 2.95 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(43, 43)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "ltest = [lb.inverse_transform(e['label'])[0] for e in test]\n",
    "ptest = [predict(model, e['data']) for e in test]\n",
    "\n",
    "len(ltest), len(ptest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "ab3ecfc9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.85 s, sys: 448 ms, total: 4.3 s\n",
      "Wall time: 2.99 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(47, 47)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "ltrain = [lb.inverse_transform(e['label'])[0] for e in train]\n",
    "ptrain = [predict(model, e['data']) for e in train]\n",
    "\n",
    "\n",
    "len(ltrain), len(ptrain)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "ac226caa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},\n",
       " {1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16})"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(ltrain), set(ltest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3c3bac5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           1       1.00      0.67      0.80         3\n",
      "           2       0.00      0.00      0.00         1\n",
      "           3       0.43      1.00      0.60         3\n",
      "           4       0.00      0.00      0.00         0\n",
      "           5       0.00      0.00      0.00         3\n",
      "           6       0.50      0.33      0.40         3\n",
      "           7       1.00      1.00      1.00         3\n",
      "           8       1.00      0.33      0.50         3\n",
      "           9       0.00      0.00      0.00         3\n",
      "          10       0.40      0.67      0.50         3\n",
      "          11       0.00      0.00      0.00         3\n",
      "          12       0.60      1.00      0.75         3\n",
      "          13       0.75      1.00      0.86         3\n",
      "          14       0.00      0.00      0.00         3\n",
      "          15       0.00      0.00      0.00         3\n",
      "          16       0.50      1.00      0.67         3\n",
      "\n",
      "    accuracy                           0.49        43\n",
      "   macro avg       0.39      0.44      0.38        43\n",
      "weighted avg       0.43      0.49      0.42        43\n",
      "\n",
      "CPU times: user 646 ms, sys: 195 ms, total: 840 ms\n",
      "Wall time: 610 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sn\n",
    "\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "set_digits = set(ltrain)\n",
    "\n",
    "train_cm = confusion_matrix(ltrain, ptrain, labels=list(set_digits), normalize='true')\n",
    "test_cm = confusion_matrix(ltest, ptest, labels=list(set_digits), normalize='true')\n",
    "\n",
    "df_cm = pd.DataFrame(test_cm, index=set_digits, columns=set_digits)\n",
    "plt.figure(figsize = (10,7))\n",
    "sn_plot = sn.heatmap(df_cm, annot=True, cmap=\"Greys\")\n",
    "plt.ylabel(\"True Label\")\n",
    "plt.xlabel(\"Predicted Label\")\n",
    "plt.show()\n",
    "\n",
    "print(classification_report(ltest, ptest, zero_division=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "43acba77",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_keras_history(history, name='', acc='acc'):\n",
    "    \"\"\"Plots keras history.\"\"\"\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "    training_acc = history.history[acc]\n",
    "    validation_acc = history.history['val_' + acc]\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "\n",
    "    epochs = range(len(training_acc))\n",
    "\n",
    "    plt.ylim(0, 1)\n",
    "    plt.plot(epochs, training_acc, 'tab:blue', label='Training acc')\n",
    "    plt.plot(epochs, validation_acc, 'tab:orange', label='Validation acc')\n",
    "    plt.title('Training and validation accuracy  ' + name)\n",
    "    plt.legend()\n",
    "\n",
    "    plt.figure()\n",
    "\n",
    "    plt.plot(epochs, loss, 'tab:green', label='Training loss')\n",
    "    plt.plot(epochs, val_loss, 'tab:red', label='Validation loss')\n",
    "    plt.title('Training and validation loss  ' + name)\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    plt.close()\n",
    "if 'history' in locals():\n",
    "    plot_keras_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "af999e08",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scenario: SYN\n",
      "Window Size: 5\n",
      "Strides: 1\n",
      "Epochs: 50\n",
      "HiddenL Count: 3\n",
      "Neuron Factor: 3\n",
      "Drop Factor: 0.1\n"
     ]
    }
   ],
   "source": [
    "print(f'Scenario: {cenario}')\n",
    "print(f'Window Size: {win_sz}')\n",
    "print(f'Strides: {stride_sz}')\n",
    "print(f'Epochs: {epoch}')\n",
    "print(f'HiddenL Count: {layer_count}')\n",
    "print(f'Neuron Factor: {dense_steps}')\n",
    "print(f'Drop Factor: {drop_count}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b16af0c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "exit()"
   ]
  }
 ],
 "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.10"
  },
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}