Transfer_Learning_Neural_Network copy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Welcome to my notebook!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default code from Kaggle Notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This Python 3 environment comes with many helpful analytics libraries installed\n",
    "# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n",
    "# For example, here's several helpful packages to load\n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "# Input data files are available in the read-only \"../input/\" directory\n",
    "# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n",
    "   \n",
    "import os\n",
    "for dirname, _, filenames in os.walk('/kaggle/input'):\n",
    "    for filename in filenames:\n",
    "        print(os.path.join(dirname, filename))\n",
    "\n",
    "# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n",
    "# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session\n",
    "\n",
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Displaying some important libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-02 15:57:11.193480: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2024-02-02 15:57:11.662619: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-02-02 15:57:11.662792: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-02-02 15:57:11.750459: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-02-02 15:57:11.969514: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-02-02 15:57:13.133682: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorflow: 2.15.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_239/2944158885.py:4: DeprecationWarning: `import kerastuner` is deprecated, please use `import keras_tuner`.\n",
      "  import kerastuner as kt\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kerastuner: 1.0.5\n",
      "keras_tuner: 1.3.5\n",
      "Python: 3.10.12\n",
      "numpy: 1.24.3\n",
      "pandas: 2.1.4\n",
      "sklearn version: 1.2.2\n",
      "sklearn path: ['/home/michaelye22/.local/lib/python3.10/site-packages/sklearn']\n",
      "matplotlib: 3.8.2\n",
      "seaborn: 0.13.0\n"
     ]
    }
   ],
   "source": [
    "# import tensorflow as tf\n",
    "# print(\"Tensorflow:\", tf.__version__)\n",
    "\n",
    "# import kerastuner as kt\n",
    "# print(\"kerastuner:\", kt.__version__)\n",
    "\n",
    "# import keras_tuner as kt2\n",
    "# print(\"keras_tuner:\", kt2.__version__)\n",
    "\n",
    "# import platform\n",
    "# print(\"Python:\", platform.python_version())\n",
    "\n",
    "# import numpy as np\n",
    "# print(\"numpy:\", np.__version__)\n",
    "\n",
    "# import pandas as pd\n",
    "# print(\"pandas:\", pd.__version__)\n",
    "\n",
    "# import sklearn\n",
    "# print(\"sklearn version:\", sklearn.__version__)\n",
    "\n",
    "# import sklearn\n",
    "# print(\"sklearn path:\", sklearn.__path__)\n",
    "\n",
    "# import matplotlib\n",
    "# print(\"matplotlib:\", matplotlib.__version__)\n",
    "\n",
    "# import seaborn as sns\n",
    "# print(\"seaborn:\", sns.__version__)\n",
    "\n",
    "# # On WSL\n",
    "\n",
    "# # 2024-01-30 11:17:52.768682: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
    "# # 2024-01-30 11:17:53.149956: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
    "# # 2024-01-30 11:17:53.150001: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
    "# # 2024-01-30 11:17:53.210606: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
    "# # 2024-01-30 11:17:53.339576: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
    "# # To enable the following instructions: AVX2 AVX512F AVX512_VNNI AVX512_BF16 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
    "# # 2024-01-30 11:17:54.568146: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
    "# # Tensorflow: 2.15.0\n",
    "# # /tmp/ipykernel_3814/2917868046.py:4: DeprecationWarning: `import kerastuner` is deprecated, please use `import keras_tuner`.\n",
    "# #   import kerastuner as kt\n",
    "# # kerastuner: 1.0.5\n",
    "# # keras_tuner: 1.3.5\n",
    "# # Python: 3.10.12\n",
    "# # numpy: 1.24.3\n",
    "# # pandas: 2.1.4\n",
    "# # sklearn version: 1.2.2\n",
    "# # sklearn path: ['/home/michaelye22/.local/lib/python3.10/site-packages/sklearn']\n",
    "# # matplotlib: 3.8.2\n",
    "# # seaborn: 0.13.0\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Global random seed to make sure we can replicate any model that we create (no randomness)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "\n",
    "\n",
    "np.random.seed(42)\n",
    "random.seed(42)\n",
    "np.random.seed(42)\n",
    "tf.random.set_seed(42)\n",
    "\n",
    "os.environ['TF_DETERMINISTIC_OPS'] = '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Data Preprocessing:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading the training and testing data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "train_values are the features (X), and train_labels is the target/label (Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_X = pd.read_csv(\"train_features.csv\")\n",
    "train_y = pd.read_csv(\"train_labels.csv\")\n",
    "\n",
    "test_values = pd.read_csv(\"test_features.csv\")\n",
    "\n",
    "# print(\"train labels:\\n\", train_Y.head())\n",
    "\n",
    "# print(\"train values:\\n\", train_X.head())\n",
    "      \n",
    "# print(\"test_values:\\n\", test_values.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check to see if there are any missing values in the data. If so, we have to do imputation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of missing values in train_X: 0\n",
      "Number of missing values in train_Y: 0\n",
      "Number of missing values in test_values: 0\n"
     ]
    }
   ],
   "source": [
    "missing_train_X = train_X.isnull().sum().sum()\n",
    "print(\"Number of missing values in train_X:\", missing_train_X)\n",
    "\n",
    "missing_train_y = train_y.isnull().sum().sum()\n",
    "print(\"Number of missing values in train_Y:\", missing_train_y)\n",
    "\n",
    "missing_test_values = test_values.isnull().sum().sum()\n",
    "print(\"Number of missing values in test_values:\", missing_test_values )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since we have 0 missing values in each dataframe, we don't have to do imputation!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stratified train_test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                        Train Distribution  Test Distribution\n",
      "site_animal                                                  \n",
      "S0001_bird                        0.000647           0.000728\n",
      "S0001_blank                       0.000404           0.000243\n",
      "S0001_leopard                     0.003073           0.003153\n",
      "S0001_monkey_prosimian            0.001051           0.000970\n",
      "S0002_bird                        0.000566           0.000485\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Load the datasets\n",
    "\n",
    "train_features = train_X\n",
    "train_labels = train_y\n",
    "\n",
    "# Merge the datasets on 'id'\n",
    "merged_data = pd.merge(train_features, train_labels, on='id')\n",
    "\n",
    "# Identifying the animal present in each image and creating a combined category\n",
    "animal_columns = ['antelope_duiker', 'bird', 'blank', 'civet_genet', 'hog', 'leopard', 'monkey_prosimian', 'rodent']\n",
    "merged_data['animal'] = merged_data[animal_columns].idxmax(axis=1)\n",
    "merged_data['site_animal'] = merged_data['site'] + '_' + merged_data['animal']\n",
    "\n",
    "# Checking the number of instances for each site_animal combination\n",
    "combination_counts = merged_data['site_animal'].value_counts()\n",
    "rare_combinations = combination_counts[combination_counts < 5]\n",
    "\n",
    "# Separating the dataset into common and rare combinations\n",
    "common_combinations = merged_data[~merged_data['site_animal'].isin(rare_combinations.index)]\n",
    "rare_combinations_data = merged_data[merged_data['site_animal'].isin(rare_combinations.index)]\n",
    "\n",
    "# Stratified split for common combinations\n",
    "common_train_set, common_test_set = train_test_split(\n",
    "    common_combinations, test_size=0.25, stratify=common_combinations['site_animal'], random_state=42)\n",
    "\n",
    "# Randomly splitting rare combinations\n",
    "total_samples = rare_combinations_data.shape[0]\n",
    "train_samples = int(np.round(total_samples * 0.75))\n",
    "rare_train_set = rare_combinations_data.sample(n=train_samples, random_state=42)\n",
    "rare_test_set = rare_combinations_data.drop(rare_train_set.index)\n",
    "\n",
    "# Combining the splits into final train and test sets\n",
    "final_train_set = pd.concat([common_train_set, rare_train_set])\n",
    "final_test_set = pd.concat([common_test_set, rare_test_set])\n",
    "\n",
    "# Optional: Verifying the final distribution (can be commented out for large datasets)\n",
    "final_train_distribution = final_train_set['site_animal'].value_counts(normalize=True)\n",
    "final_test_distribution = final_test_set['site_animal'].value_counts(normalize=True)\n",
    "final_distribution_summary = pd.DataFrame({\n",
    "    'Train Distribution': final_train_distribution,\n",
    "    'Test Distribution': final_test_distribution\n",
    "})\n",
    "print(final_distribution_summary.head())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Verify the 75/25 train_test split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Set Proportion: 74.99%\n",
      "Test Set Proportion: 25.01%\n"
     ]
    }
   ],
   "source": [
    "# Calculate the number of samples in each set\n",
    "num_train_samples = final_train_set.shape[0]\n",
    "num_test_samples = final_test_set.shape[0]\n",
    "total_samples = num_train_samples + num_test_samples\n",
    "\n",
    "# Calculate the proportions\n",
    "train_proportion = num_train_samples / total_samples\n",
    "test_proportion = num_test_samples / total_samples\n",
    "\n",
    "# Print out the proportions\n",
    "print(\"Training Set Proportion: {:.2%}\".format(train_proportion))\n",
    "print(\"Test Set Proportion: {:.2%}\".format(test_proportion))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making sure that train and test set have a 75/25 split for each site"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, for each site, around 75% should be in the training data and around 25% should be in the test data. This ensures niether the train or test set have a unbalanced amount of a certain site, leading to bias and bad predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the count of each site in both sets\n",
    "site_counts_train = final_train_set['site'].value_counts()\n",
    "site_counts_test = final_test_set['site'].value_counts()\n",
    "\n",
    "# Combine the counts into a single DataFrame for comparison\n",
    "combined_site_counts = pd.DataFrame({'Train Count': site_counts_train, 'Test Count': site_counts_test})\n",
    "\n",
    "# Calculate the total counts for each site\n",
    "combined_site_counts['Total Count'] = combined_site_counts['Train Count'] + combined_site_counts['Test Count']\n",
    "\n",
    "# Calculate the percentage split for each site\n",
    "combined_site_counts['Train Percentage'] = (combined_site_counts['Train Count'] / combined_site_counts['Total Count']) * 100\n",
    "combined_site_counts['Test Percentage'] = (combined_site_counts['Test Count'] / combined_site_counts['Total Count']) * 100\n",
    "\n",
    "# Display the combined counts with percentage split\n",
    "#print(combined_site_counts.head())\n",
    "combined_site_counts.to_csv(\"site_percentage_check.csv\")\n",
    "\n",
    "# Check to see if there any rows of data with a train percentage below 70 or above 80 (the ideal is 75)\n",
    "filtered_df = combined_site_counts[(combined_site_counts['Train Percentage'] < 70) | (combined_site_counts['Train Percentage'] > 80)]\n",
    "#print(filtered_df)\n",
    "#print(len(filtered_df)) # There are only 13 sites which have a bad train/test split, but they all side more towards the train set, which is good\n",
    "\n",
    "\n",
    "#print(len(final_train_set))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are only 13 sites which have a bad train/test split, but they all side more towards the train set, which is good"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making sure the trian and test set have the 75/25 split for each animal "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, for each animal, around 75% should be in the training data and around 25% should be in the test data. This ensures neither the train or test set have a unbalanced amount of a certain animal, leading to bias and bad predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# List of label columns\n",
    "label_columns = ['antelope_duiker', 'bird', 'blank', 'civet_genet', 'hog', 'leopard', 'monkey_prosimian', 'rodent']\n",
    "\n",
    "# Calculate the count of each label in both sets\n",
    "label_counts_train = final_train_set[label_columns].sum()\n",
    "label_counts_test = final_test_set[label_columns].sum()\n",
    "\n",
    "# Combine the counts into a single DataFrame for comparison\n",
    "combined_label_counts = pd.DataFrame({'Train Count': label_counts_train, 'Test Count': label_counts_test})\n",
    "\n",
    "# Calculate the total counts for each label\n",
    "combined_label_counts['Total Count'] = combined_label_counts['Train Count'] + combined_label_counts['Test Count']\n",
    "\n",
    "# Calculate the percentage split for each label\n",
    "combined_label_counts['Train Percentage'] = (combined_label_counts['Train Count'] / combined_label_counts['Total Count']) * 100\n",
    "combined_label_counts['Test Percentage'] = (combined_label_counts['Test Count'] / combined_label_counts['Total Count']) * 100\n",
    "\n",
    "# Display the combined counts with percentage split\n",
    "#print(combined_label_counts)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since each class has around a 75/25 split for train and test split, my data looks good!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modifying the data to include only the original columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(final_train_set)\n",
    "\n",
    "# Remove all the new features that I created for the stratified train_test split\n",
    "train_X = final_train_set[['id', 'filepath', 'site']]\n",
    "train_Y = final_train_set[['id','antelope_duiker','bird','blank','civet_genet','hog','leopard','monkey_prosimian','rodent']]\n",
    "\n",
    "test_X = final_test_set[['id', 'filepath', 'site']]\n",
    "test_Y = final_test_set[['id','antelope_duiker','bird','blank','civet_genet','hog','leopard','monkey_prosimian','rodent']]\n",
    "\n",
    "\n",
    "# Make \"id\" the index column\n",
    "train_X.set_index('id', inplace=True) # inplace = True means that it edits the original dataframe, and no new dataframe is created\n",
    "train_Y.set_index('id', inplace=True)\n",
    "\n",
    "test_X.set_index('id', inplace=True)\n",
    "test_Y.set_index('id', inplace=True)\n",
    "\n",
    "#print(test_Y)\n",
    "\n",
    "\n",
    "#print(train_X)\n",
    "#print(train_Y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Make it so that if there already exists a dataset for train_X, train_Y, and test_X, then we will use those (so that each of my models are trained on the same data, making them deterministic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "used old directory\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "if not os.path.exists('train_split_X.csv'):\n",
    "    print(\"create new directory\")\n",
    "    train_X.to_csv('train_split_X.csv')\n",
    "    train_Y.to_csv('train_split_Y.csv')\n",
    "    test_X.to_csv('test_split_X.csv')\n",
    "    test_Y.to_csv('test_split_Y.csv')\n",
    "\n",
    "else:\n",
    "    print(\"used old directory\")\n",
    "    train_X = pd.read_csv('train_split_X.csv')\n",
    "    train_Y = pd.read_csv('train_split_Y.csv')\n",
    "    test_X = pd.read_csv('test_split_X.csv')\n",
    "    test_Y = pd.read_csv(\"test_split_Y.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Check to see if each image has the same dimensions since that's important for data preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from PIL import Image\n",
    "# import os\n",
    "\n",
    "# def check_image_dimensions(directory):\n",
    "#     image_sizes = {}\n",
    "#     for img_name in os.listdir(directory):\n",
    "#         if not img_name.lower().endswith(('.png', '.jpg', '.jpeg', '.tif')): # now also checks for .tif\n",
    "#             continue\n",
    "#         img_path = os.path.join(directory, img_name)\n",
    "#         with Image.open(img_path) as img:\n",
    "#             # Get image size\n",
    "#             size = img.size\n",
    "#             if size in image_sizes:\n",
    "#                 image_sizes[size] += 1\n",
    "#             else:\n",
    "#                 image_sizes[size] = 1\n",
    "\n",
    "#     for size, count in image_sizes.items():\n",
    "#         print(f\"For the {directory} directory, {count} images are of dimension {size}\")\n",
    "\n",
    "# # Use it on the train and test data only if this code segment was never ran in this coding session:\n",
    "\n",
    "# # Use it on the train and test data:\n",
    "# check_image_dimensions('train_features')\n",
    "# check_image_dimensions('test_features')\n",
    "\n",
    "\n",
    "# # # For the train_features directory, different dimensions found: {(160, 120), (960, 515), (640, 335), (960, 540), (640, 360), (360, 215), (160, 95), (360, 240)}\n",
    "# # # For the test_features directory, different dimensions found: {(960, 515), (160, 120), (640, 335), (960, 540), (320, 215), (640, 360), (360, 240), (320, 240)}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resizing all the images "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I will actually make the resizing function when I use the ImageDataGenertor. \n",
    "# By calling the resize function in the ImageDataGenerator, I won't have to save my images in my local folder and waste space. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Before I use ImageDataGenerator, I have to format my dataframes so that they are able to be read properly by ImageDataGenertor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a multi-class problem so data format has to be modified so that it can be handled by ImageDataGenerator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                             filepath   site  antelope_duiker  bird  blank  \\\n",
      "id                                                                           \n",
      "ZJ000687  train_features/ZJ000687.jpg  S0043              0.0   0.0    0.0   \n",
      "ZJ000926  train_features/ZJ000926.jpg  S0138              1.0   0.0    0.0   \n",
      "ZJ014494  train_features/ZJ014494.jpg  S0122              0.0   0.0    1.0   \n",
      "ZJ007702  train_features/ZJ007702.jpg  S0141              1.0   0.0    0.0   \n",
      "ZJ006294  train_features/ZJ006294.jpg  S0150              0.0   0.0    0.0   \n",
      "...                               ...    ...              ...   ...    ...   \n",
      "ZJ015363  train_features/ZJ015363.jpg  S0176              0.0   0.0    0.0   \n",
      "ZJ015565  train_features/ZJ015565.jpg  S0124              0.0   1.0    0.0   \n",
      "ZJ015926  train_features/ZJ015926.jpg  S0197              1.0   0.0    0.0   \n",
      "ZJ016248  train_features/ZJ016248.jpg  S0092              0.0   0.0    1.0   \n",
      "ZJ016482  train_features/ZJ016482.jpg  S0146              0.0   0.0    1.0   \n",
      "\n",
      "          civet_genet  hog  leopard  monkey_prosimian  rodent  \\\n",
      "id                                                              \n",
      "ZJ000687          0.0  0.0      1.0               0.0     0.0   \n",
      "ZJ000926          0.0  0.0      0.0               0.0     0.0   \n",
      "ZJ014494          0.0  0.0      0.0               0.0     0.0   \n",
      "ZJ007702          0.0  0.0      0.0               0.0     0.0   \n",
      "ZJ006294          0.0  0.0      0.0               1.0     0.0   \n",
      "...               ...  ...      ...               ...     ...   \n",
      "ZJ015363          0.0  0.0      1.0               0.0     0.0   \n",
      "ZJ015565          0.0  0.0      0.0               0.0     0.0   \n",
      "ZJ015926          0.0  0.0      0.0               0.0     0.0   \n",
      "ZJ016248          0.0  0.0      0.0               0.0     0.0   \n",
      "ZJ016482          0.0  0.0      0.0               0.0     0.0   \n",
      "\n",
      "                    labels  \n",
      "id                          \n",
      "ZJ000687           leopard  \n",
      "ZJ000926   antelope_duiker  \n",
      "ZJ014494             blank  \n",
      "ZJ007702   antelope_duiker  \n",
      "ZJ006294  monkey_prosimian  \n",
      "...                    ...  \n",
      "ZJ015363           leopard  \n",
      "ZJ015565              bird  \n",
      "ZJ015926   antelope_duiker  \n",
      "ZJ016248             blank  \n",
      "ZJ016482             blank  \n",
      "\n",
      "[4123 rows x 11 columns]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Merge the two datasets\n",
    "merged_train = pd.merge(train_X, train_Y, on='id')\n",
    "\n",
    "# Set \"id\" as the index column\n",
    "merged_train.set_index(\"id\", inplace = True) # inplace = True means that it edits the original dataframe, and no new dataframe is created\n",
    "\n",
    "# Convert multi-label columns into a single column, so that this column tells us what animal type the row is \n",
    "merged_train['labels'] = merged_train.apply(lambda row: ' '.join([col for col in merged_train.columns[2:] if row[col]==1]), axis=1)\n",
    "\n",
    "\n",
    "# Do the same thing for the test set (from train-test split)\n",
    "\n",
    "\n",
    "\n",
    "# Merge the two datasets\n",
    "merged_test = pd.merge(test_X, test_Y, on='id')\n",
    "\n",
    "# Set \"id\" as the index column\n",
    "merged_test.set_index(\"id\", inplace = True) # inplace = True means that it edits the original dataframe, and no new dataframe is created\n",
    "\n",
    "# Convert multi-label columns into a single column, so that this column tells us what animal type the row is \n",
    "merged_test['labels'] = merged_test.apply(lambda row: ' '.join([col for col in merged_test.columns[2:] if row[col]==1]), axis=1)\n",
    "\n",
    "print(merged_test)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use Keras ImageDataGenerator() on Train/Test split\n",
    "The ImageDataGenerator not only helps you load images from the disk but also allows you to perform **data augmentation**, which is a technique to increase the diversity of your training set by applying random transformations (like rotation, zoom, flips, etc.) to the images. This is very useful to prevent overfitting and helps the model generalize better."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 12365 validated image filenames belonging to 8 classes.\n",
      "Found 4123 validated image filenames belonging to 8 classes.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "\n",
    "# Creating an instance of the ImageDataGenerator for data augmentation and preprocessing\n",
    "train_datagen = ImageDataGenerator(\n",
    "    rescale=1./255,  # Rescale the image pixel values to [0,1]\n",
    "    #preprocessing_function = custom_resize,  # call the crop function on each image\n",
    "\n",
    "    # rotation_range=20,  # Up to 20 degrees of rotation\n",
    "    # brightness_range=[0.8, 1.2],  # Adjust brightness by 20%\n",
    "    # horizontal_flip=True,  # Horizontal flip\n",
    "    # fill_mode='nearest' # The value \"nearest\" for fill_mode means that any empty space will be filled with the nearest pixel values. In other words, it copies the value of the nearest border pixel to fill the gap. \n",
    "\n",
    "\n",
    ")\n",
    "\n",
    "test_datagen = ImageDataGenerator(\n",
    "    rescale=1./255,  # Rescale the image pixel values to [0,1]\n",
    "    #preprocessing_function = custom_resize,  # call the crop function on each image\n",
    "\n",
    "\n",
    "    # You not supposed to do data augmetation on test data, to replicate real life data. The only data augmentation should be resizing\n",
    ")\n",
    "\n",
    "# Flow from dataframe method to load images using the dataframe\n",
    "\n",
    "train_split_generator = train_datagen.flow_from_dataframe(\n",
    "    dataframe=merged_train,\n",
    "    x_col='filepath',\n",
    "    y_col='labels',\n",
    "    target_size=(224, 224),  # automatically resizes so no need for custom resize. When I did custom resize, it made my model worse\n",
    "    color_mode='rgb',\n",
    "    class_mode='categorical',\n",
    "    batch_size=32,\n",
    "    shuffle=True,\n",
    "    seed=42\n",
    ")\n",
    "\n",
    "test_split_generator = test_datagen.flow_from_dataframe(\n",
    "    dataframe=merged_test, \n",
    "    x_col='filepath',\n",
    "    y_col='labels',\n",
    "    target_size=(224, 224), # automatically resizes so no need for custom resize. When I did custom resize, it made my model worse\n",
    "    color_mode='rgb',\n",
    "    class_mode='categorical',\n",
    "    batch_size=32,\n",
    "    shuffle=False,\n",
    "    seed=42\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use Keras ImageDataGenerator() on my test data (from test_values.csv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 4464 validated image filenames.\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from PIL import Image\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "\n",
    "test_datagen = ImageDataGenerator(\n",
    "    rescale=1./255,  # Rescale the image pixel values to [0,1]\n",
    "    #preprocessing_function = custom_resize,  # call the crop function on each image\n",
    "\n",
    "\n",
    "    # You not supposed to do data augmetation on test data, to replicate real life data. The only data augmentation should be resizing\n",
    ")\n",
    "\n",
    "# Flow from dataframe method to load images using the dataframe\n",
    "\n",
    "\n",
    "test_original_generator = test_datagen.flow_from_dataframe(\n",
    "    dataframe=test_values, \n",
    "    x_col='filepath',\n",
    "    #y_col='', # The actual test data has no labels\n",
    "    target_size=(224, 224),   # automatically resizes so no need for custom resize. When I did custom resize, it made my model worse\n",
    "    color_mode='rgb',\n",
    "    class_mode= None, # The actual test data has no labels\n",
    "    batch_size=32,\n",
    "    shuffle=False,\n",
    "    seed=42\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Retrieve a batch of images\n",
    "images = next(train_split_generator)\n",
    "\n",
    "# Display the first two images\n",
    "plt.figure(figsize=(10, 5))\n",
    "\n",
    "# Image 1\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(images[0][0])\n",
    "plt.title(\"Image 1\")\n",
    "plt.axis('off')\n",
    "\n",
    "# Image 2\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.imshow(images[0][1])\n",
    "plt.title(\"Image 2\")\n",
    "plt.axis('off')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "# from PIL import Image\n",
    "# import numpy as np\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "# class ImageDataGeneratorWithPaths(ImageDataGenerator):\n",
    "#     def flow_from_dataframe(self, *args, **kwargs):\n",
    "#         base_generator = super().flow_from_dataframe(*args, **kwargs)\n",
    "#         while True:\n",
    "#             batch_data = next(base_generator)\n",
    "#             indices = base_generator.index_array\n",
    "#             filenames = [base_generator.filenames[i] for i in indices]\n",
    "#             yield batch_data[0], batch_data[1], filenames\n",
    "\n",
    "# test_datagen = ImageDataGeneratorWithPaths(\n",
    "#     rescale=1./255,  # Rescale the image pixel values to [0,1]\n",
    "# )\n",
    "\n",
    "# # Flow from dataframe method to load images using the dataframe\n",
    "# test_original_generator = test_datagen.flow_from_dataframe(\n",
    "#     dataframe=test_values, \n",
    "#     x_col='filepath',\n",
    "#     target_size=(224, 224),   \n",
    "#     color_mode='rgb',\n",
    "#     class_mode= None, \n",
    "#     batch_size=32,\n",
    "#     shuffle=False,\n",
    "#     seed=42\n",
    "# )\n",
    "\n",
    "# # Get a batch of images, labels, and filenames\n",
    "# images, labels, filenames = next(test_original_generator)\n",
    "\n",
    "# # Now, filenames contains the filenames of the images in the current batch\n",
    "# print(filenames)\n",
    "\n",
    "# # Display the first two images\n",
    "# plt.figure(figsize=(10, 5))\n",
    "\n",
    "# plt.subplot(1, 2, 1)\n",
    "# plt.imshow(images[0])\n",
    "# plt.title('Image 1')\n",
    "# #plt.gca().set_aspect('equal', adjustable='box')\n",
    "\n",
    "# # plt.subplot(1, 2, 2)\n",
    "# # plt.imshow(images[1])\n",
    "# # plt.title('Image 2')\n",
    "# # plt.gca().set_aspect('equal', adjustable='box')\n",
    "\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confirm that the generators have the correct image size of (height,width) = (224, 224)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "# # Get a batch of images and labels from the train generator\n",
    "# images, labels = next(train_split_generator)\n",
    "\n",
    "# # Print the shape, type of the images, and filepaths\n",
    "# print(\"Images shape:\", images.shape)\n",
    "# print(\"Images type:\", images.dtype)\n",
    "# print(\"Filepaths:\", train_split_generator.filenames[:2])  # Print the first two filepaths\n",
    "\n",
    "# print(merged_train)\n",
    "\n",
    "# # Display the first two images\n",
    "# plt.figure(figsize=(10, 5))\n",
    "\n",
    "# plt.subplot(1, 2, 1)\n",
    "# plt.imshow(images[0])\n",
    "# plt.title('Image 1')\n",
    "\n",
    "# plt.subplot(1, 2, 2)\n",
    "# plt.imshow(images[1])\n",
    "# plt.title('Image 2')\n",
    "\n",
    "# plt.show()\n",
    "\n",
    "# # Do the same for the test generator\n",
    "# images, labels = next(test_split_generator)\n",
    "# print(\"Images shape:\", images.shape)\n",
    "# print(\"Images type:\", images.dtype)\n",
    "# print(\"Filepaths:\", test_split_generator.filenames[:2])  # Print the first two filepaths\n",
    "\n",
    "# # Display the first two images\n",
    "# plt.figure(figsize=(10, 5))\n",
    "\n",
    "# plt.subplot(1, 2, 1)\n",
    "# plt.imshow(images[0])\n",
    "# plt.title('Image 1')\n",
    "\n",
    "# plt.subplot(1, 2, 2)\n",
    "# plt.imshow(images[1])\n",
    "# plt.title('Image 2')\n",
    "\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Model Development:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model 1 of ResNet50. Score: 2.0596"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-02 15:57:44.065506: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:44.444029: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:44.444148: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:44.448731: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:44.448836: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:44.448872: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:45.237457: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:45.237661: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:45.237684: I tensorflow/core/common_runtime/gpu/gpu_device.cc:2022] Could not identify NUMA node of platform GPU id 0, defaulting to 0.  Your kernel may not have been built with NUMA support.\n",
      "2024-02-02 15:57:45.237779: I external/local_xla/xla/stream_executor/cuda/cuda_executor.cc:887] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node\n",
      "Your kernel may have been built without NUMA support.\n",
      "2024-02-02 15:57:45.237830: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 5535 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 4070 Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-02-02 15:57:49.153590: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8902\n",
      "2024-02-02 15:57:50.026538: I external/local_xla/xla/service/service.cc:168] XLA service 0x7f93c475f400 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n",
      "2024-02-02 15:57:50.026577: I external/local_xla/xla/service/service.cc:176]   StreamExecutor device (0): NVIDIA GeForce RTX 4070 Laptop GPU, Compute Capability 8.9\n",
      "2024-02-02 15:57:50.041924: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:269] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n",
      "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n",
      "I0000 00:00:1706907470.142431    1852 device_compiler.h:186] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "387/387 [==============================] - 128s 325ms/step - loss: 1.9244 - accuracy: 0.2521 - categorical_crossentropy: 1.9244 - val_loss: 1.8092 - val_accuracy: 0.2857 - val_categorical_crossentropy: 1.8092\n",
      "Epoch 2/5\n",
      "387/387 [==============================] - 113s 293ms/step - loss: 1.7773 - accuracy: 0.3056 - categorical_crossentropy: 1.7773 - val_loss: 1.7780 - val_accuracy: 0.2889 - val_categorical_crossentropy: 1.7780\n",
      "Epoch 3/5\n",
      "387/387 [==============================] - 136s 351ms/step - loss: 1.7393 - accuracy: 0.3249 - categorical_crossentropy: 1.7393 - val_loss: 1.6986 - val_accuracy: 0.3362 - val_categorical_crossentropy: 1.6986\n",
      "Epoch 4/5\n",
      "387/387 [==============================] - 145s 376ms/step - loss: 1.7081 - accuracy: 0.3318 - categorical_crossentropy: 1.7081 - val_loss: 1.7598 - val_accuracy: 0.2988 - val_categorical_crossentropy: 1.7598\n",
      "Epoch 5/5\n",
      "387/387 [==============================] - 119s 308ms/step - loss: 1.6750 - accuracy: 0.3436 - categorical_crossentropy: 1.6750 - val_loss: 1.7103 - val_accuracy: 0.3335 - val_categorical_crossentropy: 1.7103\n",
      "140/140 [==============================] - 35s 245ms/step\n",
      "Successfully submitted!\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.applications import ResNet50\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import Dense, GlobalAveragePooling2D\n",
    "\n",
    "# Load pre-trained ResNet50 model without the top layer\n",
    "base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))\n",
    "\n",
    "# Freeze the layers of the base model\n",
    "for layer in base_model.layers:\n",
    "    layer.trainable = False\n",
    "\n",
    "x = base_model.output # This line gets the output of the base_model (ResNet50 without the top layer) and uses it as the starting point for adding new layers.\n",
    "x = GlobalAveragePooling2D()(x)  # Add a global spatial average pooling layer\n",
    "x = Dense(1024, activation='relu')(x)  # Add a fully-connected layer\n",
    "predictions = Dense(8, activation='softmax')(x)  # Add a final output layer\n",
    "\n",
    "# This is the model we will train\n",
    "model = Model(inputs=base_model.input, outputs=predictions) # this model links the ResNetModel and the new layers to the prediction layer\n",
    "\n",
    "\n",
    "# compile model and set the metrics and loss \n",
    "model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy', 'categorical_crossentropy'])\n",
    "\n",
    "\n",
    "# fit model\n",
    "model.fit(train_split_generator, epochs=5, validation_data=test_split_generator)\n",
    "\n",
    "\n",
    "# create predictions\n",
    "predictions = model.predict(test_original_generator)\n",
    "\n",
    "# Create a DataFrame with predictions\n",
    "# Create a DataFrame with predictions\n",
    "prediction_df = pd.DataFrame(predictions, columns=['antelope_duiker', 'bird', 'blank', 'civet_genet', 'hog', 'leopard', 'monkey_prosimian', 'rodent'])\n",
    "\n",
    "# Add the 'id' from the original test DataFrame's index\n",
    "prediction_df['id'] = test_values['id'] # id column from the original test set (test_values.csv)\n",
    "\n",
    "# Ensure 'id' is the first column\n",
    "prediction_df = prediction_df[['id'] + [col for col in prediction_df.columns if col != 'id']]\n",
    "\n",
    "# Save the DataFrame to a CSV file\n",
    "prediction_df.to_csv('submission_ResNet50_2.csv', index=False) # make sure to change file name to represent the model number\n",
    "print(\"Successfully submitted!\")\n",
    "\n",
    "# 10 min for 5 epoch of no data augmentation. loss of 1.6907 in training and loss of 2.0124 in reality. shuffle = false for training\n",
    "# 11 min for 5 epoch of light change (20%) and horizontal flip. Loss of 1.7355 in training and loss of 2.0178 in reality. shuffle = false for training\n",
    "# 14 min for 5 epoch of light change (20%) and horizontal flip. Loss of 1.7255 in training and loss of 2.0195 in reality. shuffle = true for training\n",
    "# 13 min for 5 epoch of no data augmentation. Loss of 1.6750 in training and loss of 2.0061 in reality. shuffle = true for training\n",
    "\n",
    "\n",
    "# 387/387 [==============================] - 154s 390ms/step - loss: 1.9244 - accuracy: 0.2521 - categorical_crossentropy: 1.9244 - val_loss: 1.8092 - val_accuracy: 0.2857 - val_categorical_crossentropy: 1.8092\n",
    "# Epoch 2/5\n",
    "# 387/387 [==============================] - 144s 373ms/step - loss: 1.7773 - accuracy: 0.3056 - categorical_crossentropy: 1.7773 - val_loss: 1.7780 - val_accuracy: 0.2889 - val_categorical_crossentropy: 1.7780\n",
    "# Epoch 3/5\n",
    "# 387/387 [==============================] - 147s 381ms/step - loss: 1.7393 - accuracy: 0.3249 - categorical_crossentropy: 1.7393 - val_loss: 1.6986 - val_accuracy: 0.3362 - val_categorical_crossentropy: 1.6986\n",
    "# Epoch 4/5\n",
    "# 387/387 [==============================] - 153s 397ms/step - loss: 1.7081 - accuracy: 0.3318 - categorical_crossentropy: 1.7081 - val_loss: 1.7598 - val_accuracy: 0.2988 - val_categorical_crossentropy: 1.7598\n",
    "# Epoch 5/5\n",
    "# 387/387 [==============================] - 147s 380ms/step - loss: 1.6750 - accuracy: 0.3436 - categorical_crossentropy: 1.6750 - val_loss: 1.7103 - val_accuracy: 0.3335 - val_categorical_crossentropy: 1.7103\n",
    "# 140/140 [==============================] - 43s 302ms/step\n",
    "# Successfully submitted!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optuna tuning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[I 2024-02-02 16:09:05,282] A new study created in memory with name: no-name-b0a338e1-b6d4-4c8c-971f-822780af2fd7\n",
      "/tmp/ipykernel_239/2990458819.py:25: FutureWarning: suggest_loguniform has been deprecated in v3.0.0. This feature will be removed in v6.0.0. See https://github.com/optuna/optuna/releases/tag/v3.0.0. Use suggest_float(..., log=True) instead.\n",
      "  model.compile(optimizer=Adam(lr=trial.suggest_loguniform('lr', 1e-4, 1e-2)),\n",
      "WARNING:absl:`lr` is deprecated in Keras optimizer, please use `learning_rate` or use the legacy optimizer, e.g.,tf.keras.optimizers.legacy.Adam.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/3\n",
      "387/387 [==============================] - 99s 243ms/step - loss: 1.9155 - accuracy: 0.2584\n",
      "Epoch 2/3\n",
      "368/387 [===========================>..] - ETA: 4s - loss: 1.7932 - accuracy: 0.2993"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[W 2024-02-02 16:12:16,763] Trial 0 failed with parameters: {'units': 543, 'lr': 0.0011188927583150477} because of the following error: KeyboardInterrupt().\n",
      "Traceback (most recent call last):\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/optuna/study/_optimize.py\", line 200, in _run_trial\n",
      "    value_or_values = func(trial)\n",
      "  File \"/tmp/ipykernel_239/2990458819.py\", line 30, in objective\n",
      "    model.fit(train_split_generator, epochs=3)\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/keras/src/utils/traceback_utils.py\", line 65, in error_handler\n",
      "    return fn(*args, **kwargs)\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/keras/src/engine/training.py\", line 1807, in fit\n",
      "    tmp_logs = self.train_function(iterator)\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/util/traceback_utils.py\", line 150, in error_handler\n",
      "    return fn(*args, **kwargs)\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\", line 832, in __call__\n",
      "    result = self._call(*args, **kwds)\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py\", line 868, in _call\n",
      "    return tracing_compilation.call_function(\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py\", line 139, in call_function\n",
      "    return function._call_flat(  # pylint: disable=protected-access\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py\", line 1323, in _call_flat\n",
      "    return self._inference_function.call_preflattened(args)\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py\", line 216, in call_preflattened\n",
      "    flat_outputs = self.call_flat(*args)\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py\", line 251, in call_flat\n",
      "    outputs = self._bound_context.call_function(\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/context.py\", line 1486, in call_function\n",
      "    outputs = execute.execute(\n",
      "  File \"/home/michaelye22/.local/lib/python3.10/site-packages/tensorflow/python/eager/execute.py\", line 53, in quick_execute\n",
      "    tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n",
      "KeyboardInterrupt\n",
      "[W 2024-02-02 16:12:16,770] Trial 0 failed with value None.\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[21], line 38\u001b[0m\n\u001b[1;32m     35\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m score[\u001b[38;5;241m1\u001b[39m]  \u001b[38;5;66;03m# Return validation accuracy\u001b[39;00m\n\u001b[1;32m     37\u001b[0m study \u001b[38;5;241m=\u001b[39m optuna\u001b[38;5;241m.\u001b[39mcreate_study(direction\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmaximize\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m---> 38\u001b[0m \u001b[43mstudy\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobjective\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/optuna/study/study.py:451\u001b[0m, in \u001b[0;36mStudy.optimize\u001b[0;34m(self, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m    348\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21moptimize\u001b[39m(\n\u001b[1;32m    349\u001b[0m     \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    350\u001b[0m     func: ObjectiveFuncType,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    357\u001b[0m     show_progress_bar: \u001b[38;5;28mbool\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m    358\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m    359\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Optimize an objective function.\u001b[39;00m\n\u001b[1;32m    360\u001b[0m \n\u001b[1;32m    361\u001b[0m \u001b[38;5;124;03m    Optimization is done by choosing a suitable set of hyperparameter values from a given\u001b[39;00m\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    449\u001b[0m \u001b[38;5;124;03m            If nested invocation of this method occurs.\u001b[39;00m\n\u001b[1;32m    450\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 451\u001b[0m     \u001b[43m_optimize\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    452\u001b[0m \u001b[43m        \u001b[49m\u001b[43mstudy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m    453\u001b[0m \u001b[43m        \u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    454\u001b[0m \u001b[43m        \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_trials\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    455\u001b[0m \u001b[43m        \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    456\u001b[0m \u001b[43m        \u001b[49m\u001b[43mn_jobs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mn_jobs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    457\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcatch\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mtuple\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43misinstance\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mIterable\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    458\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    459\u001b[0m \u001b[43m        \u001b[49m\u001b[43mgc_after_trial\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mgc_after_trial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    460\u001b[0m \u001b[43m        \u001b[49m\u001b[43mshow_progress_bar\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mshow_progress_bar\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    461\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/optuna/study/_optimize.py:66\u001b[0m, in \u001b[0;36m_optimize\u001b[0;34m(study, func, n_trials, timeout, n_jobs, catch, callbacks, gc_after_trial, show_progress_bar)\u001b[0m\n\u001b[1;32m     64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     65\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m---> 66\u001b[0m         \u001b[43m_optimize_sequential\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     67\u001b[0m \u001b[43m            \u001b[49m\u001b[43mstudy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     68\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     69\u001b[0m \u001b[43m            \u001b[49m\u001b[43mn_trials\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     70\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     71\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     72\u001b[0m \u001b[43m            \u001b[49m\u001b[43mcallbacks\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     73\u001b[0m \u001b[43m            \u001b[49m\u001b[43mgc_after_trial\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     74\u001b[0m \u001b[43m            \u001b[49m\u001b[43mreseed_sampler_rng\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m     75\u001b[0m \u001b[43m            \u001b[49m\u001b[43mtime_start\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[1;32m     76\u001b[0m \u001b[43m            \u001b[49m\u001b[43mprogress_bar\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprogress_bar\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     77\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     78\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     79\u001b[0m         \u001b[38;5;28;01mif\u001b[39;00m n_jobs \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/optuna/study/_optimize.py:163\u001b[0m, in \u001b[0;36m_optimize_sequential\u001b[0;34m(study, func, n_trials, timeout, catch, callbacks, gc_after_trial, reseed_sampler_rng, time_start, progress_bar)\u001b[0m\n\u001b[1;32m    160\u001b[0m         \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m    162\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 163\u001b[0m     frozen_trial \u001b[38;5;241m=\u001b[39m \u001b[43m_run_trial\u001b[49m\u001b[43m(\u001b[49m\u001b[43mstudy\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcatch\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    164\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m    165\u001b[0m     \u001b[38;5;66;03m# The following line mitigates memory problems that can be occurred in some\u001b[39;00m\n\u001b[1;32m    166\u001b[0m     \u001b[38;5;66;03m# environments (e.g., services that use computing containers such as GitHub Actions).\u001b[39;00m\n\u001b[1;32m    167\u001b[0m     \u001b[38;5;66;03m# Please refer to the following PR for further details:\u001b[39;00m\n\u001b[1;32m    168\u001b[0m     \u001b[38;5;66;03m# https://github.com/optuna/optuna/pull/325.\u001b[39;00m\n\u001b[1;32m    169\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m gc_after_trial:\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/optuna/study/_optimize.py:251\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    244\u001b[0m         \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28;01mFalse\u001b[39;00m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mShould not reach.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    246\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[1;32m    247\u001b[0m     frozen_trial\u001b[38;5;241m.\u001b[39mstate \u001b[38;5;241m==\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mFAIL\n\u001b[1;32m    248\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m func_err \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    249\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(func_err, catch)\n\u001b[1;32m    250\u001b[0m ):\n\u001b[0;32m--> 251\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m func_err\n\u001b[1;32m    252\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m frozen_trial\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/optuna/study/_optimize.py:200\u001b[0m, in \u001b[0;36m_run_trial\u001b[0;34m(study, func, catch)\u001b[0m\n\u001b[1;32m    198\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m get_heartbeat_thread(trial\u001b[38;5;241m.\u001b[39m_trial_id, study\u001b[38;5;241m.\u001b[39m_storage):\n\u001b[1;32m    199\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 200\u001b[0m         value_or_values \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrial\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    201\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m exceptions\u001b[38;5;241m.\u001b[39mTrialPruned \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    202\u001b[0m         \u001b[38;5;66;03m# TODO(mamu): Handle multi-objective cases.\u001b[39;00m\n\u001b[1;32m    203\u001b[0m         state \u001b[38;5;241m=\u001b[39m TrialState\u001b[38;5;241m.\u001b[39mPRUNED\n",
      "Cell \u001b[0;32mIn[21], line 30\u001b[0m, in \u001b[0;36mobjective\u001b[0;34m(trial)\u001b[0m\n\u001b[1;32m     25\u001b[0m model\u001b[38;5;241m.\u001b[39mcompile(optimizer\u001b[38;5;241m=\u001b[39mAdam(lr\u001b[38;5;241m=\u001b[39mtrial\u001b[38;5;241m.\u001b[39msuggest_loguniform(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlr\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m1e-4\u001b[39m, \u001b[38;5;241m1e-2\u001b[39m)),\n\u001b[1;32m     26\u001b[0m               loss\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mcategorical_crossentropy\u001b[39m\u001b[38;5;124m'\u001b[39m,\n\u001b[1;32m     27\u001b[0m               metrics\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maccuracy\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[1;32m     29\u001b[0m \u001b[38;5;66;03m# Train the model\u001b[39;00m\n\u001b[0;32m---> 30\u001b[0m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_split_generator\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m     32\u001b[0m \u001b[38;5;66;03m# Evaluate the model\u001b[39;00m\n\u001b[1;32m     33\u001b[0m score \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mevaluate(test_split_generator, verbose\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/keras/src/utils/traceback_utils.py:65\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.error_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     63\u001b[0m filtered_tb \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m     64\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 65\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     66\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     67\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.10/site-packages/keras/src/engine/training.py:1807\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   1799\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   1800\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtrain\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m   1801\u001b[0m     epoch_num\u001b[38;5;241m=\u001b[39mepoch,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1804\u001b[0m     _r\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m,\n\u001b[1;32m   1805\u001b[0m ):\n\u001b[1;32m   1806\u001b[0m     callbacks\u001b[38;5;241m.\u001b[39mon_train_batch_begin(step)\n\u001b[0;32m-> 1807\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   1808\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m data_handler\u001b[38;5;241m.\u001b[39mshould_sync:\n\u001b[1;32m   1809\u001b[0m         context\u001b[38;5;241m.\u001b[39masync_wait()\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/util/traceback_utils.py:150\u001b[0m, in \u001b[0;36mfilter_traceback.<locals>.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.10/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:832\u001b[0m, in \u001b[0;36mFunction.__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    829\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    831\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--> 832\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    834\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    835\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.10/site-packages/tensorflow/python/eager/polymorphic_function/polymorphic_function.py:868\u001b[0m, in \u001b[0;36mFunction._call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    865\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    866\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    867\u001b[0m   \u001b[38;5;66;03m# defunned version which is guaranteed to never create variables.\u001b[39;00m\n\u001b[0;32m--> 868\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mtracing_compilation\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    869\u001b[0m \u001b[43m      \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_no_variable_creation_config\u001b[49m\n\u001b[1;32m    870\u001b[0m \u001b[43m  \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    871\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_variable_creation_config \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    872\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    873\u001b[0m   \u001b[38;5;66;03m# in parallel.\u001b[39;00m\n\u001b[1;32m    874\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.10/site-packages/tensorflow/python/eager/polymorphic_function/tracing_compilation.py:139\u001b[0m, in \u001b[0;36mcall_function\u001b[0;34m(args, kwargs, tracing_options)\u001b[0m\n\u001b[1;32m    137\u001b[0m bound_args \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mbind(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    138\u001b[0m flat_inputs \u001b[38;5;241m=\u001b[39m function\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39munpack_inputs(bound_args)\n\u001b[0;32m--> 139\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# pylint: disable=protected-access\u001b[39;49;00m\n\u001b[1;32m    140\u001b[0m \u001b[43m    \u001b[49m\u001b[43mflat_inputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcaptured_inputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfunction\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcaptured_inputs\u001b[49m\n\u001b[1;32m    141\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/concrete_function.py:1323\u001b[0m, in \u001b[0;36mConcreteFunction._call_flat\u001b[0;34m(self, tensor_inputs, captured_inputs)\u001b[0m\n\u001b[1;32m   1319\u001b[0m possible_gradient_type \u001b[38;5;241m=\u001b[39m gradients_util\u001b[38;5;241m.\u001b[39mPossibleTapeGradientTypes(args)\n\u001b[1;32m   1320\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   1321\u001b[0m     \u001b[38;5;129;01mand\u001b[39;00m executing_eagerly):\n\u001b[1;32m   1322\u001b[0m   \u001b[38;5;66;03m# No tape is watching; skip to running the function.\u001b[39;00m\n\u001b[0;32m-> 1323\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_inference_function\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_preflattened\u001b[49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1324\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   1325\u001b[0m     args,\n\u001b[1;32m   1326\u001b[0m     possible_gradient_type,\n\u001b[1;32m   1327\u001b[0m     executing_eagerly)\n\u001b[1;32m   1328\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.10/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:216\u001b[0m, in \u001b[0;36mAtomicFunction.call_preflattened\u001b[0;34m(self, args)\u001b[0m\n\u001b[1;32m    214\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcall_preflattened\u001b[39m(\u001b[38;5;28mself\u001b[39m, args: Sequence[core\u001b[38;5;241m.\u001b[39mTensor]) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Any:\n\u001b[1;32m    215\u001b[0m \u001b[38;5;250m  \u001b[39m\u001b[38;5;124;03m\"\"\"Calls with flattened tensor inputs and returns the structured output.\"\"\"\u001b[39;00m\n\u001b[0;32m--> 216\u001b[0m   flat_outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_flat\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    217\u001b[0m   \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunction_type\u001b[38;5;241m.\u001b[39mpack_output(flat_outputs)\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/polymorphic_function/atomic_function.py:251\u001b[0m, in \u001b[0;36mAtomicFunction.call_flat\u001b[0;34m(self, *args)\u001b[0m\n\u001b[1;32m    249\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m record\u001b[38;5;241m.\u001b[39mstop_recording():\n\u001b[1;32m    250\u001b[0m   \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mexecuting_eagerly():\n\u001b[0;32m--> 251\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_bound_context\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcall_function\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    252\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mname\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    253\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mlist\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    254\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunction_type\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mflat_outputs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    255\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    256\u001b[0m   \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    257\u001b[0m     outputs \u001b[38;5;241m=\u001b[39m make_call_op_in_graph(\n\u001b[1;32m    258\u001b[0m         \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m    259\u001b[0m         \u001b[38;5;28mlist\u001b[39m(args),\n\u001b[1;32m    260\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_bound_context\u001b[38;5;241m.\u001b[39mfunction_call_options\u001b[38;5;241m.\u001b[39mas_attrs(),\n\u001b[1;32m    261\u001b[0m     )\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/context.py:1486\u001b[0m, in \u001b[0;36mContext.call_function\u001b[0;34m(self, name, tensor_inputs, num_outputs)\u001b[0m\n\u001b[1;32m   1484\u001b[0m cancellation_context \u001b[38;5;241m=\u001b[39m cancellation\u001b[38;5;241m.\u001b[39mcontext()\n\u001b[1;32m   1485\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m cancellation_context \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 1486\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   1487\u001b[0m \u001b[43m      \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdecode\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mutf-8\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1488\u001b[0m \u001b[43m      \u001b[49m\u001b[43mnum_outputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mnum_outputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1489\u001b[0m \u001b[43m      \u001b[49m\u001b[43minputs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtensor_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1490\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   1491\u001b[0m \u001b[43m      \u001b[49m\u001b[43mctx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m   1492\u001b[0m \u001b[43m  \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1493\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m   1494\u001b[0m   outputs \u001b[38;5;241m=\u001b[39m execute\u001b[38;5;241m.\u001b[39mexecute_with_cancellation(\n\u001b[1;32m   1495\u001b[0m       name\u001b[38;5;241m.\u001b[39mdecode(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mutf-8\u001b[39m\u001b[38;5;124m\"\u001b[39m),\n\u001b[1;32m   1496\u001b[0m       num_outputs\u001b[38;5;241m=\u001b[39mnum_outputs,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m   1500\u001b[0m       cancellation_manager\u001b[38;5;241m=\u001b[39mcancellation_context,\n\u001b[1;32m   1501\u001b[0m   )\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/tensorflow/python/eager/execute.py:53\u001b[0m, in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     51\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     52\u001b[0m   ctx\u001b[38;5;241m.\u001b[39mensure_initialized()\n\u001b[0;32m---> 53\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     54\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     55\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     56\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": [
    "import optuna\n",
    "from tensorflow.keras.applications import ResNet50\n",
    "from tensorflow.keras.layers import Dense, GlobalAveragePooling2D\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.optimizers import Adam\n",
    "\n",
    "def objective(trial):\n",
    "    # Load the base pretrained model\n",
    "    base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) # weights = 'imagenet' means that it's using pretrained weights. include_top determines whether or not the fully-connected output layers of the model should be included.\n",
    "    # If include_top=False, the full model is loaded except for the output layers. This is useful if you want to fine-tune the model on a different task. By excluding the top layers, you can add your own output layers that are appropriate for your task.\n",
    "    \n",
    "    for layer in base_model.layers:\n",
    "        layer.trainable = False\n",
    "    \n",
    "    # Add a new top layer\n",
    "    x = base_model.output\n",
    "    x = GlobalAveragePooling2D()(x)\n",
    "    x = Dense(trial.suggest_int('units', 32, 1024), activation='relu')(x)\n",
    "    predictions = Dense(8, activation='softmax')(x)\n",
    "\n",
    "    # This is the model we will train\n",
    "    model = Model(inputs=base_model.input, outputs=predictions)\n",
    "\n",
    "    # Compile the model\n",
    "    model.compile(optimizer=Adam(lr=trial.suggest_loguniform('lr', 1e-4, 1e-2)),\n",
    "                  loss='categorical_crossentropy',\n",
    "                  metrics=['accuracy'])\n",
    "\n",
    "    # Train the model\n",
    "    model.fit(train_split_generator, epochs=3)\n",
    "\n",
    "    # Evaluate the model\n",
    "    score = model.evaluate(test_split_generator, verbose=0)\n",
    "\n",
    "    return score[1]  # Return validation accuracy\n",
    "\n",
    "study = optuna.create_study(direction='maximize')\n",
    "study.optimize(objective, n_trials=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another thing to possibly try is to pick an even smaller 16:9 aspect ratio so that there is little to none upsampling (making images larger) "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}