Step_04_RecognizerModel_training.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "accessible-mountain",
   "metadata": {},
   "source": [
    "# Recognizer Model Traning & Evalidation\n",
    "By Benedict Steuerlein and Sven Mayer \n",
    "\n",
    "This script is just for showcasing purposes, the resuls are of this script are not reported in the paper. However, all number reported can be recreated based on this script by filtering the classes needed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "colored-community",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python version:  3.8.10 (default, Mar 15 2022, 12:22:08) \n",
      "[GCC 9.4.0]\n",
      "numpy version 1.23.1\n",
      "matplotlib version 3.5.2\n",
      "TF: 2.9.1\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(\"Python version: \", sys.version)\n",
    "import numpy as np\n",
    "print(\"numpy version\", np.__version__)\n",
    "import pandas as pd\n",
    "import itertools\n",
    "import random\n",
    "\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "print(\"matplotlib version\", matplotlib.__version__)\n",
    "\n",
    "import imutils\n",
    "\n",
    "from tqdm import tqdm\n",
    "tqdm.pandas()\n",
    "\n",
    "from sklearn.preprocessing import OneHotEncoder \n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "from perlin_numpy import generate_perlin_noise_3d\n",
    "\n",
    "import tensorflow as tf\n",
    "print(\"tensorflow version\", tf.__version__)\n",
    "\n",
    "physical_devices = tf.config.experimental.list_physical_devices('GPU')\n",
    "if len(physical_devices) > 0:\n",
    "    tf.config.set_visible_devices(physical_devices[0], 'GPU')\n",
    "    tf.config.experimental.set_memory_growth(physical_devices[0], True)\n",
    "\n",
    "import simulate\n",
    "import process\n",
    "import recognizer\n",
    "\n",
    "from pathlib import Path\n",
    "Path(\"./figures\").mkdir(parents=True, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "incomplete-storm",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-07-11 23:30:19.565736: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2022-07-11 23:30:20.841657: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 24881 MB memory:  -> device: 0, name: Tesla V100-SXM2-32GB, pci bus id: 0000:62:00.0, compute capability: 7.0\n"
     ]
    }
   ],
   "source": [
    "DATA_PATH = \"./data/\"\n",
    "MARKER_PATH = \"./markers_official/\"\n",
    "\n",
    "simulator = tf.keras.models.load_model(\"./model_simulator/\", compile = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "powered-award",
   "metadata": {},
   "source": [
    "# DataGenerator\n",
    "\n",
    "### Generates training data for classifier on the fly\n",
    "\n",
    "1. Load templates for ids\n",
    "2. Apply noise to template\n",
    "3. Let GAN predict on template \n",
    "4. GAN results == x_true\n",
    "5. Y_class == respective OneHot-Vectors\n",
    "6. Y_rot == angle in radians (degree doesn't work well, error with radians is ~90degree) \n",
    "7. Yield list x_true, y_class, y_rot\n",
    "\n",
    "Technically we can generate an infinite amount of training data just by augmenting with noise.\n",
    "However, per epoch we do not want to simulate markers randomly (e.g. simulate only Marker with ID 10) but simulate every marker in every roatition and size - the random noise and shifting of markers will do the trick\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "stupid-scanning",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DataGenerator:\n",
    "    def __init__(self, simulator, df, batch_size = 64, shuffle = True):\n",
    "        self.batch_size = batch_size\n",
    "        self.shuffle = shuffle\n",
    "        self.df = df\n",
    "        self.simulator = simulator\n",
    "    \n",
    "    def __applyPerlin__(self, markers):\n",
    "        noise = generate_perlin_noise_3d((self.batch_size, 32, 32), (1, (np.random.randint(2) + 1)*2, (np.random.randint(2) + 1)*2), tileable=(True, False, False)).reshape(self.batch_size, 32, 32, 1)\n",
    "        return markers + ((markers+1)*noise)\n",
    "    \n",
    "    def __call__(self, shuffle=True):\n",
    "        \n",
    "        while True:\n",
    "            indexs = np.arange(len(self.df))\n",
    "            if self.shuffle:\n",
    "                np.random.shuffle(indexs)\n",
    "\n",
    "            for x in range(len(self.df)//self.batch_size):\n",
    "                idx = indexs[np.arange(x*self.batch_size, (x+1)*self.batch_size)]\n",
    "\n",
    "                X = np.stack(self.df.Simulation.iloc[idx]).reshape(self.batch_size, 32, 32, 1)\n",
    "                X = self.__applyPerlin__(X)\n",
    "                \n",
    "                y_class = np.stack(self.df.Target.iloc[idx].values)\n",
    "                y_rot = np.vstack(self.df.SinCos.iloc[idx].values)\n",
    "\n",
    "                yield X, (y_class, y_rot)\n",
    "                "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "electoral-bumper",
   "metadata": {},
   "source": [
    "### Prepare markers permutations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "three-migration",
   "metadata": {},
   "outputs": [],
   "source": [
    "sizes = [8]\n",
    "shift_amount = [-1,0,1]\n",
    "rotations = np.arange(360)\n",
    "\n",
    "markerTypeId = [['16h5', 10], ['16h5', 11], ['16h5', 12], ['16h5', 13], ['16h5', 14], ['16h5', 15], ['16h5', 16], ['16h5', 17], ['16h5', 18], ['16h5', 19]]\n",
    "product = list(itertools.product(*[sizes, rotations, shift_amount, shift_amount]))\n",
    "to_sim = [list(item[0]) + list(item[1]) for item in list(itertools.product(*[markerTypeId, product]))]\n",
    "len(to_sim)\n",
    "\n",
    "df = pd.DataFrame(data = to_sim, columns = ['MarkerType', 'Id', 'Size', 'Angle', 'Shift0', 'Shift1'])\n",
    "df['Angle'] = df.Angle.astype(np.float32)\n",
    "\n",
    "df.head()\n",
    "\n",
    "# Get unique pairs of marker, id and size\n",
    "uniqueMakers = df.groupby(['MarkerType', 'Id', 'Size']).indices.keys()\n",
    "\n",
    "# (Re)Map unique pairs to a unique id\n",
    "uid = dict(zip(uniqueMakers, list(range(len(uniqueMakers)))))\n",
    "re_uid = dict(zip(uid.values(),uid.keys()))\n",
    "\n",
    "df['U_Id'] = df.apply(lambda r: uid[(r.MarkerType, r.Id, r.Size)], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "179f43cd-e037-48e5-98e8-fbeb9b71d774",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>MarkerType</th>\n",
       "      <th>Size</th>\n",
       "      <th>MarkerCount</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>16h5</td>\n",
       "      <td>8</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  MarkerType  Size  MarkerCount\n",
       "0       16h5     8           10"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.groupby([\"MarkerType\", \"Size\"]).apply(lambda e: len(e.Id.unique())).reset_index().rename(columns = {0:\"MarkerCount\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e1b8210-7703-4da6-9685-1a1166d87525",
   "metadata": {},
   "source": [
    "# Simulate Templates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2f50ed99-c230-4e0e-bc8e-7519d419903a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 32400/32400 [00:08<00:00, 3867.73it/s]\n",
      "100%|██████████| 32400/32400 [00:02<00:00, 15390.95it/s]\n",
      "  0%|          | 0/32 [00:00<?, ?it/s]2022-07-11 23:30:37.171035: I tensorflow/stream_executor/cuda/cuda_dnn.cc:384] Loaded cuDNN version 8401\n",
      "2022-07-11 23:30:38.022324: I tensorflow/core/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n",
      "100%|██████████| 32/32 [00:26<00:00,  1.19it/s]\n"
     ]
    }
   ],
   "source": [
    "# As the template is 4 times larger than the capactive image we need to shift it factors * 4.\n",
    "def shiftTemplate(row):\n",
    "    template = np.roll(row.Template, row.Shift0 * 4, axis = 0)\n",
    "    return np.roll(template, row.Shift1 * 4, axis = 1)\n",
    "\n",
    "df[\"Template\"] = df.progress_apply(lambda e: simulate.load_tag(e.Size, e.MarkerType, e.Id, e.Angle, MARKER_PATH = MARKER_PATH), axis=1)\n",
    "df.Template = df.Template /127.5 -1. \n",
    "df.Template = df.progress_apply(lambda e: shiftTemplate(e), axis = 1)\n",
    "\n",
    "batch_size = 1024 # Lower if the GPU can't handle as many. \n",
    "simulations = []\n",
    "for i in tqdm(range(0,len(df),batch_size)):\n",
    "    x = df.Template.iloc[i:i+batch_size].values\n",
    "    x = np.expand_dims(np.stack(x), axis = 3)\n",
    "    simulations.append(simulator.predict(x, verbose=0,  use_multiprocessing=True, batch_size=batch_size))\n",
    "    \n",
    "df['Simulation'] = list(np.vstack(simulations).reshape(-1,32,32))\n",
    "\n",
    "# Change degree values of angles to radians\n",
    "df['AngleRad'] = np.radians(df['Angle'])\n",
    "df['SinCos'] = df.AngleRad.apply(lambda e: np.array([np.sin(e), np.cos(e)]))\n",
    "df['AngleDegNew'] = df.SinCos.apply(lambda x: np.rad2deg(np.arctan2(x[0], x[1])))\n",
    "\n",
    "#Prepare and train the recognizer\n",
    "nb_classes = len(df.U_Id.unique())        \n",
    "group_mapper = dict(zip(df.U_Id.unique(), np.arange(nb_classes)))\n",
    "one_hot_targets = np.eye(nb_classes)\n",
    "\n",
    "df['U_Id_Group'] = df.U_Id.apply(lambda e: group_mapper[e])\n",
    "df['Target'] = df.U_Id_Group.apply(lambda e: one_hot_targets[int(e)])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "80daf2cc-93d9-4baf-ad27-da7cd0c36e6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "e = df.iloc[0]\n",
    "fig, ax = plt.subplots(1,2, figsize=(10,5))\n",
    "ax[0].imshow(e.Template)\n",
    "ax[1].imshow(e.Simulation)\n",
    "plt.suptitle(f\"{e.MarkerType} ID{e.Id} {e.Size}mm -- U_Id{e.U_Id}\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "asian-sauce",
   "metadata": {},
   "source": [
    "# Filter only markers wanted in the Recognizer Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f600fdb2-616d-49ba-90dc-d7bab99df1e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Available Settings:\n",
      "Marker ['16h5']\n",
      "Size [8]\n"
     ]
    }
   ],
   "source": [
    "print(\"Available Settings:\")\n",
    "print(\"Marker\", df.MarkerType.unique())\n",
    "print(\"Size\", df.Size.unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f1960356-eeaf-45c7-9921-a52db568ac64",
   "metadata": {},
   "outputs": [],
   "source": [
    "datasetsPaths = [f\"{DATA_PATH}36h11_validation.pkl\", f\"{DATA_PATH}16h5_validation.pkl\"]\n",
    "lstdfs = []\n",
    "for p in datasetsPaths:\n",
    "    lstdfs.append(pd.read_pickle(p))\n",
    "df_val = pd.concat(lstdfs)\n",
    "df_val = df_val[df_val.MarkerType.isin(df.MarkerType.unique()) & df_val.Size.isin(df.Size.unique()) & df_val.Id.isin(df.Id.unique())]\n",
    "df_val.reset_index(drop = True, inplace = True)\n",
    "\n",
    "df_val['Angle'] = df_val.Angle.astype(np.float32)\n",
    "df_val['AngleRad'] = np.radians(df_val['Angle'])\n",
    "df_val['SinCos'] = df_val.AngleRad.apply(lambda e: (np.sin(e), np.cos(e)))\n",
    "df_val['AngleDegNew'] = df_val.SinCos.apply(lambda x: np.rad2deg(np.arctan2(x[0],x[1])))\n",
    "\n",
    "df_val['U_Id'] = df_val.apply(lambda r: uid[(r.MarkerType, r.Id, r.Size)], axis = 1)\n",
    "\n",
    "df_val.groupby([\"MarkerType\", \"Size\"]).apply(lambda e: len(e.Id.unique())).reset_index().rename(columns = {0:\"MarkerCount\"})\n",
    "\n",
    "df_val['U_Id_Group'] = df_val.U_Id.apply(lambda e: group_mapper[e])\n",
    "df_val['Target'] = df_val.U_Id_Group.apply(lambda e: one_hot_targets[int(e)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fe56540b-7819-4a91-a25c-3a6a1a8dbf20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "e = df_val.iloc[0]\n",
    "fig, ax = plt.subplots(1,1, figsize=(10,5))\n",
    "ax.imshow(e.Blob)\n",
    "plt.suptitle(f\"{e.MarkerType} ID{e.Id} {e.Size}mm -- U_Id{e.U_Id}\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "satisfactory-florist",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensorflow verion: 2.9.1\n",
      "Model: \"recognizer\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      " input (InputLayer)             [(None, 32, 32, 1)]  0           []                               \n",
      "                                                                                                  \n",
      " Conv0 (Conv2D)                 (None, 32, 32, 64)   640         ['input[0][0]']                  \n",
      "                                                                                                  \n",
      " Conv1 (Conv2D)                 (None, 32, 32, 64)   36928       ['Conv0[0][0]']                  \n",
      "                                                                                                  \n",
      " BatchNorm0 (BatchNormalization  (None, 32, 32, 64)  256         ['Conv1[0][0]']                  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " MaxPool0 (MaxPooling2D)        (None, 16, 16, 64)   0           ['BatchNorm0[0][0]']             \n",
      "                                                                                                  \n",
      " dropout (Dropout)              (None, 16, 16, 64)   0           ['MaxPool0[0][0]']               \n",
      "                                                                                                  \n",
      " Conv2 (Conv2D)                 (None, 16, 16, 128)  73856       ['dropout[0][0]']                \n",
      "                                                                                                  \n",
      " Conv3 (Conv2D)                 (None, 16, 16, 128)  147584      ['Conv2[0][0]']                  \n",
      "                                                                                                  \n",
      " BatchNorm1 (BatchNormalization  (None, 16, 16, 128)  512        ['Conv3[0][0]']                  \n",
      " )                                                                                                \n",
      "                                                                                                  \n",
      " MaxPool1 (MaxPooling2D)        (None, 8, 8, 128)    0           ['BatchNorm1[0][0]']             \n",
      "                                                                                                  \n",
      " dropout_1 (Dropout)            (None, 8, 8, 128)    0           ['MaxPool1[0][0]']               \n",
      "                                                                                                  \n",
      " ConvC1 (Conv2D)                (None, 8, 8, 128)    147584      ['dropout_1[0][0]']              \n",
      "                                                                                                  \n",
      " ConvR1 (Conv2D)                (None, 8, 8, 128)    147584      ['dropout_1[0][0]']              \n",
      "                                                                                                  \n",
      " ConvC2 (Conv2D)                (None, 8, 8, 64)     73792       ['ConvC1[0][0]']                 \n",
      "                                                                                                  \n",
      " ConvR2 (Conv2D)                (None, 8, 8, 64)     73792       ['ConvR1[0][0]']                 \n",
      "                                                                                                  \n",
      " BatchNormC1 (BatchNormalizatio  (None, 8, 8, 64)    256         ['ConvC2[0][0]']                 \n",
      " n)                                                                                               \n",
      "                                                                                                  \n",
      " BatchNormR1 (BatchNormalizatio  (None, 8, 8, 64)    256         ['ConvR2[0][0]']                 \n",
      " n)                                                                                               \n",
      "                                                                                                  \n",
      " MaxPoolC1 (MaxPooling2D)       (None, 4, 4, 64)     0           ['BatchNormC1[0][0]']            \n",
      "                                                                                                  \n",
      " MaxPoolR1 (MaxPooling2D)       (None, 4, 4, 64)     0           ['BatchNormR1[0][0]']            \n",
      "                                                                                                  \n",
      " dropout_2 (Dropout)            (None, 4, 4, 64)     0           ['MaxPoolC1[0][0]']              \n",
      "                                                                                                  \n",
      " dropout_4 (Dropout)            (None, 4, 4, 64)     0           ['MaxPoolR1[0][0]']              \n",
      "                                                                                                  \n",
      " flatten (Flatten)              (None, 1024)         0           ['dropout_2[0][0]']              \n",
      "                                                                                                  \n",
      " flatten_1 (Flatten)            (None, 1024)         0           ['dropout_4[0][0]']              \n",
      "                                                                                                  \n",
      " dense (Dense)                  (None, 512)          524800      ['flatten[0][0]']                \n",
      "                                                                                                  \n",
      " dense_1 (Dense)                (None, 512)          524800      ['flatten_1[0][0]']              \n",
      "                                                                                                  \n",
      " BatchNormC2 (BatchNormalizatio  (None, 512)         2048        ['dense[0][0]']                  \n",
      " n)                                                                                               \n",
      "                                                                                                  \n",
      " BatchNormR2 (BatchNormalizatio  (None, 512)         2048        ['dense_1[0][0]']                \n",
      " n)                                                                                               \n",
      "                                                                                                  \n",
      " dropout_3 (Dropout)            (None, 512)          0           ['BatchNormC2[0][0]']            \n",
      "                                                                                                  \n",
      " dropout_5 (Dropout)            (None, 512)          0           ['BatchNormR2[0][0]']            \n",
      "                                                                                                  \n",
      " class_output (Dense)           (None, 10)           5130        ['dropout_3[0][0]']              \n",
      "                                                                                                  \n",
      " rot_output (Dense)             (None, 2)            1026        ['dropout_5[0][0]']              \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 1,762,892\n",
      "Trainable params: 1,760,204\n",
      "Non-trainable params: 2,688\n",
      "__________________________________________________________________________________________________\n",
      "None\n",
      "Epoch 1/10\n",
      "405/405 [==============================] - 19s 43ms/step - loss: 2.2639 - class_output_loss: 1.3808 - rot_output_loss: 0.8831 - class_output_categorical_accuracy: 0.5388 - rot_output_angular_error: 0.8831 - val_loss: 1.1040 - val_class_output_loss: 0.4848 - val_rot_output_loss: 0.6193 - val_class_output_categorical_accuracy: 0.8374 - val_rot_output_angular_error: 0.6193\n",
      "Epoch 2/10\n",
      "405/405 [==============================] - 17s 42ms/step - loss: 0.9869 - class_output_loss: 0.3774 - rot_output_loss: 0.6095 - class_output_categorical_accuracy: 0.8625 - rot_output_angular_error: 0.6095 - val_loss: 0.5773 - val_class_output_loss: 0.1247 - val_rot_output_loss: 0.4526 - val_class_output_categorical_accuracy: 0.9573 - val_rot_output_angular_error: 0.4526\n",
      "Epoch 3/10\n",
      "405/405 [==============================] - 16s 41ms/step - loss: 0.7073 - class_output_loss: 0.1995 - rot_output_loss: 0.5079 - class_output_categorical_accuracy: 0.9328 - rot_output_angular_error: 0.5079 - val_loss: 0.3504 - val_class_output_loss: 0.0423 - val_rot_output_loss: 0.3081 - val_class_output_categorical_accuracy: 0.9881 - val_rot_output_angular_error: 0.3081\n",
      "Epoch 4/10\n",
      "405/405 [==============================] - 16s 40ms/step - loss: 0.5496 - class_output_loss: 0.1272 - rot_output_loss: 0.4224 - class_output_categorical_accuracy: 0.9554 - rot_output_angular_error: 0.4224 - val_loss: 0.2991 - val_class_output_loss: 0.0336 - val_rot_output_loss: 0.2655 - val_class_output_categorical_accuracy: 0.9887 - val_rot_output_angular_error: 0.2655\n",
      "Epoch 5/10\n",
      "405/405 [==============================] - 16s 40ms/step - loss: 0.4734 - class_output_loss: 0.0972 - rot_output_loss: 0.3762 - class_output_categorical_accuracy: 0.9657 - rot_output_angular_error: 0.3762 - val_loss: 0.2607 - val_class_output_loss: 0.0209 - val_rot_output_loss: 0.2399 - val_class_output_categorical_accuracy: 0.9923 - val_rot_output_angular_error: 0.2399\n",
      "Epoch 6/10\n",
      "405/405 [==============================] - 15s 38ms/step - loss: 0.4244 - class_output_loss: 0.0792 - rot_output_loss: 0.3451 - class_output_categorical_accuracy: 0.9733 - rot_output_angular_error: 0.3451 - val_loss: 0.2022 - val_class_output_loss: 0.0065 - val_rot_output_loss: 0.1957 - val_class_output_categorical_accuracy: 0.9988 - val_rot_output_angular_error: 0.1957\n",
      "Epoch 7/10\n",
      "405/405 [==============================] - 15s 36ms/step - loss: 0.3856 - class_output_loss: 0.0658 - rot_output_loss: 0.3199 - class_output_categorical_accuracy: 0.9772 - rot_output_angular_error: 0.3199 - val_loss: 0.2164 - val_class_output_loss: 0.0138 - val_rot_output_loss: 0.2027 - val_class_output_categorical_accuracy: 0.9958 - val_rot_output_angular_error: 0.2027\n",
      "Epoch 8/10\n",
      "405/405 [==============================] - 14s 34ms/step - loss: 0.3718 - class_output_loss: 0.0650 - rot_output_loss: 0.3068 - class_output_categorical_accuracy: 0.9774 - rot_output_angular_error: 0.3068 - val_loss: 0.1660 - val_class_output_loss: 0.0028 - val_rot_output_loss: 0.1632 - val_class_output_categorical_accuracy: 0.9994 - val_rot_output_angular_error: 0.1632\n",
      "Epoch 9/10\n",
      "405/405 [==============================] - 14s 35ms/step - loss: 0.3474 - class_output_loss: 0.0546 - rot_output_loss: 0.2928 - class_output_categorical_accuracy: 0.9811 - rot_output_angular_error: 0.2928 - val_loss: 0.1696 - val_class_output_loss: 0.0035 - val_rot_output_loss: 0.1661 - val_class_output_categorical_accuracy: 0.9989 - val_rot_output_angular_error: 0.1661\n",
      "Epoch 10/10\n",
      "405/405 [==============================] - 14s 34ms/step - loss: 0.3350 - class_output_loss: 0.0493 - rot_output_loss: 0.2857 - class_output_categorical_accuracy: 0.9829 - rot_output_angular_error: 0.2857 - val_loss: 0.1820 - val_class_output_loss: 0.0033 - val_rot_output_loss: 0.1787 - val_class_output_categorical_accuracy: 0.9991 - val_rot_output_angular_error: 0.1787\n",
      "4546/4546 [==============================] - 24s 5ms/step\n"
     ]
    }
   ],
   "source": [
    "# Set Hyperparamter for recognizer training\n",
    "\n",
    "batch_size = 64\n",
    "epochs = 10\n",
    "\n",
    "\n",
    "# Split dataframe into train/val\n",
    "index = list(df.index)\n",
    "np.random.shuffle(index)\n",
    "\n",
    "t_split = .8\n",
    "\n",
    "idx_t = index[:int(t_split * len(index))]\n",
    "idx_v = index[int(t_split * len(index)):]\n",
    "\n",
    "df['Datatype'] = -1\n",
    "df.loc[idx_t, 'Datatype'] = 'train'\n",
    "df.loc[idx_v, 'Datatype'] = 'val'\n",
    "\n",
    "# Init data generators for train and test using the simulator model\n",
    "gen_train = DataGenerator(simulator, df[df.Datatype == 'train'], batch_size=batch_size)\n",
    "gen_val = DataGenerator(simulator, df[df.Datatype == 'val'], batch_size=batch_size)\n",
    "\n",
    "dataset_train = tf.data.Dataset.from_generator(gen_train, \n",
    "                                     output_signature=(\n",
    "     tf.TensorSpec(shape=(batch_size, 32, 32, 1), dtype=tf.float32),\n",
    "     (tf.TensorSpec(shape=(batch_size, nb_classes), dtype=tf.float32),\n",
    "     tf.TensorSpec(shape=(batch_size, 2), dtype=tf.float32)))).prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "dataset_val = tf.data.Dataset.from_generator(gen_val, \n",
    "                                     output_signature=(\n",
    "     tf.TensorSpec(shape=(batch_size, 32, 32, 1), dtype=tf.float32),\n",
    "     (tf.TensorSpec(shape=(batch_size, nb_classes), dtype=tf.float32),\n",
    "     tf.TensorSpec(shape=(batch_size, 2), dtype=tf.float32)))).prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "steps_train = len(df[df.Datatype == 'train'])//batch_size\n",
    "steps_val = len(df[df.Datatype == 'val'])//batch_size\n",
    "\n",
    "#train recognizer\n",
    "classifier = recognizer.Recognizer(dataset_train, dataset_val, nb_classes, steps_train, steps_val)\n",
    "history = classifier.train(batch_size = batch_size, epochs = epochs)\n",
    "\n",
    "del gen_train\n",
    "del gen_val\n",
    "\n",
    "# test recognizer quality\n",
    "x_val = np.stack((df_val.Blob/127.5 - 1.).values).reshape(-1,32,32,1)\n",
    "y_class_true = np.argmax(np.stack(df_val.Target.values), axis = 1)\n",
    "\n",
    "class_pred, rot_pred = classifier.model.predict(x_val)\n",
    "\n",
    "class_pred = np.argmax(class_pred, axis = 1)\n",
    "\n",
    "cm = confusion_matrix(y_class_true, class_pred, labels=range(nb_classes))\n",
    "accuracy = accuracy_score(y_true=y_class_true, y_pred=class_pred)\n",
    "\n",
    "rot_pred_rad = np.arctan2(rot_pred[:,0], rot_pred[:,1])\n",
    "rot_true = rot_true = df_val.AngleRad.values\n",
    "rot_error = np.rad2deg(((rot_pred_rad-rot_true + np.pi)%(2*np.pi))-np.pi)\n",
    "\n",
    "\n",
    "res = {\n",
    "    'Accuracy':accuracy,\n",
    "    'Rotation_Errors':rot_error,\n",
    "    'Confusion':cm\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cb3cd855-2c62-400a-ae6d-c7f6961f58e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "group_mapperT = dict((v,k) for k,v in group_mapper.items())\n",
    "lstMarkerNames = []\n",
    "for k in sorted(group_mapperT.keys()):\n",
    "    x = re_uid[group_mapperT[k]]\n",
    "    lstMarkerNames.append(f\"{x[0]} ID{x[1]} {x[2]}mm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "78449219-efae-4549-abd4-2e973c673120",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f2e75eefe80>"
      ]
     },
     "execution_count": 13,
     "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": [
    "plt.plot(np.array(history.history[\"class_output_categorical_accuracy\"])*100, label=\"Train\")\n",
    "plt.plot(np.array(history.history[\"val_class_output_categorical_accuracy\"])*100, label=\"Validation\")\n",
    "plt.ylabel(\"Accuracy [%]\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "39e5a206-8fa0-49e7-8708-6946a3ed4c86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f2e767d4250>"
      ]
     },
     "execution_count": 14,
     "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": [
    "plt.plot(np.rad2deg(history.history[\"rot_output_angular_error\"]), label=\"Train\")\n",
    "plt.plot(np.rad2deg(history.history[\"val_rot_output_angular_error\"]), label=\"Validation\")\n",
    "plt.ylabel(\"Angular Error [deg]\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "impaired-detective",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.preprocessing import normalize\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "\n",
    "matrix = res[\"Confusion\"]# confusion_matrix(res[\"Confusion\"])\n",
    "#matrix = df_results.iloc[0].Confusion\n",
    "# array([[  0.,   3.,   6.],\n",
    "#        [  9.,  12.,  15.],\n",
    "#        [ 18.,  21.,  24.]])\n",
    "\n",
    "normed_matrix = normalize(matrix, axis=1, norm='l1')\n",
    "#fig, ax = plt.subplots(1, figsize = (20,20))\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix = normed_matrix.round(2), \n",
    "                              display_labels = lstMarkerNames)\n",
    "disp.plot(cmap = plt.cm.Blues)\n",
    "ax = disp.ax_\n",
    "ax.set_xticks(np.arange(nb_classes))\n",
    "#ax.set_yticklabels([re_uid[x] for x in df_results.iloc[-1].Classes])\n",
    "ax.set_ylabel('True Label')\n",
    "ax.set_xlabel('Predicted Label')\n",
    "\n",
    "ax.set_xticklabels(lstMarkerNames, rotation = -90)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}