diff --git a/README.odt b/README.odt
new file mode 100644
index 0000000..c9cf808
Binary files /dev/null and b/README.odt differ
diff --git a/notebooks/v2_DenseNet_dataaug.ipynb b/notebooks/v2_DenseNet_dataaug.ipynb
new file mode 100644
index 0000000..b8f11d3
--- /dev/null
+++ b/notebooks/v2_DenseNet_dataaug.ipynb
@@ -0,0 +1,1065 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "35472663-a1e6-4228-a178-5006b2effe76",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "d43896a6-ec52-44e5-a44e-cd7fabd18f18",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "DATA_RAW_PATH = \"../data/RAW/RT-BENE.zip\" \n",
+ "DATA_INTER_PATH = \"/opt/data/Ubuntu/projects/RT-BENE/data/intermediate\"\n",
+ "DATA_PATH = f\"{DATA_INTER_PATH}/RT-BENE\"\n",
+ "if not os.path.exists(DATA_PATH):\n",
+ " !unzip -q $DATA_RAW_PATH -d $DATA_INTER_PATH"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "da68634c-20ed-4ada-967b-a10f34029522",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import tensorflow as tf"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "3cb3c96d-687c-483c-a0d3-1144962d32b9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " blink_id | \n",
+ " left_eye | \n",
+ " right_eye | \n",
+ " video | \n",
+ " blink | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 | \n",
+ " 0 | \n",
+ " 0_left_000001_rgb.png | \n",
+ " 0_right_000001_rgb.png | \n",
+ " 0 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 1 | \n",
+ " 1 | \n",
+ " 0_left_000002_rgb.png | \n",
+ " 0_right_000002_rgb.png | \n",
+ " 0 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 2 | \n",
+ " 0_left_000003_rgb.png | \n",
+ " 0_right_000003_rgb.png | \n",
+ " 0 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " 3 | \n",
+ " 0_left_000004_rgb.png | \n",
+ " 0_right_000004_rgb.png | \n",
+ " 0 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 4 | \n",
+ " 4 | \n",
+ " 0_left_000005_rgb.png | \n",
+ " 0_right_000005_rgb.png | \n",
+ " 0 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ "
\n",
+ " \n",
+ " 107345 | \n",
+ " 107345 | \n",
+ " 16_left_009059_rgb.png | \n",
+ " 16_right_009059_rgb.png | \n",
+ " 16 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 107346 | \n",
+ " 107346 | \n",
+ " 16_left_009060_rgb.png | \n",
+ " 16_right_009060_rgb.png | \n",
+ " 16 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 107347 | \n",
+ " 107347 | \n",
+ " 16_left_009061_rgb.png | \n",
+ " 16_right_009061_rgb.png | \n",
+ " 16 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 107348 | \n",
+ " 107348 | \n",
+ " 16_left_009062_rgb.png | \n",
+ " 16_right_009062_rgb.png | \n",
+ " 16 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ " 107349 | \n",
+ " 107349 | \n",
+ " 16_left_009063_rgb.png | \n",
+ " 16_right_009063_rgb.png | \n",
+ " 16 | \n",
+ " 0 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
107350 rows × 5 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " blink_id left_eye right_eye video \\\n",
+ "0 0 0_left_000001_rgb.png 0_right_000001_rgb.png 0 \n",
+ "1 1 0_left_000002_rgb.png 0_right_000002_rgb.png 0 \n",
+ "2 2 0_left_000003_rgb.png 0_right_000003_rgb.png 0 \n",
+ "3 3 0_left_000004_rgb.png 0_right_000004_rgb.png 0 \n",
+ "4 4 0_left_000005_rgb.png 0_right_000005_rgb.png 0 \n",
+ "... ... ... ... ... \n",
+ "107345 107345 16_left_009059_rgb.png 16_right_009059_rgb.png 16 \n",
+ "107346 107346 16_left_009060_rgb.png 16_right_009060_rgb.png 16 \n",
+ "107347 107347 16_left_009061_rgb.png 16_right_009061_rgb.png 16 \n",
+ "107348 107348 16_left_009062_rgb.png 16_right_009062_rgb.png 16 \n",
+ "107349 107349 16_left_009063_rgb.png 16_right_009063_rgb.png 16 \n",
+ "\n",
+ " blink \n",
+ "0 0 \n",
+ "1 0 \n",
+ "2 0 \n",
+ "3 0 \n",
+ "4 0 \n",
+ "... ... \n",
+ "107345 0 \n",
+ "107346 0 \n",
+ "107347 0 \n",
+ "107348 0 \n",
+ "107349 0 \n",
+ "\n",
+ "[107350 rows x 5 columns]"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data = pd.read_csv(f\"{DATA_PATH}/blinks.csv\")\n",
+ "data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d358eef2-c764-4557-86b2-104413d7c6ff",
+ "metadata": {},
+ "source": [
+ "### How many videos do we have?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "0df339bd-3747-4f21-b2a2-3821ff303e32",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([ 0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "video_ids = np.unique(data[\"video\"])\n",
+ "video_ids"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "859f2a1e-1858-4671-a36e-8895f9c4008c",
+ "metadata": {},
+ "source": [
+ "### Total images"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "2fc1945a-e8b2-49d4-81fe-06c44aa8364f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "107350"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data[\"blink_id\"].count()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8248cca0-6ca5-4e58-97c0-5c80fab138ba",
+ "metadata": {},
+ "source": [
+ "### How many images per video?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "b86a9305-0d25-4830-8dee-50d87b091bfc",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " Images in video | \n",
+ " % blink frames | \n",
+ "
\n",
+ " \n",
+ " video | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 | \n",
+ " 12865 | \n",
+ " 7.236689 | \n",
+ "
\n",
+ " \n",
+ " 1 | \n",
+ " 8671 | \n",
+ " 1.476185 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 8702 | \n",
+ " 9.066881 | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " 3205 | \n",
+ " 5.210608 | \n",
+ "
\n",
+ " \n",
+ " 4 | \n",
+ " 4750 | \n",
+ " 2.736842 | \n",
+ "
\n",
+ " \n",
+ " 5 | \n",
+ " 5355 | \n",
+ " 2.054155 | \n",
+ "
\n",
+ " \n",
+ " 7 | \n",
+ " 1857 | \n",
+ " 8.023694 | \n",
+ "
\n",
+ " \n",
+ " 8 | \n",
+ " 6108 | \n",
+ " 7.514735 | \n",
+ "
\n",
+ " \n",
+ " 9 | \n",
+ " 4210 | \n",
+ " 1.068884 | \n",
+ "
\n",
+ " \n",
+ " 10 | \n",
+ " 16559 | \n",
+ " 2.131771 | \n",
+ "
\n",
+ " \n",
+ " 11 | \n",
+ " 12817 | \n",
+ " 5.399079 | \n",
+ "
\n",
+ " \n",
+ " 12 | \n",
+ " 935 | \n",
+ " 2.459893 | \n",
+ "
\n",
+ " \n",
+ " 13 | \n",
+ " 9586 | \n",
+ " 3.077405 | \n",
+ "
\n",
+ " \n",
+ " 14 | \n",
+ " 5371 | \n",
+ " 4.002979 | \n",
+ "
\n",
+ " \n",
+ " 15 | \n",
+ " 1810 | \n",
+ " 1.602210 | \n",
+ "
\n",
+ " \n",
+ " 16 | \n",
+ " 4549 | \n",
+ " 0.923280 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Images in video % blink frames\n",
+ "video \n",
+ "0 12865 7.236689\n",
+ "1 8671 1.476185\n",
+ "2 8702 9.066881\n",
+ "3 3205 5.210608\n",
+ "4 4750 2.736842\n",
+ "5 5355 2.054155\n",
+ "7 1857 8.023694\n",
+ "8 6108 7.514735\n",
+ "9 4210 1.068884\n",
+ "10 16559 2.131771\n",
+ "11 12817 5.399079\n",
+ "12 935 2.459893\n",
+ "13 9586 3.077405\n",
+ "14 5371 4.002979\n",
+ "15 1810 1.602210\n",
+ "16 4549 0.923280"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "data_per_video = data.groupby(by=[\"video\"]).count()\n",
+ "blinks_per_video = data.loc[data[\"blink\"] == 1].groupby(by=\"video\").count()\n",
+ "blinks_per_video = blinks_per_video.div(data_per_video, level=\"video\") * 100\n",
+ "data_per_video = pd.concat([data_per_video[\"blink_id\"], blinks_per_video[\"blink\"]], axis=1, keys=[\"Images in video\",\"% blink frames\"])\n",
+ "data_per_video"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "592f11ec-797e-43d1-bd26-187feb077b43",
+ "metadata": {},
+ "source": [
+ "Previous data shows that a rebalancing method will have to be used"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad2e0771-9a36-4378-8798-f79866c728de",
+ "metadata": {},
+ "source": [
+ "#### Split train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "252c72ab-cba5-44d7-bb01-2a59eca9e1b0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(68702, 5)\n",
+ "(17176, 5)\n",
+ "(21470, 5)\n"
+ ]
+ }
+ ],
+ "source": [
+ "test_size = 0.2\n",
+ "val_size = 0.2\n",
+ "train_data = data.sample(frac=1).reset_index(drop=True)\n",
+ "test_data = train_data[int(train_data.shape[0]*(1-test_size)):]\n",
+ "train_data = train_data[:int(train_data.shape[0]*(1-test_size)) -1]\n",
+ "\n",
+ "val_data = train_data[int(train_data.shape[0]*(1-val_size)):]\n",
+ "train_data = train_data[:int(train_data.shape[0]*(1-val_size)) -1]\n",
+ "\n",
+ "print(train_data.shape)\n",
+ "print(val_data.shape)\n",
+ "print(test_data.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0d0bc867-e450-423b-a8fe-56df94d8aec8",
+ "metadata": {},
+ "source": [
+ "#### Generic generator class"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "3fc1e6cf-52fc-4abb-90e1-acfbfcf52836",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import cv2\n",
+ "class RTBeneDataset:\n",
+ " def __init__(self, phase: str, data: pd.DataFrame, mean: float, std: float, transforms = None):\n",
+ " self.phase = phase\n",
+ " self.data = data\n",
+ " self.mean = mean\n",
+ " self.std = std\n",
+ " self.transforms = transforms\n",
+ " self.counter = 0\n",
+ " \n",
+ " if self.phase == \"train\":\n",
+ " #Shuffle the data\n",
+ " self.data = self.data.sample(frac=1).reset_index(drop=True)\n",
+ " else:\n",
+ " self.data = self.data.reset_index(drop=True)\n",
+ " \n",
+ " \n",
+ " def __getitem(self, idx):\n",
+ " row = self.data.loc[idx,[\"left_eye\", \"right_eye\"]].to_list(), self.data.loc[idx,[\"blink\"]].to_list()[0]\n",
+ " return row\n",
+ " \n",
+ " def __call__(self):\n",
+ " for i in range(self.data.shape[0]):\n",
+ " yield self.__getitem(i)\n",
+ " self.counter +=1\n",
+ " \n",
+ " if self.counter == (self.data.shape[0] -1):\n",
+ " # When all the dataset is readed, reshuffle again\n",
+ " self.data = self.data.sample(frac=1).reset_index(drop=True)\n",
+ " \n",
+ " @staticmethod\n",
+ " @tf.function\n",
+ " def tf_load_row(x, y):\n",
+ " image_l = tf.io.read_file(tf.strings.join([f\"{DATA_PATH}/images/\", x[0]]))\n",
+ " image_r = tf.io.read_file(tf.strings.join([f\"{DATA_PATH}/images/\", x[1]]))\n",
+ " image_l = tf.image.decode_png(image_l, channels=3)\n",
+ " image_r = tf.image.decode_png(image_r, channels=3)\n",
+ " y = tf.cast(y, tf.float32)\n",
+ " return (image_l, image_r), [tf.abs(1-y), y]\n",
+ " \n",
+ "def set_shapes(imgs, label, img_shape=(36,60,3)):\n",
+ " imgs[0].set_shape(img_shape)\n",
+ " imgs[1].set_shape(img_shape)\n",
+ " label.set_shape([])\n",
+ " return imgs, label"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dcfba562-db17-48c7-bc33-5689a30f8567",
+ "metadata": {},
+ "source": [
+ "## Resampling to get better distribution of the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "71ecc920-9f14-4400-8484-480a0e9065c9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "train_blink_RTB = RTBeneDataset(\"train\", train_data.loc[train_data[\"blink\"] == 1], 127.5, 1)\n",
+ "train_no_blink_RTB = RTBeneDataset(\"train\", train_data.loc[train_data[\"blink\"] == 0], 127.5, 1)\n",
+ "val_RTB = RTBeneDataset(\"val\", val_data, 127.5, 1)\n",
+ "test_RTB = RTBeneDataset(\"val\", test_data, 127.5, 1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5d99074a-f99c-43ba-a19a-24818ef176c2",
+ "metadata": {},
+ "source": [
+ "### Data augmentation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "c941f6da-d0bf-4e97-918b-eae100a80312",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from albumentations import (\n",
+ " Compose, RandomBrightness, JpegCompression, HueSaturationValue, RandomContrast, HorizontalFlip,\n",
+ " Rotate\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "fffb2712-c61c-43d9-b67d-d462dc4c77bd",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/home/esteve/.local/lib/python3.9/site-packages/albumentations/augmentations/transforms.py:1800: FutureWarning: This class has been deprecated. Please use RandomBrightnessContrast\n",
+ " warnings.warn(\n",
+ "/home/esteve/.local/lib/python3.9/site-packages/albumentations/augmentations/transforms.py:965: FutureWarning: This class has been deprecated. Please use ImageCompression\n",
+ " warnings.warn(\n",
+ "/home/esteve/.local/lib/python3.9/site-packages/albumentations/augmentations/transforms.py:1826: FutureWarning: This class has been deprecated. Please use RandomBrightnessContrast\n",
+ " warnings.warn(\n"
+ ]
+ }
+ ],
+ "source": [
+ "transforms = Compose([\n",
+ " Rotate(limit=20),\n",
+ " RandomBrightness(limit=0.2),\n",
+ " JpegCompression(quality_lower=70, quality_upper=100, p=0.5),\n",
+ " HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.5),\n",
+ " RandomContrast(limit=0.2, p=0.5),\n",
+ " HorizontalFlip(),\n",
+ " ])\n",
+ "\n",
+ "def aug_fn(image):\n",
+ " data = {\"image\":image}\n",
+ " aug_data = transforms(**data)\n",
+ " aug_img = aug_data[\"image\"]\n",
+ " return aug_img\n",
+ "\n",
+ "def scale(image, label):\n",
+ " return (tf.cast(image[0], tf.float32)/255.0, tf.cast(image[1], tf.float32)/255.0), label\n",
+ "\n",
+ "def process_data(image, label):\n",
+ " aug_img_l = tf.numpy_function(func=aug_fn, inp=[image[0]], Tout=tf.uint8)\n",
+ " aug_img_r = tf.numpy_function(func=aug_fn, inp=[image[1]], Tout=tf.uint8)\n",
+ " return (aug_img_l, aug_img_r), label"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "ccd8d481-5151-4a09-bb21-e3ece76b6bce",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2022-02-13 20:09:01.733033: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:01.825211: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:01.825515: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:01.826135: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n",
+ "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
+ "2022-02-13 20:09:01.827386: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:01.827653: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:01.827869: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:02.167259: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:02.167597: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:02.167826: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
+ "2022-02-13 20:09:02.169422: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 9498 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3060, pci bus id: 0000:06:00.0, compute capability: 8.6\n"
+ ]
+ }
+ ],
+ "source": [
+ "batch_size = 256\n",
+ "\n",
+ "blink_dataset = tf.data.Dataset.from_generator(train_blink_RTB, \n",
+ " output_types=(tf.string, tf.float32), \n",
+ " output_shapes=((2),()))\n",
+ "\n",
+ "no_blink_dataset = tf.data.Dataset.from_generator(train_no_blink_RTB, \n",
+ " output_types=(tf.string, tf.float32), \n",
+ " output_shapes=((2),()))\n",
+ "\n",
+ "train_dataset = tf.data.Dataset.sample_from_datasets([blink_dataset, no_blink_dataset], [0.4, 0.6], stop_on_empty_dataset=True)\\\n",
+ " .map(RTBeneDataset.tf_load_row, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
+ " .map(process_data, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
+ " .map(scale, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
+ " .batch(batch_size)\\\n",
+ " .repeat()\n",
+ "\n",
+ "\n",
+ "val_dataset = tf.data.Dataset.from_generator(val_RTB, \n",
+ " output_types=(tf.string, tf.float32), \n",
+ " output_shapes=((2),()))\\\n",
+ " .map(RTBeneDataset.tf_load_row, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
+ " .map(scale, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
+ " .prefetch(tf.data.AUTOTUNE)\\\n",
+ " .batch(batch_size)\n",
+ "\n",
+ "test_dataset = tf.data.Dataset.from_generator(test_RTB, \n",
+ " output_types=(tf.string, tf.float32), \n",
+ " output_shapes=((2),()))\\\n",
+ " .map(RTBeneDataset.tf_load_row, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
+ " .map(scale, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
+ " .prefetch(tf.data.AUTOTUNE)\\\n",
+ " .batch(batch_size)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "131f43fe-745e-474c-9ed8-f7ecf4582e5c",
+ "metadata": {},
+ "source": [
+ "### Test image augmentations"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "5308ccf1-44d6-4217-a4aa-70fe860857b7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "it = train_dataset.as_numpy_iterator()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "30d1aaab-3b44-472e-a484-e6e68b761f4f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for data in it:\n",
+ " #print(data[1])\n",
+ " fig,axs = plt.subplots(10,2, figsize=(4,20))\n",
+ " for i in range(10):\n",
+ " axs[i,0].imshow(data[0][0][i])\n",
+ " axs[i,1].imshow(data[0][1][i])\n",
+ " fig.tight_layout()\n",
+ " break"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "94104655-132f-4517-b98e-5c36107623c9",
+ "metadata": {},
+ "source": [
+ "### Create model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "0ccc5e52-356e-41cc-9434-448d84f4189c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from tensorflow import keras\n",
+ "from tensorflow.keras import regularizers, initializers, layers\n",
+ "from tensorflow.keras.applications import DenseNet121"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "c7dd581f-c27d-4bc3-9084-d45cc726e623",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model: \"densenet_all_data_rebalanced_aug_dropout\"\n",
+ "__________________________________________________________________________________________________\n",
+ " Layer (type) Output Shape Param # Connected to \n",
+ "==================================================================================================\n",
+ " input_1 (InputLayer) [(None, 36, 60, 3)] 0 [] \n",
+ " \n",
+ " input_2 (InputLayer) [(None, 36, 60, 3)] 0 [] \n",
+ " \n",
+ " featext_left (Functional) (None, 1, 1, 1024) 7037504 ['input_1[0][0]'] \n",
+ " \n",
+ " featext_right (Functional) (None, 1, 1, 1024) 7037504 ['input_2[0][0]'] \n",
+ " \n",
+ " concatenate (Concatenate) (None, 1, 1, 2048) 0 ['featext_left[0][0]', \n",
+ " 'featext_right[0][0]'] \n",
+ " \n",
+ " flatten (Flatten) (None, 2048) 0 ['concatenate[0][0]'] \n",
+ " \n",
+ " dense (Dense) (None, 256) 524544 ['flatten[0][0]'] \n",
+ " \n",
+ " dropout (Dropout) (None, 256) 0 ['dense[0][0]'] \n",
+ " \n",
+ " dense_1 (Dense) (None, 128) 32896 ['dropout[0][0]'] \n",
+ " \n",
+ " dropout_1 (Dropout) (None, 128) 0 ['dense_1[0][0]'] \n",
+ " \n",
+ " dense_2 (Dense) (None, 2) 258 ['dropout_1[0][0]'] \n",
+ " \n",
+ "==================================================================================================\n",
+ "Total params: 14,632,706\n",
+ "Trainable params: 14,465,410\n",
+ "Non-trainable params: 167,296\n",
+ "__________________________________________________________________________________________________\n"
+ ]
+ }
+ ],
+ "source": [
+ "left_eye = keras.Input(shape=(36, 60, 3))\n",
+ "right_eye = keras.Input(shape=(36, 60, 3))\n",
+ "featext_left = DenseNet121(weights=\"imagenet\", include_top=False, input_shape=(36, 60, 3))\n",
+ "featext_left._name = \"featext_left\"\n",
+ "for layer in featext_left.layers:\n",
+ " layer.kernel_regularizer=regularizers.l1(1e-3),\n",
+ "featext_right = DenseNet121(weights=\"imagenet\", include_top=False, input_shape=(36, 60, 3))\n",
+ "featext_right._name = \"featext_right\"\n",
+ "for layer in featext_right.layers:\n",
+ " layer.kernel_regularizer=regularizers.l1(1e-3),\n",
+ "left_feat_extractor = featext_left(left_eye)\n",
+ "right_feat_extractor = featext_right(right_eye)\n",
+ "concat = layers.Concatenate()([left_feat_extractor, right_feat_extractor])\n",
+ "flat = layers.Flatten()(concat)\n",
+ "dense_1 = layers.Dense(256, activation=\"relu\",\n",
+ " kernel_regularizer=regularizers.l2(1e-5),\n",
+ " kernel_initializer=initializers.GlorotNormal)(flat)\n",
+ "do_1 = layers.Dropout(0.2)(dense_1)\n",
+ "dense_2 = layers.Dense(128, activation=\"relu\",\n",
+ " kernel_regularizer=regularizers.l2(1e-5),\n",
+ " kernel_initializer=initializers.GlorotNormal)(do_1)\n",
+ "do_2 = layers.Dropout(0.2)(dense_2)\n",
+ "out = layers.Dense(2, activation=\"softmax\")(do_2)\n",
+ "\n",
+ "model = keras.Model(inputs=([left_eye, right_eye]), outputs=out, name=\"densenet_all_data_rebalanced_aug_dropout\")\n",
+ "model.summary()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "5246c770-00a1-45de-a158-e019f4743882",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from keras import backend as K\n",
+ "\n",
+ "def recall_m(y_true, y_pred):\n",
+ " true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
+ " possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n",
+ " recall = true_positives / (possible_positives + K.epsilon())\n",
+ " return recall\n",
+ "\n",
+ "def precision_m(y_true, y_pred):\n",
+ " true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n",
+ " predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n",
+ " precision = true_positives / (predicted_positives + K.epsilon())\n",
+ " return precision\n",
+ "\n",
+ "def F1_score(y_true, y_pred):\n",
+ " precision = precision_m(y_true, y_pred)\n",
+ " recall = recall_m(y_true, y_pred)\n",
+ " return 2*((precision*recall)/(precision+recall+K.epsilon()))\n",
+ " \n",
+ "model.compile(optimizer=keras.optimizers.Adam(learning_rate=1e-3), \n",
+ " loss=keras.losses.CategoricalCrossentropy(), \n",
+ " metrics=[keras.metrics.Accuracy(), keras.metrics.Precision(), keras.metrics.Recall(), F1_score])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "2ccf3233-fa62-48fe-b367-6135623d9f86",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "WARNING:tensorflow:Model failed to serialize as JSON. Ignoring... Cannot serialize (,) since it doesn't implement `get_config()`, and also doesn\t have `__name__`\n",
+ "Epoch 1/40\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2022-02-06 16:56:49.902876: I tensorflow/stream_executor/cuda/cuda_dnn.cc:368] Loaded cuDNN version 8204\n",
+ "2022-02-06 16:56:51.517747: I tensorflow/core/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n",
+ "2022-02-06 16:56:55.352128: I tensorflow/stream_executor/cuda/cuda_blas.cc:1786] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "134/134 [==============================] - 100s 575ms/step - loss: 0.1430 - accuracy: 0.0050 - precision: 0.9458 - recall: 0.9458 - F1_score: 0.9460 - val_loss: 3.1240 - val_accuracy: 0.0205 - val_precision: 0.6792 - val_recall: 0.6792 - val_F1_score: 0.6792 - lr: 0.0010\n",
+ "Epoch 2/40\n",
+ "134/134 [==============================] - 79s 594ms/step - loss: 0.0686 - accuracy: 0.0167 - precision: 0.9779 - recall: 0.9779 - F1_score: 0.9776 - val_loss: 0.5844 - val_accuracy: 0.1583 - val_precision: 0.8812 - val_recall: 0.8812 - val_F1_score: 0.8812 - lr: 0.0010\n",
+ "Epoch 3/40\n",
+ "134/134 [==============================] - 76s 570ms/step - loss: 0.0519 - accuracy: 0.0310 - precision: 0.9837 - recall: 0.9837 - F1_score: 0.9839 - val_loss: 0.0364 - val_accuracy: 0.0968 - val_precision: 0.9879 - val_recall: 0.9879 - val_F1_score: 0.9879 - lr: 0.0010\n",
+ "Epoch 4/40\n",
+ "134/134 [==============================] - 74s 556ms/step - loss: 0.0466 - accuracy: 0.0349 - precision: 0.9840 - recall: 0.9840 - F1_score: 0.9843 - val_loss: 0.0610 - val_accuracy: 0.1652 - val_precision: 0.9833 - val_recall: 0.9833 - val_F1_score: 0.9833 - lr: 0.0010\n",
+ "Epoch 5/40\n",
+ "134/134 [==============================] - 83s 626ms/step - loss: 0.0548 - accuracy: 0.0356 - precision: 0.9829 - recall: 0.9829 - F1_score: 0.9830 - val_loss: 199.9079 - val_accuracy: 0.0387 - val_precision: 0.0427 - val_recall: 0.0427 - val_F1_score: 0.0427 - lr: 0.0010\n",
+ "Epoch 6/40\n",
+ "134/134 [==============================] - 76s 570ms/step - loss: 0.0937 - accuracy: 0.0080 - precision: 0.9684 - recall: 0.9684 - F1_score: 0.9673 - val_loss: 0.0965 - val_accuracy: 0.0573 - val_precision: 0.9887 - val_recall: 0.9887 - val_F1_score: 0.9887 - lr: 0.0010\n",
+ "Epoch 7/40\n",
+ "134/134 [==============================] - 81s 606ms/step - loss: 0.0482 - accuracy: 0.0268 - precision: 0.9838 - recall: 0.9838 - F1_score: 0.9840 - val_loss: 0.0941 - val_accuracy: 0.0665 - val_precision: 0.9767 - val_recall: 0.9767 - val_F1_score: 0.9767 - lr: 0.0010\n",
+ "Epoch 8/40\n",
+ "134/134 [==============================] - 77s 577ms/step - loss: 0.0556 - accuracy: 0.0315 - precision: 0.9821 - recall: 0.9821 - F1_score: 0.9801 - val_loss: 5.4431 - val_accuracy: 0.0000e+00 - val_precision: 0.2193 - val_recall: 0.2193 - val_F1_score: 0.2193 - lr: 0.0010\n",
+ "Epoch 9/40\n",
+ "134/134 [==============================] - 77s 575ms/step - loss: 0.0441 - accuracy: 0.0081 - precision: 0.9859 - recall: 0.9859 - F1_score: 0.9860 - val_loss: 0.0297 - val_accuracy: 0.0000e+00 - val_precision: 0.9917 - val_recall: 0.9917 - val_F1_score: 0.9917 - lr: 2.0000e-04\n",
+ "Epoch 10/40\n",
+ "134/134 [==============================] - 74s 558ms/step - loss: 0.0307 - accuracy: 0.0197 - precision: 0.9907 - recall: 0.9907 - F1_score: 0.9907 - val_loss: 0.0308 - val_accuracy: 3.2066e-04 - val_precision: 0.9920 - val_recall: 0.9920 - val_F1_score: 0.9920 - lr: 2.0000e-04\n",
+ "Epoch 11/40\n",
+ "134/134 [==============================] - 67s 502ms/step - loss: 0.0276 - accuracy: 0.0321 - precision: 0.9917 - recall: 0.9917 - F1_score: 0.9917 - val_loss: 0.0436 - val_accuracy: 0.0022 - val_precision: 0.9896 - val_recall: 0.9896 - val_F1_score: 0.9896 - lr: 2.0000e-04\n",
+ "Epoch 12/40\n",
+ "134/134 [==============================] - 77s 581ms/step - loss: 0.0229 - accuracy: 0.0488 - precision: 0.9928 - recall: 0.9928 - F1_score: 0.9927 - val_loss: 0.0382 - val_accuracy: 0.0394 - val_precision: 0.9925 - val_recall: 0.9925 - val_F1_score: 0.9925 - lr: 2.0000e-04\n",
+ "Epoch 13/40\n",
+ "134/134 [==============================] - 75s 566ms/step - loss: 0.0223 - accuracy: 0.0612 - precision: 0.9931 - recall: 0.9931 - F1_score: 0.9932 - val_loss: 0.0574 - val_accuracy: 0.0099 - val_precision: 0.9866 - val_recall: 0.9866 - val_F1_score: 0.9866 - lr: 2.0000e-04\n",
+ "Epoch 14/40\n",
+ "134/134 [==============================] - 74s 557ms/step - loss: 0.0214 - accuracy: 0.0760 - precision: 0.9937 - recall: 0.9937 - F1_score: 0.9937 - val_loss: 0.0436 - val_accuracy: 0.0194 - val_precision: 0.9907 - val_recall: 0.9907 - val_F1_score: 0.9907 - lr: 2.0000e-04\n",
+ "Epoch 15/40\n",
+ "134/134 [==============================] - 76s 572ms/step - loss: 0.0157 - accuracy: 0.0646 - precision: 0.9957 - recall: 0.9957 - F1_score: 0.9958 - val_loss: 0.0462 - val_accuracy: 0.0025 - val_precision: 0.9908 - val_recall: 0.9908 - val_F1_score: 0.9908 - lr: 4.0000e-05\n",
+ "Epoch 16/40\n",
+ "134/134 [==============================] - 68s 512ms/step - loss: 0.0136 - accuracy: 0.0779 - precision: 0.9964 - recall: 0.9964 - F1_score: 0.9964 - val_loss: 0.0436 - val_accuracy: 0.0045 - val_precision: 0.9915 - val_recall: 0.9915 - val_F1_score: 0.9915 - lr: 4.0000e-05\n",
+ "Epoch 17/40\n",
+ "134/134 [==============================] - 77s 576ms/step - loss: 0.0128 - accuracy: 0.0890 - precision: 0.9967 - recall: 0.9967 - F1_score: 0.9968 - val_loss: 0.0461 - val_accuracy: 0.0099 - val_precision: 0.9916 - val_recall: 0.9916 - val_F1_score: 0.9916 - lr: 4.0000e-05\n",
+ "Epoch 18/40\n",
+ "134/134 [==============================] - 74s 554ms/step - loss: 0.0115 - accuracy: 0.0974 - precision: 0.9971 - recall: 0.9971 - F1_score: 0.9971 - val_loss: 0.0454 - val_accuracy: 0.0170 - val_precision: 0.9919 - val_recall: 0.9919 - val_F1_score: 0.9919 - lr: 4.0000e-05\n",
+ "Epoch 19/40\n",
+ "134/134 [==============================] - 77s 576ms/step - loss: 0.0127 - accuracy: 0.1021 - precision: 0.9971 - recall: 0.9971 - F1_score: 0.9971 - val_loss: 0.0462 - val_accuracy: 0.0327 - val_precision: 0.9922 - val_recall: 0.9922 - val_F1_score: 0.9922 - lr: 4.0000e-05\n",
+ "Epoch 20/40\n",
+ "134/134 [==============================] - 74s 554ms/step - loss: 0.0095 - accuracy: 0.1068 - precision: 0.9980 - recall: 0.9980 - F1_score: 0.9981 - val_loss: 0.0473 - val_accuracy: 0.0347 - val_precision: 0.9920 - val_recall: 0.9920 - val_F1_score: 0.9920 - lr: 8.0000e-06\n",
+ "Epoch 21/40\n",
+ "134/134 [==============================] - 76s 569ms/step - loss: 0.0105 - accuracy: 0.1083 - precision: 0.9977 - recall: 0.9977 - F1_score: 0.9977 - val_loss: 0.0491 - val_accuracy: 0.0369 - val_precision: 0.9919 - val_recall: 0.9919 - val_F1_score: 0.9919 - lr: 8.0000e-06\n",
+ "Epoch 22/40\n",
+ "134/134 [==============================] - 74s 557ms/step - loss: 0.0104 - accuracy: 0.1124 - precision: 0.9978 - recall: 0.9978 - F1_score: 0.9978 - val_loss: 0.0478 - val_accuracy: 0.0450 - val_precision: 0.9923 - val_recall: 0.9923 - val_F1_score: 0.9923 - lr: 8.0000e-06\n",
+ "Epoch 23/40\n",
+ "134/134 [==============================] - 70s 521ms/step - loss: 0.0087 - accuracy: 0.1139 - precision: 0.9983 - recall: 0.9983 - F1_score: 0.9984 - val_loss: 0.0477 - val_accuracy: 0.0496 - val_precision: 0.9924 - val_recall: 0.9924 - val_F1_score: 0.9924 - lr: 8.0000e-06\n",
+ "Epoch 24/40\n",
+ "134/134 [==============================] - 74s 558ms/step - loss: 0.0112 - accuracy: 0.1173 - precision: 0.9974 - recall: 0.9974 - F1_score: 0.9975 - val_loss: 0.0488 - val_accuracy: 0.0558 - val_precision: 0.9921 - val_recall: 0.9921 - val_F1_score: 0.9921 - lr: 8.0000e-06\n",
+ "Epoch 25/40\n",
+ "134/134 [==============================] - 72s 533ms/step - loss: 0.0091 - accuracy: 0.1177 - precision: 0.9982 - recall: 0.9982 - F1_score: 0.9982 - val_loss: 0.0482 - val_accuracy: 0.0579 - val_precision: 0.9924 - val_recall: 0.9924 - val_F1_score: 0.9924 - lr: 1.6000e-06\n",
+ "Epoch 26/40\n",
+ "134/134 [==============================] - 68s 507ms/step - loss: 0.0093 - accuracy: 0.1177 - precision: 0.9981 - recall: 0.9981 - F1_score: 0.9982 - val_loss: 0.0482 - val_accuracy: 0.0596 - val_precision: 0.9926 - val_recall: 0.9926 - val_F1_score: 0.9926 - lr: 1.6000e-06\n",
+ "Epoch 27/40\n",
+ "125/134 [==========================>...] - ETA: 3s - loss: 0.0107 - accuracy: 0.1184 - precision: 0.9974 - recall: 0.9974 - F1_score: 0.9975"
+ ]
+ },
+ {
+ "ename": "KeyboardInterrupt",
+ "evalue": "",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)",
+ "Input \u001b[0;32mIn [21]\u001b[0m, in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 11\u001b[0m tensorboard_callback \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39mcallbacks\u001b[38;5;241m.\u001b[39mTensorBoard(log_dir\u001b[38;5;241m=\u001b[39m\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m./logs/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mrun_id\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, update_freq\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m100\u001b[39m,)\n\u001b[1;32m 13\u001b[0m reduce_lr_callback \u001b[38;5;241m=\u001b[39m tf\u001b[38;5;241m.\u001b[39mkeras\u001b[38;5;241m.\u001b[39mcallbacks\u001b[38;5;241m.\u001b[39mReduceLROnPlateau(monitor\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mval_loss\u001b[39m\u001b[38;5;124m'\u001b[39m, factor\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.2\u001b[39m,\n\u001b[1;32m 14\u001b[0m patience\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m)\n\u001b[0;32m---> 16\u001b[0m history \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 17\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mval_dataset\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 18\u001b[0m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m40\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 19\u001b[0m \u001b[43m \u001b[49m\u001b[43msteps_per_epoch\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mtrain_data\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mbatch_size\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[1;32m 20\u001b[0m \u001b[43m \u001b[49m\u001b[43mvalidation_steps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mval_data\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43mbatch_size\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 21\u001b[0m \u001b[43m \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mmodel_checkpoint_callback\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtensorboard_callback\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mreduce_lr_callback\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/keras/utils/traceback_utils.py:64\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 64\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 65\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e: \u001b[38;5;66;03m# pylint: disable=broad-except\u001b[39;00m\n\u001b[1;32m 66\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/keras/engine/training.py:1384\u001b[0m, in \u001b[0;36mModel.fit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1377\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m tf\u001b[38;5;241m.\u001b[39mprofiler\u001b[38;5;241m.\u001b[39mexperimental\u001b[38;5;241m.\u001b[39mTrace(\n\u001b[1;32m 1378\u001b[0m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mtrain\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m 1379\u001b[0m epoch_num\u001b[38;5;241m=\u001b[39mepoch,\n\u001b[1;32m 1380\u001b[0m step_num\u001b[38;5;241m=\u001b[39mstep,\n\u001b[1;32m 1381\u001b[0m batch_size\u001b[38;5;241m=\u001b[39mbatch_size,\n\u001b[1;32m 1382\u001b[0m _r\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m 1383\u001b[0m callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m-> 1384\u001b[0m tmp_logs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtrain_function\u001b[49m\u001b[43m(\u001b[49m\u001b[43miterator\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1385\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m data_handler\u001b[38;5;241m.\u001b[39mshould_sync:\n\u001b[1;32m 1386\u001b[0m context\u001b[38;5;241m.\u001b[39masync_wait()\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback..error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 149\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 150\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 151\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 152\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m _process_traceback_frames(e\u001b[38;5;241m.\u001b[39m__traceback__)\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/tensorflow/python/eager/def_function.py:915\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 912\u001b[0m compiler \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mxla\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnonXla\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 914\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m OptionalXlaContext(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_jit_compile):\n\u001b[0;32m--> 915\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 917\u001b[0m new_tracing_count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mexperimental_get_tracing_count()\n\u001b[1;32m 918\u001b[0m without_tracing \u001b[38;5;241m=\u001b[39m (tracing_count \u001b[38;5;241m==\u001b[39m new_tracing_count)\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/tensorflow/python/eager/def_function.py:947\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 944\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n\u001b[1;32m 945\u001b[0m \u001b[38;5;66;03m# In this case we have created variables on the first call, so we run the\u001b[39;00m\n\u001b[1;32m 946\u001b[0m \u001b[38;5;66;03m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[0;32m--> 947\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_stateless_fn\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# pylint: disable=not-callable\u001b[39;00m\n\u001b[1;32m 948\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_stateful_fn \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 949\u001b[0m \u001b[38;5;66;03m# Release the lock early so that multiple threads can perform the call\u001b[39;00m\n\u001b[1;32m 950\u001b[0m \u001b[38;5;66;03m# in parallel.\u001b[39;00m\n\u001b[1;32m 951\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock\u001b[38;5;241m.\u001b[39mrelease()\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/tensorflow/python/eager/function.py:2956\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2953\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n\u001b[1;32m 2954\u001b[0m (graph_function,\n\u001b[1;32m 2955\u001b[0m filtered_flat_args) \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_maybe_define_function(args, kwargs)\n\u001b[0;32m-> 2956\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mgraph_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2957\u001b[0m \u001b[43m \u001b[49m\u001b[43mfiltered_flat_args\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgraph_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\u001b[43m)\u001b[49m\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/tensorflow/python/eager/function.py:1853\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m 1849\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m 1850\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (possible_gradient_type \u001b[38;5;241m==\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPOSSIBLE_GRADIENT_TYPES_NONE\n\u001b[1;32m 1851\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m 1852\u001b[0m \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1853\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_build_call_outputs(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1854\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcancellation_manager\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcancellation_manager\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m 1855\u001b[0m forward_backward \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_select_forward_and_backward_functions(\n\u001b[1;32m 1856\u001b[0m args,\n\u001b[1;32m 1857\u001b[0m possible_gradient_type,\n\u001b[1;32m 1858\u001b[0m executing_eagerly)\n\u001b[1;32m 1859\u001b[0m forward_function, args_with_tangents \u001b[38;5;241m=\u001b[39m forward_backward\u001b[38;5;241m.\u001b[39mforward()\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/tensorflow/python/eager/function.py:499\u001b[0m, in \u001b[0;36m_EagerDefinedFunction.call\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m 497\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m _InterpolateFunctionError(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m 498\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_manager \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m--> 499\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mexecute\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 500\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msignature\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 501\u001b[0m \u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_num_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 502\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 503\u001b[0m \u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 504\u001b[0m \u001b[43m \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mctx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 505\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 506\u001b[0m outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m 507\u001b[0m \u001b[38;5;28mstr\u001b[39m(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msignature\u001b[38;5;241m.\u001b[39mname),\n\u001b[1;32m 508\u001b[0m num_outputs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_num_outputs,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 511\u001b[0m ctx\u001b[38;5;241m=\u001b[39mctx,\n\u001b[1;32m 512\u001b[0m cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_manager)\n",
+ "File \u001b[0;32m~/.local/lib/python3.9/site-packages/tensorflow/python/eager/execute.py:54\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 53\u001b[0m ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 54\u001b[0m tensors \u001b[38;5;241m=\u001b[39m \u001b[43mpywrap_tfe\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mTFE_Py_Execute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_handle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdevice_name\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mop_name\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 55\u001b[0m \u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mattrs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 56\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m core\u001b[38;5;241m.\u001b[39m_NotOkStatusException \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 57\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+ "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+ ]
+ }
+ ],
+ "source": [
+ "from datetime import datetime\n",
+ "\n",
+ "run_id = f'{model.name}-{datetime.now().strftime(\"%m-%H%M%S\")}'\n",
+ "model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(\n",
+ " filepath=f\"models/{run_id}/\" + \"{epoch:02d}-{val_F1_score:.2f}\",\n",
+ " save_weights_only=True,\n",
+ " monitor='val_F1_score',\n",
+ " mode='max',\n",
+ " save_best_only=False)\n",
+ "\n",
+ "tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=f\"./logs/{run_id}\", update_freq=100,)\n",
+ "\n",
+ "reduce_lr_callback = tf.keras.callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2,\n",
+ " patience=5)\n",
+ "\n",
+ "history = model.fit(train_dataset, \n",
+ " validation_data=val_dataset, \n",
+ " epochs=40, \n",
+ " steps_per_epoch=int(train_data.shape[0]/(2*batch_size)), \n",
+ " validation_steps=int(val_data.shape[0]/batch_size),\n",
+ " callbacks=[model_checkpoint_callback, tensorboard_callback, reduce_lr_callback])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "f8a2f845-b418-48e1-bfcc-2f96dccf675f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 21,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model.load_weights(\"models/densenet_all_data_rebalanced_aug_dropout-02-165635/26-0.99\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "f7a994f3-5e62-49fe-b010-cd942a7bbaa7",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "2022-02-13 20:10:50.384532: I tensorflow/stream_executor/cuda/cuda_dnn.cc:368] Loaded cuDNN version 8204\n",
+ "2022-02-13 20:10:51.969706: I tensorflow/core/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n",
+ "2022-02-13 20:10:55.708456: I tensorflow/stream_executor/cuda/cuda_blas.cc:1786] TensorFloat-32 will be used for the matrix multiplication. This will only be logged once.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "84/84 [==============================] - 30s 228ms/step - loss: 0.0451 - accuracy: 0.0566 - precision: 0.9925 - recall: 0.9925 - F1_score: 0.9926\n"
+ ]
+ }
+ ],
+ "source": [
+ "results = model.evaluate(test_dataset)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f2e0a960-fdd7-459c-84cd-d6165ad917e0",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "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.9.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/notebooks/v3.ipynb b/notebooks/v3.ipynb
deleted file mode 100644
index e130b1a..0000000
--- a/notebooks/v3.ipynb
+++ /dev/null
@@ -1,1299 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "code",
- "execution_count": 1,
- "id": "35472663-a1e6-4228-a178-5006b2effe76",
- "metadata": {},
- "outputs": [],
- "source": [
- "import os\n",
- "os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\""
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 2,
- "id": "d43896a6-ec52-44e5-a44e-cd7fabd18f18",
- "metadata": {},
- "outputs": [],
- "source": [
- "DATA_RAW_PATH = \"../data/RAW/RT-BENE.zip\" \n",
- "DATA_INTER_PATH = \"/opt/data/Ubuntu/projects/RT-BENE/data/intermediate\"\n",
- "DATA_PATH = f\"{DATA_INTER_PATH}/RT-BENE\"\n",
- "if not os.path.exists(DATA_PATH):\n",
- " !unzip -q $DATA_RAW_PATH -d $DATA_INTER_PATH"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 3,
- "id": "da68634c-20ed-4ada-967b-a10f34029522",
- "metadata": {},
- "outputs": [],
- "source": [
- "import pandas as pd\n",
- "import matplotlib.pyplot as plt\n",
- "import numpy as np\n",
- "import tensorflow as tf"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 4,
- "id": "3cb3c96d-687c-483c-a0d3-1144962d32b9",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " blink_id | \n",
- " left_eye | \n",
- " right_eye | \n",
- " video | \n",
- " blink | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " 0 | \n",
- " 0 | \n",
- " 0_left_000001_rgb.png | \n",
- " 0_right_000001_rgb.png | \n",
- " 0 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 1 | \n",
- " 1 | \n",
- " 0_left_000002_rgb.png | \n",
- " 0_right_000002_rgb.png | \n",
- " 0 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 2 | \n",
- " 2 | \n",
- " 0_left_000003_rgb.png | \n",
- " 0_right_000003_rgb.png | \n",
- " 0 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 3 | \n",
- " 3 | \n",
- " 0_left_000004_rgb.png | \n",
- " 0_right_000004_rgb.png | \n",
- " 0 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 4 | \n",
- " 4 | \n",
- " 0_left_000005_rgb.png | \n",
- " 0_right_000005_rgb.png | \n",
- " 0 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- " ... | \n",
- "
\n",
- " \n",
- " 107345 | \n",
- " 107345 | \n",
- " 16_left_009059_rgb.png | \n",
- " 16_right_009059_rgb.png | \n",
- " 16 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 107346 | \n",
- " 107346 | \n",
- " 16_left_009060_rgb.png | \n",
- " 16_right_009060_rgb.png | \n",
- " 16 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 107347 | \n",
- " 107347 | \n",
- " 16_left_009061_rgb.png | \n",
- " 16_right_009061_rgb.png | \n",
- " 16 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 107348 | \n",
- " 107348 | \n",
- " 16_left_009062_rgb.png | \n",
- " 16_right_009062_rgb.png | \n",
- " 16 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- " 107349 | \n",
- " 107349 | \n",
- " 16_left_009063_rgb.png | \n",
- " 16_right_009063_rgb.png | \n",
- " 16 | \n",
- " 0 | \n",
- "
\n",
- " \n",
- "
\n",
- "
107350 rows × 5 columns
\n",
- "
"
- ],
- "text/plain": [
- " blink_id left_eye right_eye video \\\n",
- "0 0 0_left_000001_rgb.png 0_right_000001_rgb.png 0 \n",
- "1 1 0_left_000002_rgb.png 0_right_000002_rgb.png 0 \n",
- "2 2 0_left_000003_rgb.png 0_right_000003_rgb.png 0 \n",
- "3 3 0_left_000004_rgb.png 0_right_000004_rgb.png 0 \n",
- "4 4 0_left_000005_rgb.png 0_right_000005_rgb.png 0 \n",
- "... ... ... ... ... \n",
- "107345 107345 16_left_009059_rgb.png 16_right_009059_rgb.png 16 \n",
- "107346 107346 16_left_009060_rgb.png 16_right_009060_rgb.png 16 \n",
- "107347 107347 16_left_009061_rgb.png 16_right_009061_rgb.png 16 \n",
- "107348 107348 16_left_009062_rgb.png 16_right_009062_rgb.png 16 \n",
- "107349 107349 16_left_009063_rgb.png 16_right_009063_rgb.png 16 \n",
- "\n",
- " blink \n",
- "0 0 \n",
- "1 0 \n",
- "2 0 \n",
- "3 0 \n",
- "4 0 \n",
- "... ... \n",
- "107345 0 \n",
- "107346 0 \n",
- "107347 0 \n",
- "107348 0 \n",
- "107349 0 \n",
- "\n",
- "[107350 rows x 5 columns]"
- ]
- },
- "execution_count": 4,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "data = pd.read_csv(f\"{DATA_PATH}/blinks.csv\")\n",
- "data"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "d358eef2-c764-4557-86b2-104413d7c6ff",
- "metadata": {},
- "source": [
- "### How many videos do we have?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 5,
- "id": "0df339bd-3747-4f21-b2a2-3821ff303e32",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "array([ 0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])"
- ]
- },
- "execution_count": 5,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "video_ids = np.unique(data[\"video\"])\n",
- "video_ids"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "859f2a1e-1858-4671-a36e-8895f9c4008c",
- "metadata": {},
- "source": [
- "### Total images"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 6,
- "id": "2fc1945a-e8b2-49d4-81fe-06c44aa8364f",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "107350"
- ]
- },
- "execution_count": 6,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "data[\"blink_id\"].count()"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "8248cca0-6ca5-4e58-97c0-5c80fab138ba",
- "metadata": {},
- "source": [
- "### How many images per video?"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 7,
- "id": "b86a9305-0d25-4830-8dee-50d87b091bfc",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " | \n",
- " Images in video | \n",
- " % blink frames | \n",
- "
\n",
- " \n",
- " video | \n",
- " | \n",
- " | \n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " 0 | \n",
- " 12865 | \n",
- " 7.236689 | \n",
- "
\n",
- " \n",
- " 1 | \n",
- " 8671 | \n",
- " 1.476185 | \n",
- "
\n",
- " \n",
- " 2 | \n",
- " 8702 | \n",
- " 9.066881 | \n",
- "
\n",
- " \n",
- " 3 | \n",
- " 3205 | \n",
- " 5.210608 | \n",
- "
\n",
- " \n",
- " 4 | \n",
- " 4750 | \n",
- " 2.736842 | \n",
- "
\n",
- " \n",
- " 5 | \n",
- " 5355 | \n",
- " 2.054155 | \n",
- "
\n",
- " \n",
- " 7 | \n",
- " 1857 | \n",
- " 8.023694 | \n",
- "
\n",
- " \n",
- " 8 | \n",
- " 6108 | \n",
- " 7.514735 | \n",
- "
\n",
- " \n",
- " 9 | \n",
- " 4210 | \n",
- " 1.068884 | \n",
- "
\n",
- " \n",
- " 10 | \n",
- " 16559 | \n",
- " 2.131771 | \n",
- "
\n",
- " \n",
- " 11 | \n",
- " 12817 | \n",
- " 5.399079 | \n",
- "
\n",
- " \n",
- " 12 | \n",
- " 935 | \n",
- " 2.459893 | \n",
- "
\n",
- " \n",
- " 13 | \n",
- " 9586 | \n",
- " 3.077405 | \n",
- "
\n",
- " \n",
- " 14 | \n",
- " 5371 | \n",
- " 4.002979 | \n",
- "
\n",
- " \n",
- " 15 | \n",
- " 1810 | \n",
- " 1.602210 | \n",
- "
\n",
- " \n",
- " 16 | \n",
- " 4549 | \n",
- " 0.923280 | \n",
- "
\n",
- " \n",
- "
\n",
- "
"
- ],
- "text/plain": [
- " Images in video % blink frames\n",
- "video \n",
- "0 12865 7.236689\n",
- "1 8671 1.476185\n",
- "2 8702 9.066881\n",
- "3 3205 5.210608\n",
- "4 4750 2.736842\n",
- "5 5355 2.054155\n",
- "7 1857 8.023694\n",
- "8 6108 7.514735\n",
- "9 4210 1.068884\n",
- "10 16559 2.131771\n",
- "11 12817 5.399079\n",
- "12 935 2.459893\n",
- "13 9586 3.077405\n",
- "14 5371 4.002979\n",
- "15 1810 1.602210\n",
- "16 4549 0.923280"
- ]
- },
- "execution_count": 7,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "data_per_video = data.groupby(by=[\"video\"]).count()\n",
- "blinks_per_video = data.loc[data[\"blink\"] == 1].groupby(by=\"video\").count()\n",
- "blinks_per_video = blinks_per_video.div(data_per_video, level=\"video\") * 100\n",
- "data_per_video = pd.concat([data_per_video[\"blink_id\"], blinks_per_video[\"blink\"]], axis=1, keys=[\"Images in video\",\"% blink frames\"])\n",
- "data_per_video"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "592f11ec-797e-43d1-bd26-187feb077b43",
- "metadata": {},
- "source": [
- "Previous data shows that a rebalancing method will have to be used"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "ad2e0771-9a36-4378-8798-f79866c728de",
- "metadata": {},
- "source": [
- "#### Split train and test sets"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 8,
- "id": "252c72ab-cba5-44d7-bb01-2a59eca9e1b0",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "(68702, 5)\n",
- "(17176, 5)\n",
- "(21470, 5)\n"
- ]
- }
- ],
- "source": [
- "test_size = 0.2\n",
- "val_size = 0.2\n",
- "train_data = data.sample(frac=1).reset_index(drop=True)\n",
- "test_data = train_data[int(train_data.shape[0]*(1-test_size)):]\n",
- "train_data = train_data[:int(train_data.shape[0]*(1-test_size)) -1]\n",
- "\n",
- "val_data = train_data[int(train_data.shape[0]*(1-val_size)):]\n",
- "train_data = train_data[:int(train_data.shape[0]*(1-val_size)) -1]\n",
- "\n",
- "print(train_data.shape)\n",
- "print(val_data.shape)\n",
- "print(test_data.shape)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0d0bc867-e450-423b-a8fe-56df94d8aec8",
- "metadata": {},
- "source": [
- "#### Generic generator class"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 9,
- "id": "3fc1e6cf-52fc-4abb-90e1-acfbfcf52836",
- "metadata": {},
- "outputs": [],
- "source": [
- "import cv2\n",
- "class RTBeneDataset:\n",
- " def __init__(self, phase: str, data: pd.DataFrame, mean: float, std: float, transforms = None):\n",
- " self.phase = phase\n",
- " self.data = data\n",
- " self.mean = mean\n",
- " self.std = std\n",
- " self.transforms = transforms\n",
- " self.counter = 0\n",
- " \n",
- " if self.phase == \"train\":\n",
- " #Shuffle the data\n",
- " self.data = self.data.sample(frac=1).reset_index(drop=True)\n",
- " else:\n",
- " self.data = self.data.reset_index(drop=True)\n",
- " \n",
- " \n",
- " def __getitem(self, idx):\n",
- " row = self.data.loc[idx,[\"left_eye\", \"right_eye\"]].to_list(), self.data.loc[idx,[\"blink\"]].to_list()[0]\n",
- " return row\n",
- " \n",
- " def __call__(self):\n",
- " for i in range(self.data.shape[0]):\n",
- " yield self.__getitem(i)\n",
- " self.counter +=1\n",
- " \n",
- " if self.counter == (self.data.shape[0] -1):\n",
- " # When all the dataset is readed, reshuffle again\n",
- " self.data = self.data.sample(frac=1).reset_index(drop=True)\n",
- " \n",
- " @staticmethod\n",
- " @tf.function\n",
- " def tf_load_row(x, y):\n",
- " image_l = tf.io.read_file(tf.strings.join([f\"{DATA_PATH}/images/\", x[0]]))\n",
- " image_r = tf.io.read_file(tf.strings.join([f\"{DATA_PATH}/images/\", x[1]]))\n",
- " image_l = tf.image.decode_png(image_l, channels=3)\n",
- " image_r = tf.image.decode_png(image_r, channels=3)\n",
- " y = tf.cast(y, tf.float32)\n",
- " return (image_l, image_r), [tf.abs(1-y), y]\n",
- " \n",
- "def set_shapes(imgs, label, img_shape=(36,60,3)):\n",
- " imgs[0].set_shape(img_shape)\n",
- " imgs[1].set_shape(img_shape)\n",
- " label.set_shape([])\n",
- " return imgs, label"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "dcfba562-db17-48c7-bc33-5689a30f8567",
- "metadata": {},
- "source": [
- "## Resampling to get better distribution of the data"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 10,
- "id": "71ecc920-9f14-4400-8484-480a0e9065c9",
- "metadata": {},
- "outputs": [],
- "source": [
- "train_blink_RTB = RTBeneDataset(\"train\", train_data.loc[train_data[\"blink\"] == 1], 127.5, 1)\n",
- "train_no_blink_RTB = RTBeneDataset(\"train\", train_data.loc[train_data[\"blink\"] == 0], 127.5, 1)\n",
- "val_RTB = RTBeneDataset(\"val\", val_data, 127.5, 1)\n",
- "test_RTB = RTBeneDataset(\"val\", test_data, 127.5, 1)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "5d99074a-f99c-43ba-a19a-24818ef176c2",
- "metadata": {},
- "source": [
- "### Data augmentation"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 11,
- "id": "c941f6da-d0bf-4e97-918b-eae100a80312",
- "metadata": {},
- "outputs": [],
- "source": [
- "from albumentations import (\n",
- " Compose, RandomBrightness, JpegCompression, HueSaturationValue, RandomContrast, HorizontalFlip,\n",
- " Rotate\n",
- ")"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 12,
- "id": "fffb2712-c61c-43d9-b67d-d462dc4c77bd",
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "/home/esteve/.local/lib/python3.9/site-packages/albumentations/augmentations/transforms.py:1800: FutureWarning: This class has been deprecated. Please use RandomBrightnessContrast\n",
- " warnings.warn(\n",
- "/home/esteve/.local/lib/python3.9/site-packages/albumentations/augmentations/transforms.py:965: FutureWarning: This class has been deprecated. Please use ImageCompression\n",
- " warnings.warn(\n",
- "/home/esteve/.local/lib/python3.9/site-packages/albumentations/augmentations/transforms.py:1826: FutureWarning: This class has been deprecated. Please use RandomBrightnessContrast\n",
- " warnings.warn(\n"
- ]
- }
- ],
- "source": [
- "transforms = Compose([\n",
- " Rotate(limit=20),\n",
- " RandomBrightness(limit=0.2),\n",
- " JpegCompression(quality_lower=70, quality_upper=100, p=0.5),\n",
- " HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.5),\n",
- " RandomContrast(limit=0.2, p=0.5),\n",
- " HorizontalFlip(),\n",
- " ])\n",
- "\n",
- "def aug_fn(image):\n",
- " data = {\"image\":image}\n",
- " aug_data = transforms(**data)\n",
- " aug_img = aug_data[\"image\"]\n",
- " return aug_img\n",
- "\n",
- "def scale(image, label):\n",
- " return (tf.cast(image[0], tf.float32)/255.0, tf.cast(image[1], tf.float32)/255.0), label\n",
- "\n",
- "def process_data(image, label):\n",
- " aug_img_l = tf.numpy_function(func=aug_fn, inp=[image[0]], Tout=tf.uint8)\n",
- " aug_img_r = tf.numpy_function(func=aug_fn, inp=[image[1]], Tout=tf.uint8)\n",
- " return (aug_img_l, aug_img_r), label"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 13,
- "id": "ccd8d481-5151-4a09-bb21-e3ece76b6bce",
- "metadata": {},
- "outputs": [
- {
- "name": "stderr",
- "output_type": "stream",
- "text": [
- "2022-02-06 16:54:55.602178: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:55.694025: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:55.694443: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:55.696571: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations: AVX2 FMA\n",
- "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
- "2022-02-06 16:54:55.697755: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:55.698138: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:55.698464: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:56.490978: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:56.491395: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:56.491729: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:936] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero\n",
- "2022-02-06 16:54:56.492668: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1525] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 9775 MB memory: -> device: 0, name: NVIDIA GeForce RTX 3060, pci bus id: 0000:06:00.0, compute capability: 8.6\n"
- ]
- }
- ],
- "source": [
- "batch_size = 256\n",
- "\n",
- "blink_dataset = tf.data.Dataset.from_generator(train_blink_RTB, \n",
- " output_types=(tf.string, tf.float32), \n",
- " output_shapes=((2),()))\n",
- "\n",
- "no_blink_dataset = tf.data.Dataset.from_generator(train_no_blink_RTB, \n",
- " output_types=(tf.string, tf.float32), \n",
- " output_shapes=((2),()))\n",
- "\n",
- "train_dataset = tf.data.Dataset.sample_from_datasets([blink_dataset, no_blink_dataset], [0.4, 0.6], stop_on_empty_dataset=True)\\\n",
- " .map(RTBeneDataset.tf_load_row, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
- " .map(process_data, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
- " .map(scale, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
- " .batch(batch_size)\\\n",
- " .repeat()\n",
- "\n",
- "\n",
- "val_dataset = tf.data.Dataset.from_generator(val_RTB, \n",
- " output_types=(tf.string, tf.float32), \n",
- " output_shapes=((2),()))\\\n",
- " .map(RTBeneDataset.tf_load_row, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
- " .map(scale, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
- " .prefetch(tf.data.AUTOTUNE)\\\n",
- " .batch(batch_size)\n",
- "\n",
- "test_dataset = tf.data.Dataset.from_generator(test_RTB, \n",
- " output_types=(tf.string, tf.float32), \n",
- " output_shapes=((2),()))\\\n",
- " .map(RTBeneDataset.tf_load_row, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
- " .map(scale, num_parallel_calls=tf.data.AUTOTUNE)\\\n",
- " .prefetch(tf.data.AUTOTUNE)\\\n",
- " .batch(batch_size)"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "131f43fe-745e-474c-9ed8-f7ecf4582e5c",
- "metadata": {},
- "source": [
- "### Test image augmentations"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 14,
- "id": "5308ccf1-44d6-4217-a4aa-70fe860857b7",
- "metadata": {},
- "outputs": [],
- "source": [
- "it = train_dataset.as_numpy_iterator()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 15,
- "id": "30d1aaab-3b44-472e-a484-e6e68b761f4f",
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "[[1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]\n",
- " [1. 0.]\n",
- " [0. 1.]\n",
- " [1. 0.]]\n"
- ]
- },
- {
- "data": {
- "image/png": "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\n",
- "text/plain": [
- "