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

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f97d492f",
   "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": "f6220693",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Possibilities: 'SYY', 'SYN', 'SNY', 'SNN', \n",
    "#                'JYY', 'JYN', 'JNY', 'JNN'\n",
    "cenario = 'JNY'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d569ebf",
   "metadata": {},
   "source": [
    "## Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3d34815c",
   "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": "22237fa1",
   "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": "b220134d",
   "metadata": {},
   "source": [
    "# Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ff0d90d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "create_new = True\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": "819834af",
   "metadata": {},
   "source": [
    "# Helper Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "db6e77dc",
   "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": "6a0431cf",
   "metadata": {},
   "source": [
    "# Loading Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e959d5aa",
   "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": "19976126",
   "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": "3cb2910c",
   "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": "062fbcda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading data...\n",
      "../data.pickle found...\n",
      "768\n",
      "CPU times: user 548 ms, sys: 2.58 s, total: 3.13 s\n",
      "Wall time: 3.13 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": "eb844cab",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 90 µs, sys: 305 µs, total: 395 µs\n",
      "Wall time: 399 µ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": "21caabe5",
   "metadata": {},
   "source": [
    "# Preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3f72125c",
   "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": "4ce4cae7",
   "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": "c72e677d",
   "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": "322c13e7",
   "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": "bf81d3ed",
   "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": "d5dd8da8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:07<00:00, 12.98it/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": "9733336e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def minmaxscaler(entry, minimum, maximum):\n",
    "    return (entry-minimum)/(maximum-minimum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3f74d664",
   "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": "84b87eac",
   "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": "bdd01b2f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:15<00:00,  6.08it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 14.8 s, sys: 1.46 s, total: 16.2 s\n",
      "Wall time: 15.8 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": "892d5852",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fa3700e5130>]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "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": "39ad9063",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fa33033cc70>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "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": "5257f8a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fa3302c2070>]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "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": "ce91623f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fa3302ac760>]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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
      "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": "01759009",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 120 µs, sys: 96 µs, total: 216 µs\n",
      "Wall time: 226 µ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": "84b6ba0b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 96/96 [00:39<00:00,  2.42it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(59496, 5, 408) (59496,) (54212, 5, 408) (54212,)\n",
      "CPU times: user 1min 55s, sys: 17.4 s, total: 2min 12s\n",
      "Wall time: 40 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": "11d535e3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key: 1: 3907\n",
      "Key: 2: 2358\n",
      "Key: 3: 2044\n",
      "Key: 4: 5157\n",
      "Key: 5: 5080\n",
      "Key: 6: 4624\n",
      "Key: 7: 7405\n",
      "Key: 8: 1386\n",
      "Key: 9: 2344\n",
      "Key: 10: 561\n",
      "Key: 11: 1397\n",
      "Key: 12: 748\n",
      "Key: 13: 3929\n",
      "Key: 14: 3588\n",
      "Key: 15: 6981\n",
      "Key: 16: 7987\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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
      "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": "8b39db31",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key: 1: 2292\n",
      "Key: 2: 1617\n",
      "Key: 3: 1958\n",
      "Key: 4: 0\n",
      "Key: 5: 1463\n",
      "Key: 6: 3972\n",
      "Key: 7: 7160\n",
      "Key: 8: 561\n",
      "Key: 9: 3797\n",
      "Key: 10: 3175\n",
      "Key: 11: 5723\n",
      "Key: 12: 773\n",
      "Key: 13: 2487\n",
      "Key: 14: 6576\n",
      "Key: 15: 2338\n",
      "Key: 16: 10320\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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
      "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": "8ab5b1b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 206 ms, sys: 23.9 ms, total: 230 ms\n",
      "Wall time: 229 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": "17ab5592",
   "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": "ae01b11b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(59496, 5, 408)\n",
      "(59496, 16)\n",
      "(54212, 5, 408)\n",
      "(54212, 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": "61aa2f65",
   "metadata": {},
   "source": [
    "# Building Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "dda54ca3",
   "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": "9da5f916",
   "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": "f078aec3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "flatten (Flatten)            (None, 2040)              0         \n",
      "_________________________________________________________________\n",
      "dropout_10.0 (Dropout)       (None, 2040)              0         \n",
      "_________________________________________________________________\n",
      "batchNorm (BatchNormalizatio (None, 2040)              8160      \n",
      "_________________________________________________________________\n",
      "HiddenDropout_20 (Dropout)   (None, 2040)              0         \n",
      "_________________________________________________________________\n",
      "Hidden_2 (Dense)             (None, 226)               461266    \n",
      "_________________________________________________________________\n",
      "HiddenDropout_30 (Dropout)   (None, 226)               0         \n",
      "_________________________________________________________________\n",
      "Hidden_3 (Dense)             (None, 75)                17025     \n",
      "_________________________________________________________________\n",
      "HiddenDropout_40 (Dropout)   (None, 75)                0         \n",
      "_________________________________________________________________\n",
      "Hidden_4 (Dense)             (None, 25)                1900      \n",
      "_________________________________________________________________\n",
      "Output (Dense)               (None, 16)                416       \n",
      "=================================================================\n",
      "Total params: 488,767\n",
      "Trainable params: 484,687\n",
      "Non-trainable params: 4,080\n",
      "_________________________________________________________________\n",
      "Epoch 1/50\n",
      "1860/1860 - 9s - loss: 1.1439 - acc: 0.8277 - val_loss: 4.1534 - val_acc: 0.3367\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 2/50\n",
      "1860/1860 - 8s - loss: 0.6508 - acc: 0.9432 - val_loss: 4.2615 - val_acc: 0.3517\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 3/50\n",
      "1860/1860 - 8s - loss: 0.5574 - acc: 0.9578 - val_loss: 4.6319 - val_acc: 0.3213\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 4/50\n",
      "1860/1860 - 8s - loss: 0.5164 - acc: 0.9626 - val_loss: 4.2537 - val_acc: 0.3229\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 5/50\n",
      "1860/1860 - 8s - loss: 0.4962 - acc: 0.9650 - val_loss: 4.4670 - val_acc: 0.2816\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 6/50\n",
      "1860/1860 - 8s - loss: 0.4865 - acc: 0.9677 - val_loss: 4.2317 - val_acc: 0.3228\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 7/50\n",
      "1860/1860 - 8s - loss: 0.4641 - acc: 0.9696 - val_loss: 4.2347 - val_acc: 0.3028\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 8/50\n",
      "1860/1860 - 8s - loss: 0.4593 - acc: 0.9693 - val_loss: 4.3525 - val_acc: 0.3061\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 9/50\n",
      "1860/1860 - 8s - loss: 0.4479 - acc: 0.9708 - val_loss: 4.7173 - val_acc: 0.2928\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 10/50\n",
      "1860/1860 - 8s - loss: 0.4377 - acc: 0.9709 - val_loss: 4.3594 - val_acc: 0.3111\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 11/50\n",
      "1860/1860 - 8s - loss: 0.4305 - acc: 0.9712 - val_loss: 4.4137 - val_acc: 0.3213\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 12/50\n",
      "1860/1860 - 8s - loss: 0.4305 - acc: 0.9712 - val_loss: 4.5386 - val_acc: 0.2677\n",
      "Epoch 13/50\n",
      "1860/1860 - 8s - loss: 0.4223 - acc: 0.9718 - val_loss: 4.2520 - val_acc: 0.2910\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 14/50\n",
      "1860/1860 - 8s - loss: 0.4124 - acc: 0.9726 - val_loss: 4.0999 - val_acc: 0.3237\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 15/50\n",
      "1860/1860 - 8s - loss: 0.4133 - acc: 0.9716 - val_loss: 4.8021 - val_acc: 0.2812\n",
      "Epoch 16/50\n",
      "1860/1860 - 8s - loss: 0.4052 - acc: 0.9730 - val_loss: 4.3781 - val_acc: 0.3171\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 17/50\n",
      "1860/1860 - 8s - loss: 0.4016 - acc: 0.9715 - val_loss: 4.3116 - val_acc: 0.3006\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 18/50\n",
      "1860/1860 - 8s - loss: 0.4027 - acc: 0.9730 - val_loss: 4.3661 - val_acc: 0.3093\n",
      "Epoch 19/50\n",
      "1860/1860 - 8s - loss: 0.3926 - acc: 0.9735 - val_loss: 4.4316 - val_acc: 0.3270\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 20/50\n",
      "1860/1860 - 8s - loss: 0.3937 - acc: 0.9735 - val_loss: 4.3595 - val_acc: 0.3323\n",
      "Epoch 21/50\n",
      "1860/1860 - 8s - loss: 0.3894 - acc: 0.9726 - val_loss: 4.1465 - val_acc: 0.3015\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 22/50\n",
      "1860/1860 - 8s - loss: 0.3807 - acc: 0.9748 - val_loss: 4.4357 - val_acc: 0.2999\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 23/50\n",
      "1860/1860 - 8s - loss: 0.3821 - acc: 0.9742 - val_loss: 4.2996 - val_acc: 0.2980\n",
      "Epoch 24/50\n",
      "1860/1860 - 8s - loss: 0.3816 - acc: 0.9733 - val_loss: 4.3006 - val_acc: 0.3003\n",
      "Epoch 25/50\n",
      "1860/1860 - 8s - loss: 0.3813 - acc: 0.9738 - val_loss: 4.3178 - val_acc: 0.3021\n",
      "Epoch 26/50\n",
      "1860/1860 - 8s - loss: 0.3837 - acc: 0.9734 - val_loss: 4.1520 - val_acc: 0.3249\n",
      "Epoch 27/50\n",
      "1860/1860 - 8s - loss: 0.3731 - acc: 0.9738 - val_loss: 4.3379 - val_acc: 0.3001\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 28/50\n",
      "1860/1860 - 8s - loss: 0.3770 - acc: 0.9740 - val_loss: 4.2641 - val_acc: 0.2848\n",
      "Epoch 29/50\n",
      "1860/1860 - 8s - loss: 0.3732 - acc: 0.9745 - val_loss: 4.4376 - val_acc: 0.2973\n",
      "Epoch 30/50\n",
      "1860/1860 - 8s - loss: 0.3661 - acc: 0.9754 - val_loss: 4.5851 - val_acc: 0.2762\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 31/50\n",
      "1860/1860 - 8s - loss: 0.3703 - acc: 0.9746 - val_loss: 4.4630 - val_acc: 0.2816\n",
      "Epoch 32/50\n",
      "1860/1860 - 8s - loss: 0.3776 - acc: 0.9736 - val_loss: 4.3901 - val_acc: 0.2840\n",
      "Epoch 33/50\n",
      "1860/1860 - 8s - loss: 0.3629 - acc: 0.9757 - val_loss: 4.2703 - val_acc: 0.2749\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 34/50\n",
      "1860/1860 - 8s - loss: 0.3709 - acc: 0.9744 - val_loss: 4.6455 - val_acc: 0.2860\n",
      "Epoch 35/50\n",
      "1860/1860 - 8s - loss: 0.3628 - acc: 0.9753 - val_loss: 4.5363 - val_acc: 0.3022\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 36/50\n",
      "1860/1860 - 8s - loss: 0.3589 - acc: 0.9757 - val_loss: 4.0942 - val_acc: 0.3210\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 37/50\n",
      "1860/1860 - 8s - loss: 0.3658 - acc: 0.9743 - val_loss: 4.4832 - val_acc: 0.2863\n",
      "Epoch 38/50\n",
      "1860/1860 - 8s - loss: 0.3729 - acc: 0.9739 - val_loss: 3.9867 - val_acc: 0.3346\n",
      "Epoch 39/50\n",
      "1860/1860 - 8s - loss: 0.3619 - acc: 0.9749 - val_loss: 4.2968 - val_acc: 0.2802\n",
      "Epoch 40/50\n",
      "1860/1860 - 8s - loss: 0.3606 - acc: 0.9759 - val_loss: 4.1525 - val_acc: 0.2883\n",
      "Epoch 41/50\n",
      "1860/1860 - 8s - loss: 0.3602 - acc: 0.9743 - val_loss: 4.2747 - val_acc: 0.2978\n",
      "Epoch 42/50\n",
      "1860/1860 - 8s - loss: 0.2673 - acc: 0.9859 - val_loss: 3.9356 - val_acc: 0.3196\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 43/50\n",
      "1860/1860 - 8s - loss: 0.2155 - acc: 0.9865 - val_loss: 4.2117 - val_acc: 0.2991\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 44/50\n",
      "1860/1860 - 8s - loss: 0.2059 - acc: 0.9860 - val_loss: 3.9830 - val_acc: 0.3013\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 45/50\n",
      "1860/1860 - 8s - loss: 0.2032 - acc: 0.9851 - val_loss: 3.9253 - val_acc: 0.3093\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 46/50\n",
      "1860/1860 - 8s - loss: 0.1954 - acc: 0.9858 - val_loss: 4.0545 - val_acc: 0.3242\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 47/50\n",
      "1860/1860 - 8s - loss: 0.1898 - acc: 0.9867 - val_loss: 4.2185 - val_acc: 0.3063\n",
      "INFO:tensorflow:Assets written to: training_JNY/cp.ckpt/assets\n",
      "Epoch 48/50\n",
      "1860/1860 - 8s - loss: 0.1980 - acc: 0.9855 - val_loss: 4.1222 - val_acc: 0.3030\n",
      "Epoch 49/50\n",
      "1860/1860 - 8s - loss: 0.1943 - acc: 0.9862 - val_loss: 4.0228 - val_acc: 0.3137\n",
      "Epoch 50/50\n",
      "1860/1860 - 8s - loss: 0.1900 - acc: 0.9871 - val_loss: 4.0491 - val_acc: 0.3201\n",
      "CPU times: user 10min 53s, sys: 53.9 s, total: 11min 47s\n",
      "Wall time: 7min 10s\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": "ef53285d",
   "metadata": {},
   "source": [
    "# Eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "073e281f",
   "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": "61519002",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.76 s, sys: 476 ms, total: 4.23 s\n",
      "Wall time: 2.89 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(42, 42)"
      ]
     },
     "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": "77f6f25b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.22 s, sys: 425 ms, total: 4.64 s\n",
      "Wall time: 3.19 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(48, 48)"
      ]
     },
     "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": "28d924cb",
   "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": "61f24ceb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "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       0.50      0.67      0.57         3\n",
      "           2       0.00      0.00      0.00         2\n",
      "           3       0.25      0.67      0.36         3\n",
      "           4       0.00      0.00      0.00         0\n",
      "           5       1.00      0.50      0.67         2\n",
      "           6       0.00      0.00      0.00         3\n",
      "           7       0.17      0.33      0.22         3\n",
      "           8       0.00      0.00      0.00         2\n",
      "           9       0.50      0.67      0.57         3\n",
      "          10       0.00      0.00      0.00         3\n",
      "          11       0.00      0.00      0.00         3\n",
      "          12       0.00      0.00      0.00         3\n",
      "          13       0.00      0.00      0.00         3\n",
      "          14       0.00      0.00      0.00         3\n",
      "          15       0.50      0.67      0.57         3\n",
      "          16       0.60      1.00      0.75         3\n",
      "\n",
      "    accuracy                           0.31        42\n",
      "   macro avg       0.22      0.28      0.23        42\n",
      "weighted avg       0.23      0.31      0.25        42\n",
      "\n",
      "CPU times: user 648 ms, sys: 205 ms, total: 853 ms\n",
      "Wall time: 623 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": "3533008c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWoAAAEICAYAAAB25L6yAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAA6OklEQVR4nO3dd3xUVdoH8N8zJZkkkwYEBEKzkFACCQSQXlSUonSkWBAFBQU7YkdXfHdXd0VsuygiKgpIVcoiggiIKybAUkISWgIJJSEhyUwyfZ73j5mMCWmTOpPk+fKZT2bunHvuc2eG554599wzxMwQQgjhvRSeDkAIIUT5JFELIYSXk0QthBBeThK1EEJ4OUnUQgjh5SRRCyGEl5NE3QgQ0XYierCmy3oSEaUQ0e21UC8T0c3O+/8iolfdKVuF7Uwnoh+rGmc59Q4horSarld4lsrTAYjSEZG+yEN/ACYANufjR5l5lbt1MfOI2ijb0DHzYzVRDxG1B3AOgJqZrc66VwFw+z0UjZskai/FzNrC+0SUAuARZv7p+nJEpCr8zy+EaJik66OeKfxqS0QvENFlACuIKJSIthBRJhFdc94PL7LOHiJ6xHl/BhHtJ6J3nWXPEdGIKpbtQER7iUhHRD8R0UdE9HUZcbsT41+I6FdnfT8SUbMiz99PRKlElEVEL5fz+vQhostEpCyybBwRHXXe701EvxFRDhFdIqIPicinjLq+IKK3ijx+3rnORSKaeV3ZUUR0mIjyiOgCES0q8vRe598cItITUd/C17bI+v2I6A8iynX+7efua1MeIurkXD+HiE4Q0T1FnhtJRAnOOtOJ6Dnn8mbO9yeHiLKJaB8RSa7wIHnx66cbADQB0A7AbDjexxXOx20BGAB8WM76fQAkAWgG4O8AlhMRVaHsNwAOAmgKYBGA+8vZpjsxTgPwEIDmAHwAFCaOzgA+cdbfyrm9cJSCmX8HkA9g2HX1fuO8bwPwtHN/+gK4DcDccuKGM4a7nPHcAeAWANf3j+cDeABACIBRAOYQ0Vjnc4Ocf0OYWcvMv11XdxMAWwEsde7bPwFsJaKm1+1DidemgpjVAH4A8KNzvXkAVhFRhLPIcji60QIBdAWw27n8WQBpAMIAtADwEgCZa8KDJFHXT3YArzOziZkNzJzFzOuZuYCZdQAWAxhczvqpzPwpM9sArATQEo7/kG6XJaK2AHoBeI2Zzcy8H8D3ZW3QzRhXMHMyMxsArAUQ7Vw+EcAWZt7LzCYArzpfg7J8C2AqABBRIICRzmVg5nhm/i8zW5k5BcC/S4mjNJOd8R1n5nw4DkxF928PMx9jZjszH3Vuz516AUdiP8XMXznj+hZAIoC7i5Qp67Upz60AtAD+6nyPdgPYAudrA8ACoDMRBTHzNWY+VGR5SwDtmNnCzPtYJgXyKEnU9VMmMxsLHxCRPxH929k1kAfHV+2Qol//r3O58A4zFzjvaitZthWA7CLLAOBCWQG7GePlIvcLisTUqmjdzkSZVda24Gg9jyciXwDjARxi5lRnHB2dX+svO+N4G47WdUWKxQAg9br960NEPzu7dnIBPOZmvYV1p163LBVA6yKPy3ptKoyZmYse1IrWOwGOg1gqEf1CRH2dy98BcBrAj0R0logWurcborZIoq6frm/dPAsgAkAfZg7Cn1+1y+rOqAmXADQhIv8iy9qUU746MV4qWrdzm03LKszMCXAkpBEo3u0BOLpQEgHc4ozjparEAEf3TVHfwPGNog0zBwP4V5F6K2qNXoSjS6iotgDS3YironrbXNe/7KqXmf9g5jFwdItsgqOlDmbWMfOzzHwjgHsAPENEt1UzFlENkqgbhkA4+nxznP2dr9f2Bp0t1DgAi4jIx9kau7ucVaoT4zoAo4logPPE35uo+LP7DYAn4TggfHddHHkA9EQUCWCOmzGsBTCDiDo7DxTXxx8IxzcMIxH1huMAUSgTjq6aG8uoexuAjkQ0jYhURHQvgM5wdFNUx+9wtL4XEJGaiIbA8R6tdr5n04komJktcLwmdgAgotFEdLPzXEQuHP365XU1iVomibphWALAD8BVAP8F8J862u50OE7IZQF4C8AaOMZ7l2YJqhgjM58A8DgcyfcSgGtwnOwqT2Ef8W5mvlpk+XNwJFEdgE+dMbsTw3bnPuyGo1tg93VF5gJ4k4h0AF6Ds3XqXLcAjj75X50jKW69ru4sAKPh+NaRBWABgNHXxV1pzGyGIzGPgON1/xjAA8yc6CxyP4AUZxfQY3C8n4DjZOlPAPQAfgPwMTP/XJ1YRPWQnCMQNYWI1gBIZOZab9EL0ZhIi1pUGRH1IqKbiEjhHL42Bo6+TiFEDZIrE0V13ABgAxwn9tIAzGHmw54NSYiGR7o+hBDCy7nVoibHXBM6OM7+Wpk5tjaDEkII8afKdH0MdfcsdLNmzbh9+/ZVi0gIIRqh+Pj4q8wcVtpztdJH3b59e8TFxdVG1UII0SAR0fVXp7q4O+qD4bicNJ6IZpexkdlEFEdEcZmZmVWJUwghRCncTdQDmLkHHAPnHyeiQdcXYOZlzBzLzLFhYaW23oUQQlSBW4mamQvnBsgAsBFA79oMSgghxJ8qTNREFOCcKhJEFABgOIDjtR2YEEIIB3dOJrYAsNE5V7wKwDfMXFdzSQghRKNXYaJm5rMAutdBLEIIIUohc30IIYSXk0TdSOT9Zwcsly55OgwhRBVIom4EbDk5SH/qKWS8956nQxFCVIEk6kbAcPwEAEC/azfsprLm9RdCeCtJ1I2A8fgxAIA9Px/6vXs9HI0QorIkUdcwc2oqUqZMhSW9ur9LWnMMx45D3bYtlE2aIG/bNk+HI4SoJEnUNSz7q69hOHIE2au+qbhwHTEeOwa/7t0ReOdw6Pf8AntBgadDEkJUgiTqGmQ3GJD7/fcAgNwNG7yiP9hyJQPWjAz4RXVF8MiRYIMBup/ld0qFqE/qdaK2m82wetFMfXk7dsCel4emcx6DLScHuh9/9HRIMJ5wXO2v6doVfj17QtW8OfK2b/dwVKImMDMuvfoasr/6GvJLTQ1bvU7Umf/4J86MHAWbXu/pUAAAOd+tg0+7dgh74gmo27XFtTVrPB0SDMeOAUolNJ06gRQKBI24C/m/7IVNp/N0aKKaCv74AznffYcrixcjbd482HJzPR2SqCX1NlHbjUbkbNwIu07nFS1E0+nTMMTHI2TyZJBSidDJ98IQFw/TqVMejct47Dh8b74ZCj8/AEDQiBFgiwW6Xbs8GldjYMvJqdXzAbnr10Oh1SLsmWeg3/MLzo2f4Dgwiwan3iZq3Y8/wp6XB0VAAHLXb/B0OMj57jtArUbwuLEAgODx40BqNa6tWeuxmJgZxmPHoInq6lqm6d4d6latZPRHLTMmJ+PMiJE4e/c9MCYn13j9Np0OeTt+RNCoUWg2exbaffUl2G5HyrTp0hXSANXbRJ3z3Tqo27VFszmPwXDkCExnzngsFrvJhNxNmxF4+21QNWkCAFCFhiLwzjuRu3kz7AZDleu15eRUOS5LWhpsubnw6xrlWkZECBo5AvkHfoP12rUq1y3KZjpzBucfmglSqcBmM1KnTqvx8et5W7eBjUaETJwAAPCPiUGHDeuh7dcPVxYvRvqTT0n3VgNSLxO16dw5FPzxB0ImTETw2LGAUomcDZ5rVet+3Albbi5CJ08utjx0yr2Orpltle+aMaem4tw9Y3B2zNgqJ3qj82tw0RY1AASNHAlYrdDt3FmlekXZTGfPIXXGDEBBaLtyJdp/txbqtm1x4bE5yP7yqxpr6easXw/fjh2h6frne6sKDUX4Jx+j+fPPQbdrFy4+v6BGtiU8r14m6tz16wGlEiHjxkLVrBm0Q4Ygd/P3YIvFI/HkrF0LdZs28O/Tp9hyv5494XPTTZU+qVgQH4+Ue6fAmpUF65UruLa6aiclDceOg3x8oLnllmLLfTt1gk+7dl7Rt9+QmFNTcX7GDMDOaLdiBXxv7AD1DTeg/ddfQTtsKK68/TYuv/FGtT+nxqRkGI8dQ8jECXDOE+9CCgWaPvwwms58CPp9++RbUwNR7xI1WyzI2bgJ2qF
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "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": "066c889a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scenario: JNY\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": null,
   "id": "452840ea",
   "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.8.10"
  },
  "toc-showtags": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}