step3_convolutional_neural_network_ensemble.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a convolutional neural network (CNN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we will import the information stored as numpy arrays and create train/test and validation data sets. As we have imbalanced data due to the high abundance of beech trees in the data set, we will do data augmentation and oversampling. Next, we crate the structure for the models used for classification and look into the results and accuracy of our best model.\n",
    "\n",
    "While we tested different model structures and number of features, here, we will only report our best model.\n",
    "\n",
    "\n",
    "**Data you need for running this notebook:**\n",
    "\n",
    "Zipped numpy arrays (.npz) with all information, that should be added to the model (such as spectral information and vegetation height)\n",
    "\n",
    "**Content overview:**\n",
    "\n",
    "* [Setup](#Setup)\n",
    "* [Data manipulation](#Data-Manipulation)\n",
    "* [Prepare the data for the model](#Prepare-the-data-for-the-model)\n",
    "* [Create the Ensemble Convolutional Neural Network Model](#Create-the-Ensemble-Convolutional-Neural-Network-Model)\n",
    "* [Additional Information](#Additional-Information)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-10-10 17:08:36.217574: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-10-10 17:08:36.260276: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n",
      "2023-10-10 17:08:36.261516: 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 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2023-10-10 17:08:37.251407: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n"
     ]
    }
   ],
   "source": [
    "# Toolboxes for data handling\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "# Toolboxes for plotting\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Toolboxes for modelling with a neural network\n",
    "import tensorflow as tf\n",
    "\n",
    "# Toolboxes for splitting the data\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "# Toolboxes for warning handling\n",
    "import warnings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ignore warnings for this notebook\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import and manipulate data "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basis for the modelling are the box images, that have been stored as zipped numpy arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define paths to the data\n",
    "path_spec = './data/TDOP/box_images/TDOP_box_images_2022_weg30m.tif.npz'\n",
    "path_height = './data/LiDAR/box_images/vegheight_box_images_weg30m.tif.npz'\n",
    "path_slope = './data/LiDAR/box_images/slope_box_images_weg30m.tif.npz'\n",
    "path_altitude = './data/LiDAR/box_images/altitude_box_images_weg30m.tif.npz'\n",
    "path_label = './data/Laubbäume_utm32_cleaned.csv'\n",
    "\n",
    "# Load spectral data\n",
    "with np.load(path_spec, allow_pickle=True) as data:\n",
    "    bia_spec = data[\"bia_array\"]\n",
    "\n",
    "# Load vegetation height data\n",
    "with np.load(path_height, allow_pickle=True) as data:\n",
    "    bia_height = data[\"bia_array\"]\n",
    "\n",
    "# Load slope data\n",
    "with np.load(path_slope, allow_pickle=True) as data:\n",
    "    bia_slope = data[\"bia_array\"]\n",
    "\n",
    "# Load altitude data\n",
    "with np.load(path_altitude, allow_pickle=True) as data:\n",
    "    bia_altitude = data[\"bia_array\"]\n",
    "\n",
    "# Load label data, extract only the labels and transform the vector\n",
    "# to an array\n",
    "lbl_array_tmp = np.array(pd.read_csv(path_label).desc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data manipulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Detect weird occurrences in the data and drop them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine weird values in the spectral data\n",
    "# np.unique(bia_spec, return_counts=True)\n",
    "\n",
    "# The spectral data range between 5250 and 65250 but there are\n",
    "# 11552 occurrences with a 0 matching exactly two images 38*38*4\n",
    "\n",
    "# Create identifier for these occurrences\n",
    "ind_spec = np.all(bia_spec == 0, (1,2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine weird values in the height data\n",
    "# np.unique(bia_height, return_counts=True)\n",
    "\n",
    "# The height data range between .05 and 44.15 but there are\n",
    "# 200 occurrences with a 0 matching exactly two images 10*10*1\n",
    "\n",
    "# Create identifier for these occurrences\n",
    "ind_height = np.all(bia_height == 0, (1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine weird values in the slope data\n",
    "# np.unique(bia_slope, return_counts=True)\n",
    "\n",
    "# The slope ranges between 10 and 85° but there are two occurrences of\n",
    "# -9999 and three with 0\n",
    "\n",
    "# Create identifier for these occurrences\n",
    "ind_slope = bia_slope < 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine weird values in the altitude data\n",
    "# np.unique(bia_altitude, return_counts=True)\n",
    "\n",
    "# The altitude ranges between 630 and 960 meters but there are\n",
    "# two occurrences with a -3250 meters\n",
    "\n",
    "# Create identifier for these occurrences\n",
    "ind_altitude = bia_altitude < 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Summarize the indicators so that one indication is enough to exclude a tree coordinate\n",
    "ind_incl = ind_spec.astype(int) + ind_height.astype(int) + ind_slope.astype(int) + ind_altitude.astype(int)\n",
    "\n",
    "# Let's exclude all weird occurrences from our data\n",
    "bia_spec = bia_spec[ind_incl == 0]\n",
    "bia_height = bia_height[ind_incl == 0]\n",
    "bia_slope = bia_slope[ind_incl == 0]\n",
    "bia_altitude = bia_altitude[ind_incl == 0]\n",
    "lbl_array_tmp = lbl_array_tmp[ind_incl == 0]\n",
    "\n",
    "# Eventually, only two occurrences and hence two tree coordinates are dropped"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scale the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scale the spectral data\n",
    "bia_spec = bia_spec / ((2**16)-1)\n",
    "\n",
    "# Calculate the extreme height values\n",
    "height_min = np.min(bia_height)\n",
    "height_max = np.max(bia_height)\n",
    "\n",
    "# Scale the slope data\n",
    "bia_height = (bia_height - height_min) / (height_max - height_min)\n",
    "\n",
    "# Calculate the extreme slope values\n",
    "slope_min = np.min(bia_slope)\n",
    "slope_max = np.max(bia_slope)\n",
    "\n",
    "# Scale the slope data\n",
    "bia_slope = (bia_slope - slope_min) / (slope_max - slope_min)\n",
    "\n",
    "# Calculate the extreme altitude values\n",
    "altitude_min = np.min(bia_altitude)\n",
    "altitude_max = np.max(bia_altitude)\n",
    "\n",
    "# Scale the altitude data\n",
    "bia_altitude = (bia_altitude - altitude_min) / (altitude_max - altitude_min)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot example spectral images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate a random number to extract a spectral image\n",
    "ind_rand = np.random.randint(0, bia_spec.shape[0])\n",
    "\n",
    "# Showcase an image of the spectral data\n",
    "plt.imshow(bia_spec[ind_rand,:,:,0:3]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assign labels as integers to different trees species"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As tensorflow prefers integers compared to strings as target values, we transform our labels array. In this array \"1\" indicates a \"Rotbuche\", \"2\" indicates a \"Berg-Ahorn\", \"3\" indicates a \"Haenge-Birke\" and \"0\" indicates a tree belonging to any other three species."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# New indicator array filled with 0s\n",
    "lbl_array = np.zeros_like(lbl_array_tmp)\n",
    "\n",
    "# Loop through each label\n",
    "for i in range(len(lbl_array_tmp)):\n",
    "    \n",
    "    # Assign a 1 if it is a Rotbuche\n",
    "    if lbl_array_tmp[i] == 'Rotbuche':\n",
    "        lbl_array[i] = 1\n",
    "\n",
    "    # Assign a 2 if it is a Berg-Ahorn    \n",
    "    elif lbl_array_tmp[i] == 'Berg-Ahorn':\n",
    "        lbl_array[i] = 2\n",
    "\n",
    "    # Assign a 3 if it is a Haenge-Birke\n",
    "    elif lbl_array_tmp[i] == 'Haenge-Birke':\n",
    "        lbl_array[i] = 3\n",
    "    \n",
    "# Change the type of the array from \"obj\" to \"int\"\n",
    "lbl_array = lbl_array.astype('int')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare the data for the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Split the data into a train, test and validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create as many indices as there are trees (irrespective of years)\n",
    "ind = np.arange(0, len(lbl_array), 1)\n",
    "\n",
    "# Split the indices into a train and temporary test set\n",
    "train_ind, test_ind_tmp, train_lbl, test_lbl_tmp = \\\n",
    "    train_test_split(ind, lbl_array, train_size=0.8, stratify=lbl_array, random_state=42)\n",
    "\n",
    "# Split the temporary test indices once again into a test and validation set\n",
    "test_ind, val_ind, test_lbl, val_lbl = \\\n",
    "    train_test_split(test_ind_tmp, test_lbl_tmp, train_size=0.5, stratify=test_lbl_tmp, random_state=42)\n",
    "\n",
    "# Extract images and labels for the train data set using the train indices\n",
    "train_spec = bia_spec[train_ind,:,:,:]\n",
    "train_height = bia_height[train_ind,:,:]\n",
    "train_slope = bia_slope[train_ind]\n",
    "train_altitude = bia_altitude[train_ind]\n",
    "train_label = lbl_array[train_ind]\n",
    "\n",
    "# Extract images and labels for the test data set using the test indices\n",
    "test_spec = bia_spec[test_ind,:,:,:]\n",
    "test_height = bia_height[test_ind,:,:]\n",
    "test_slope = bia_slope[test_ind]\n",
    "test_altitude = bia_altitude[test_ind]\n",
    "test_label = lbl_array[test_ind]\n",
    "\n",
    "# Extract images and labels for the validation data set using the validation indices\n",
    "val_spec = bia_spec[val_ind,:,:,:]\n",
    "val_height = bia_height[val_ind,:,:]\n",
    "val_slope = bia_slope[val_ind]\n",
    "val_altitude = bia_altitude[val_ind]\n",
    "val_label = lbl_array[val_ind]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Perform data augmentation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To deal with the low sample size of the data set, we will create variations of the existing images, called augmentation.\n",
    "\n",
    "We only perform flips and 90° rotations as other augmentations may interfere with vital information in the image - let's  be crazy and flip and rotate all images in all possible combinations (x12). We first create a function for this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function that takes a dataset of images and augments each image\n",
    "# once in a certain way\n",
    "def augment_images(img_array):\n",
    "\n",
    "    # Predefine an array that will contain the augmented images\n",
    "    img_array_full = np.tile(img_array, (12,1,1,1,1))\n",
    "\n",
    "    # Loop through each image\n",
    "    for i in range(img_array.shape[0]):\n",
    "\n",
    "        # Augmentation number 0: Nothing\n",
    "        img_aug = img_array_full[0,i]\n",
    "        img_array_full[0,i] = img_aug\n",
    "\n",
    "        # Augmentation number 1: 90° rotation        \n",
    "        img_aug = tf.image.rot90(img_array[i], k=1).numpy()\n",
    "        img_array_full[1,i] = img_aug\n",
    "\n",
    "        # Augmentation number 2: 90° rotation + vertical flip\n",
    "        img_aug = tf.image.rot90(img_array[i], k=1).numpy()\n",
    "        img_aug = tf.image.flip_up_down(img_aug).numpy()\n",
    "        img_array_full[2,i] = img_aug\n",
    "\n",
    "        # Augmentation number 3: 90° rotation + horizontal flip\n",
    "        img_aug = tf.image.rot90(img_array[i], k=1).numpy()\n",
    "        img_aug = tf.image.flip_left_right(img_aug).numpy()\n",
    "        img_array_full[3,i] = img_aug\n",
    "\n",
    "        # Augmentation number 4: 90° rotation + vertical flip +\n",
    "        # horizontal flip\n",
    "        img_aug = tf.image.rot90(img_array[i], k=1).numpy()\n",
    "        img_aug = tf.image.flip_up_down(img_aug).numpy()\n",
    "        img_aug = tf.image.flip_left_right(img_aug).numpy()\n",
    "        img_array_full[4,i] = img_aug\n",
    "\n",
    "        # Augmentation number 5: 270° rotation\n",
    "        img_aug = tf.image.rot90(img_array[i], k=3).numpy()\n",
    "        img_array_full[5,i] = img_aug\n",
    "\n",
    "        # Augmentation number 6: 270° rotation + vertical flip\n",
    "        img_aug = tf.image.rot90(img_array[i], k=3).numpy()\n",
    "        img_aug = tf.image.flip_up_down(img_aug).numpy()\n",
    "        img_array_full[6,i] = img_aug\n",
    "\n",
    "        # Augmentation number 7: 90° rotation + horizontal flip\n",
    "        img_aug = tf.image.rot90(img_array[i], k=3).numpy()\n",
    "        img_aug = tf.image.flip_left_right(img_aug).numpy()\n",
    "        img_array_full[7,i] = img_aug\n",
    "\n",
    "        # Augmentation number 8: 270° rotation + vertical flip +\n",
    "        # horizontal flip\n",
    "        img_aug = tf.image.rot90(img_array[i], k=3).numpy()\n",
    "        img_aug = tf.image.flip_up_down(img_aug).numpy()\n",
    "        img_aug = tf.image.flip_left_right(img_aug).numpy()\n",
    "        img_array_full[8,i] = img_aug\n",
    "\n",
    "        # Augmentation number 9: vertical flip + horizontal flip\n",
    "        img_aug = tf.image.flip_up_down(img_array[i]).numpy()\n",
    "        img_aug = tf.image.flip_left_right(img_aug).numpy()\n",
    "        img_array_full[9,i] = img_aug\n",
    "\n",
    "        # Augmentation number 10: vertical flip\n",
    "        img_aug = tf.image.flip_up_down(img_array[i]).numpy()\n",
    "        img_array_full[10,i] = img_aug\n",
    "\n",
    "        # Augmentation number 11: horizontal flip\n",
    "        img_aug = tf.image.flip_left_right(img_array[i]).numpy()\n",
    "        img_array_full[11,i] = img_aug\n",
    "\n",
    "        # Report progress\n",
    "        if (i+1) == img_array.shape[0]:\n",
    "            print(' - ' + str(100) + \n",
    "                '% of all images have been augmented.')\n",
    "        elif (i%100 == 0) & (i != 0):\n",
    "            print(' - ' + str(round(100*i/img_array.shape[0])) + \n",
    "                '% of all images have been augmented.')\n",
    "        elif (i%10 == 0) & (i != 0):\n",
    "            print('.', end='')\n",
    "        \n",
    "    # Return the augmented dataset\n",
    "    return img_array_full\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let´s use the function for augmentation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Started the augmentation of the spectral training images\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-10-10 17:08:39.897235: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:981] 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",
      "2023-10-10 17:08:39.897713: W tensorflow/core/common_runtime/gpu/gpu_device.cc:1960] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.\n",
      "Skipping registering GPU devices...\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "......... - 7% of all images have been augmented.\n",
      "......... - 15% of all images have been augmented.\n",
      "......... - 22% of all images have been augmented.\n",
      "......... - 29% of all images have been augmented.\n",
      "......... - 37% of all images have been augmented.\n",
      "......... - 44% of all images have been augmented.\n",
      "......... - 51% of all images have been augmented.\n",
      "......... - 59% of all images have been augmented.\n",
      "......... - 66% of all images have been augmented.\n",
      "......... - 74% of all images have been augmented.\n",
      "......... - 81% of all images have been augmented.\n",
      "......... - 88% of all images have been augmented.\n",
      "......... - 96% of all images have been augmented.\n",
      "..... - 100% of all images have been augmented.\n",
      "Finished the augmentation of the spectral training images\n",
      "\n",
      "\n",
      "Started the augmentation of the vegetation height training images\n",
      "......... - 7% of all images have been augmented.\n",
      "......... - 15% of all images have been augmented.\n",
      "......... - 22% of all images have been augmented.\n",
      "......... - 29% of all images have been augmented.\n",
      "......... - 37% of all images have been augmented.\n",
      "......... - 44% of all images have been augmented.\n",
      "......... - 51% of all images have been augmented.\n",
      "......... - 59% of all images have been augmented.\n",
      "......... - 66% of all images have been augmented.\n",
      "......... - 74% of all images have been augmented.\n",
      "......... - 81% of all images have been augmented.\n",
      "......... - 88% of all images have been augmented.\n",
      "......... - 96% of all images have been augmented.\n",
      "..... - 100% of all images have been augmented.\n",
      "Finished the augmentation of the vegetation height training images\n",
      "\n",
      "\n",
      "Started the \"augmentation\" of the slope training data\n",
      "Finished the augmentation of the slope training data\n",
      "\n",
      "\n",
      "Started the \"augmentation\" of the altitude training data\n",
      "Finished the \"augmentation\" of the altitude training data\n",
      "\n",
      "\n",
      "Started the \"augmentation\" of the label training data\n",
      "Finished the \"augmentation\" of the label training data\n"
     ]
    }
   ],
   "source": [
    "# Augment spectral data\n",
    "print('Started the augmentation of the spectral training images')\n",
    "train_spec_aug = augment_images(train_spec)\n",
    "train_spec_aug = np.reshape(train_spec_aug, (-1, train_spec.shape[1], train_spec.shape[2], train_spec.shape[3]))\n",
    "print('Finished the augmentation of the spectral training images')\n",
    "\n",
    "# Augment height data (you need to add a singular channel dimension\n",
    "# as tensorflow's augmentation functions will not function otherwise)\n",
    "print('\\n\\nStarted the augmentation of the vegetation height training images')\n",
    "train_height_aug = augment_images(train_height[:,:,:,np.newaxis])\n",
    "train_height_aug = np.reshape(train_height_aug, (-1, train_height.shape[1], train_height.shape[2], 1))\n",
    "print('Finished the augmentation of the vegetation height training images')\n",
    "\n",
    "# Augment slope data\n",
    "print('\\n\\nStarted the \"augmentation\" of the slope training data')\n",
    "train_slope_aug = np.tile(train_slope, (12,1))\n",
    "train_slope_aug = np.reshape(train_slope_aug, (-1))\n",
    "print('Finished the augmentation of the slope training data')\n",
    "\n",
    "# Augment altitude data\n",
    "print('\\n\\nStarted the \"augmentation\" of the altitude training data')\n",
    "train_altitude_aug = np.tile(train_altitude, (12,1))\n",
    "train_altitude_aug = np.reshape(train_altitude_aug, (-1))\n",
    "print('Finished the \"augmentation\" of the altitude training data')\n",
    "\n",
    "# Augment label data\n",
    "print('\\n\\nStarted the \"augmentation\" of the label training data')\n",
    "train_lbl_aug = np.tile(train_lbl, (12,1))\n",
    "train_lbl_aug = np.reshape(train_lbl_aug, (-1))\n",
    "print('Finished the \"augmentation\" of the label training data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deal with class imbalance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have highly imbalanced data with 55% beech trees dominating the dataset, we explored different approaches to deal with imbalanced data. We tested and compared:\n",
    "- Weighted classes\n",
    "- Oversampling\n",
    "- Undersampling\n",
    "\n",
    "**Oversampling** worked best for our data as there are not enough data overall to perform undersampling. In addition, it seemed that adding weighted classes introduced a further bias that did not diminish the previous bias of a data imbalance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we will randomly draw from the pool of original and augemented images to increase the sample sizes of the minorty classes, until the same size as for the majority class is reached."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the frequency of each class in the data\n",
    "_, n_all = np.unique(train_lbl_aug, return_counts=True)\n",
    "\n",
    "# Determine the class with the most data\n",
    "n_max = np.max(n_all)\n",
    "\n",
    "# Generate a new array that will contain the over-sampled results\n",
    "train_spec_ao = train_spec_aug.copy()\n",
    "train_height_ao = train_height_aug.copy()\n",
    "train_slope_ao = train_slope_aug.copy()\n",
    "train_altitude_ao = train_altitude_aug.copy()\n",
    "train_lbl_ao = train_lbl_aug.copy()\n",
    "\n",
    "# Loop through all class categories\n",
    "for i in range(len(n_all)):\n",
    "\n",
    "    # Extract the frequency of this class\n",
    "    n_class = n_all[i]\n",
    "\n",
    "    # Execute this code if this is not the class with the highest\n",
    "    # frequency\n",
    "    if (n_class < n_max):\n",
    "\n",
    "        # Extract only data of this class\n",
    "        class_spec = train_spec_aug[train_lbl_aug == i]\n",
    "        class_height = train_height_aug[train_lbl_aug == i]\n",
    "        class_slope = train_slope_aug[train_lbl_aug == i]\n",
    "        class_altitude = train_altitude_aug[train_lbl_aug == i]\n",
    "        class_lbl = train_lbl_aug[train_lbl_aug == i]\n",
    "\n",
    "        # Generate as many random integers as there are in the class\n",
    "        # category with the highest frequency minus the number of already\n",
    "        # existing images for this class category\n",
    "        rand_ind = np.random.randint(0, len(class_lbl)-1, n_max - n_class)\n",
    "\n",
    "        # Draw random data from the existing data\n",
    "        rand_spec = class_spec[rand_ind,:,:,:]\n",
    "        rand_height = class_height[rand_ind,:,:,:]\n",
    "        rand_slope = class_slope[rand_ind]\n",
    "        rand_altitude = class_altitude[rand_ind]\n",
    "        rand_lbl = class_lbl[rand_ind]\n",
    "\n",
    "        # Append data to its respective array\n",
    "        train_spec_ao = np.append(train_spec_ao, rand_spec, axis=0)\n",
    "        train_height_ao = np.append(train_height_ao, rand_height, axis=0)\n",
    "        train_slope_ao = np.append(train_slope_ao, rand_slope, axis=0)\n",
    "        train_altitude_ao = np.append(train_altitude_ao, rand_altitude, axis=0)  \n",
    "        train_lbl_ao = np.append(train_lbl_ao, rand_lbl, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One hot encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# One hot encode the labels\n",
    "train_lbl_ao_ohe = tf.keras.utils.to_categorical(train_lbl_ao)\n",
    "test_lbl_ohe = tf.keras.utils.to_categorical(test_lbl)\n",
    "val_lbl_ohe = tf.keras.utils.to_categorical(val_lbl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the Ensemble Convolutional Neural Network Model\n",
    "\n",
    "We will create en ensemble model, that combines different convolutional neural networks for different parts of the data into one. There will be one convolutional neural network for the spectral images and one for the images of the vegetation height. Slope and altitude information will be added as auxiliary information that is not processed by a convolutional neural network. All models and information are eventually fed to a dense network which results in the categorization of the information in either of the four tree species categories.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 1: Define a convolutional neural network for the spectral data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_spec\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 38, 38, 4)]       0         \n",
      "                                                                 \n",
      " conv2d (Conv2D)             (None, 36, 36, 32)        1184      \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2  (None, 18, 18, 32)        0         \n",
      " D)                                                              \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 18, 18, 32)        0         \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 16, 16, 64)        18496     \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPoolin  (None, 8, 8, 64)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 8, 8, 64)          0         \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 6, 6, 128)         73856     \n",
      "                                                                 \n",
      " max_pooling2d_2 (MaxPoolin  (None, 3, 3, 128)         0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " dropout_2 (Dropout)         (None, 3, 3, 128)         0         \n",
      "                                                                 \n",
      " conv2d_3 (Conv2D)           (None, 1, 1, 256)         295168    \n",
      "                                                                 \n",
      " dropout_3 (Dropout)         (None, 1, 1, 256)         0         \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 256)               0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 388704 (1.48 MB)\n",
      "Trainable params: 388704 (1.48 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Create the input layer\n",
    "input_spec = tf.keras.layers.Input(shape=(train_spec_ao.shape[1], train_spec_ao.shape[2], train_spec_ao.shape[3]))\n",
    "\n",
    "# Create layer 1\n",
    "conv1_spec = tf.keras.layers.Conv2D(filters=32, kernel_size=[3,3], activation='relu')(input_spec)\n",
    "pool1_spec = tf.keras.layers.MaxPooling2D(pool_size=[2,2])(conv1_spec)\n",
    "drop1_spec = tf.keras.layers.Dropout(0.2)(pool1_spec)\n",
    "\n",
    "# Create layer 2\n",
    "conv2_spec = tf.keras.layers.Conv2D(filters=64, kernel_size=[3,3], activation='relu')(drop1_spec)\n",
    "pool2_spec = tf.keras.layers.MaxPooling2D(pool_size=[2,2])(conv2_spec)\n",
    "drop2_spec = tf.keras.layers.Dropout(0.4)(pool2_spec)\n",
    "\n",
    "# Create layer 3\n",
    "conv3_spec = tf.keras.layers.Conv2D(filters=128, kernel_size=[3,3], activation='relu')(drop2_spec)\n",
    "pool3_spec = tf.keras.layers.MaxPooling2D(pool_size=[2,2])(conv3_spec)\n",
    "drop3_spec = tf.keras.layers.Dropout(0.4)(pool3_spec)\n",
    "\n",
    "# Create layer 4\n",
    "conv4_spec = tf.keras.layers.Conv2D(filters=256, kernel_size=[3,3], activation='relu')(drop3_spec)\n",
    "drop4_spec = tf.keras.layers.Dropout(0.2)(conv4_spec)\n",
    "\n",
    "# Create the final flat layer\n",
    "flat1_spec = tf.keras.layers.Flatten()(drop4_spec)\n",
    "\n",
    "# Create a model from this structure\n",
    "model_spec = tf.keras.Model(input_spec, flat1_spec, name=\"model_spec\")\n",
    "\n",
    "# Show the structure of this model\n",
    "model_spec.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 2: Define a convolutional neural network for the vegetation height data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_height\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_2 (InputLayer)        [(None, 10, 10, 1)]       0         \n",
      "                                                                 \n",
      " conv2d_4 (Conv2D)           (None, 8, 8, 32)          320       \n",
      "                                                                 \n",
      " max_pooling2d_3 (MaxPoolin  (None, 4, 4, 32)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " dropout_4 (Dropout)         (None, 4, 4, 32)          0         \n",
      "                                                                 \n",
      " conv2d_5 (Conv2D)           (None, 2, 2, 64)          18496     \n",
      "                                                                 \n",
      " max_pooling2d_4 (MaxPoolin  (None, 1, 1, 64)          0         \n",
      " g2D)                                                            \n",
      "                                                                 \n",
      " dropout_5 (Dropout)         (None, 1, 1, 64)          0         \n",
      "                                                                 \n",
      " flatten_1 (Flatten)         (None, 64)                0         \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 18816 (73.50 KB)\n",
      "Trainable params: 18816 (73.50 KB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Create the input layer\n",
    "input_height = tf.keras.layers.Input(shape=(train_height_ao.shape[1],train_height_ao.shape[2], train_height_ao.shape[3]))\n",
    "\n",
    "# Create layer 1\n",
    "conv1_height = tf.keras.layers.Conv2D(filters=32, kernel_size=[3,3], activation='relu')(input_height)\n",
    "pool1_height = tf.keras.layers.MaxPooling2D(pool_size=[2,2])(conv1_height)\n",
    "drop1_height = tf.keras.layers.Dropout(0.4)(pool1_height)\n",
    "\n",
    "# Create layer 2\n",
    "conv2_height = tf.keras.layers.Conv2D(filters=64, kernel_size=[3,3], activation='relu')(drop1_height)\n",
    "pool2_height = tf.keras.layers.MaxPooling2D(pool_size=[2,2])(conv2_height)\n",
    "drop2_height = tf.keras.layers.Dropout(0.4)(pool2_height)\n",
    "\n",
    "# Create the final flat layer\n",
    "flat1_height = tf.keras.layers.Flatten()(drop2_height)\n",
    "\n",
    "# Create a model from this structure\n",
    "model_height = tf.keras.Model(input_height, flat1_height, name=\"model_height\")\n",
    "\n",
    "# Show the structure of this model\n",
    "model_height.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 3: Define a model input for additional variables that are no images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combine the variables into one array\n",
    "train_aux_ao = np.vstack([train_slope_ao, train_altitude_ao]).T\n",
    "test_aux = np.vstack([test_slope, test_altitude]).T\n",
    "val_aux = np.vstack([val_slope, val_altitude]).T\n",
    "\n",
    "# Create an input layer for auxiliary variables that are directly attached\n",
    "# to the dense layer\n",
    "input_aux = tf.keras.layers.Input(shape=(2,))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 4: Combine all models into one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_speight\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)        [(None, 38, 38, 4)]          0         []                            \n",
      "                                                                                                  \n",
      " conv2d (Conv2D)             (None, 36, 36, 32)           1184      ['input_1[0][0]']             \n",
      "                                                                                                  \n",
      " max_pooling2d (MaxPooling2  (None, 18, 18, 32)           0         ['conv2d[0][0]']              \n",
      " D)                                                                                               \n",
      "                                                                                                  \n",
      " dropout (Dropout)           (None, 18, 18, 32)           0         ['max_pooling2d[0][0]']       \n",
      "                                                                                                  \n",
      " conv2d_1 (Conv2D)           (None, 16, 16, 64)           18496     ['dropout[0][0]']             \n",
      "                                                                                                  \n",
      " max_pooling2d_1 (MaxPoolin  (None, 8, 8, 64)             0         ['conv2d_1[0][0]']            \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " input_2 (InputLayer)        [(None, 10, 10, 1)]          0         []                            \n",
      "                                                                                                  \n",
      " dropout_1 (Dropout)         (None, 8, 8, 64)             0         ['max_pooling2d_1[0][0]']     \n",
      "                                                                                                  \n",
      " conv2d_4 (Conv2D)           (None, 8, 8, 32)             320       ['input_2[0][0]']             \n",
      "                                                                                                  \n",
      " conv2d_2 (Conv2D)           (None, 6, 6, 128)            73856     ['dropout_1[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_3 (MaxPoolin  (None, 4, 4, 32)             0         ['conv2d_4[0][0]']            \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " max_pooling2d_2 (MaxPoolin  (None, 3, 3, 128)            0         ['conv2d_2[0][0]']            \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " dropout_4 (Dropout)         (None, 4, 4, 32)             0         ['max_pooling2d_3[0][0]']     \n",
      "                                                                                                  \n",
      " dropout_2 (Dropout)         (None, 3, 3, 128)            0         ['max_pooling2d_2[0][0]']     \n",
      "                                                                                                  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " conv2d_5 (Conv2D)           (None, 2, 2, 64)             18496     ['dropout_4[0][0]']           \n",
      "                                                                                                  \n",
      " conv2d_3 (Conv2D)           (None, 1, 1, 256)            295168    ['dropout_2[0][0]']           \n",
      "                                                                                                  \n",
      " max_pooling2d_4 (MaxPoolin  (None, 1, 1, 64)             0         ['conv2d_5[0][0]']            \n",
      " g2D)                                                                                             \n",
      "                                                                                                  \n",
      " dropout_3 (Dropout)         (None, 1, 1, 256)            0         ['conv2d_3[0][0]']            \n",
      "                                                                                                  \n",
      " dropout_5 (Dropout)         (None, 1, 1, 64)             0         ['max_pooling2d_4[0][0]']     \n",
      "                                                                                                  \n",
      " flatten (Flatten)           (None, 256)                  0         ['dropout_3[0][0]']           \n",
      "                                                                                                  \n",
      " flatten_1 (Flatten)         (None, 64)                   0         ['dropout_5[0][0]']           \n",
      "                                                                                                  \n",
      " input_3 (InputLayer)        [(None, 2)]                  0         []                            \n",
      "                                                                                                  \n",
      " concatenate (Concatenate)   (None, 322)                  0         ['flatten[0][0]',             \n",
      "                                                                     'flatten_1[0][0]',           \n",
      "                                                                     'input_3[0][0]']             \n",
      "                                                                                                  \n",
      " dense (Dense)               (None, 64)                   20672     ['concatenate[0][0]']         \n",
      "                                                                                                  \n",
      " dropout_6 (Dropout)         (None, 64)                   0         ['dense[0][0]']               \n",
      "                                                                                                  \n",
      " dense_1 (Dense)             (None, 32)                   2080      ['dropout_6[0][0]']           \n",
      "                                                                                                  \n",
      " dropout_7 (Dropout)         (None, 32)                   0         ['dense_1[0][0]']             \n",
      "                                                                                                  \n",
      " dense_2 (Dense)             (None, 32)                   1056      ['dropout_7[0][0]']           \n",
      "                                                                                                  \n",
      " dropout_8 (Dropout)         (None, 32)                   0         ['dense_2[0][0]']             \n",
      "                                                                                                  \n",
      " dense_3 (Dense)             (None, 4)                    132       ['dropout_8[0][0]']           \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 431460 (1.65 MB)\n",
      "Trainable params: 431460 (1.65 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "# Concatenate all models from before\n",
    "cross_speight = tf.keras.layers.concatenate([flat1_spec, flat1_height, input_aux]) \n",
    "\n",
    "# Create the dense layer 1\n",
    "dens1_speight = tf.keras.layers.Dense(units=64, activation='relu')(cross_speight)\n",
    "drop1_speight = tf.keras.layers.Dropout(.2)(dens1_speight)\n",
    "\n",
    "# Create the dense layer 2\n",
    "dens2_speight = tf.keras.layers.Dense(units=32, activation='relu')(drop1_speight)\n",
    "drop2_speight = tf.keras.layers.Dropout(.4)(dens2_speight)\n",
    "\n",
    "# Create the dense layer 3\n",
    "dens3_speight = tf.keras.layers.Dense(units=32, activation='relu')(drop2_speight)\n",
    "drop3_speight = tf.keras.layers.Dropout(.2)(dens3_speight)\n",
    "\n",
    "# Create the output layer with four units as there are four tree species\n",
    "# that need to be predicted\n",
    "output_speight = tf.keras.layers.Dense(units=4, activation='softmax')(drop3_speight)\n",
    "\n",
    "# Create the final model\n",
    "model_speight = tf.keras.models.Model(inputs=[input_spec, input_height, input_aux], outputs=output_speight, name=\"model_speight\")\n",
    "\n",
    "# Show the structure of this model\n",
    "model_speight.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 5: Compile and fit the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1134/1134 [==============================] - 43s 37ms/step - loss: 1.2382 - categorical_accuracy: 0.4516 - val_loss: 1.2034 - val_categorical_accuracy: 0.5000\n",
      "Epoch 2/10\n",
      "1134/1134 [==============================] - 35s 31ms/step - loss: 1.1687 - categorical_accuracy: 0.5203 - val_loss: 1.1537 - val_categorical_accuracy: 0.4882\n",
      "Epoch 3/10\n",
      "1134/1134 [==============================] - 35s 31ms/step - loss: 1.1381 - categorical_accuracy: 0.5340 - val_loss: 1.2196 - val_categorical_accuracy: 0.4941\n",
      "Epoch 4/10\n",
      "1134/1134 [==============================] - 35s 31ms/step - loss: 1.1150 - categorical_accuracy: 0.5520 - val_loss: 1.1801 - val_categorical_accuracy: 0.5294\n",
      "Epoch 5/10\n",
      "1134/1134 [==============================] - 34s 30ms/step - loss: 1.0899 - categorical_accuracy: 0.5723 - val_loss: 1.1200 - val_categorical_accuracy: 0.5353\n",
      "Epoch 6/10\n",
      "1134/1134 [==============================] - 35s 31ms/step - loss: 1.0723 - categorical_accuracy: 0.5897 - val_loss: 1.1128 - val_categorical_accuracy: 0.5588\n",
      "Epoch 7/10\n",
      "1134/1134 [==============================] - 35s 31ms/step - loss: 1.0536 - categorical_accuracy: 0.6036 - val_loss: 1.0975 - val_categorical_accuracy: 0.5588\n",
      "Epoch 8/10\n",
      "1134/1134 [==============================] - 37s 33ms/step - loss: 1.0319 - categorical_accuracy: 0.6222 - val_loss: 1.0820 - val_categorical_accuracy: 0.5471\n",
      "Epoch 9/10\n",
      "1134/1134 [==============================] - 39s 34ms/step - loss: 1.0136 - categorical_accuracy: 0.6385 - val_loss: 1.1128 - val_categorical_accuracy: 0.5294\n",
      "Epoch 10/10\n",
      "1134/1134 [==============================] - 35s 31ms/step - loss: 0.9983 - categorical_accuracy: 0.6482 - val_loss: 1.0827 - val_categorical_accuracy: 0.5765\n"
     ]
    }
   ],
   "source": [
    "# Compile the model\n",
    "model_speight.compile(\\\n",
    "    optimizer=tf.keras.optimizers.RMSprop(),\n",
    "    loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing = 0.1),\n",
    "    metrics=['categorical_accuracy'])\n",
    "\n",
    "# Fit the model\n",
    "history_speight = model_speight.fit(\\\n",
    "    x=[train_spec_ao, train_height_ao, train_aux_ao],\n",
    "    y=train_lbl_ao_ohe,\n",
    "    epochs=10,\n",
    "    validation_data=([test_spec, test_height, test_aux], test_lbl_ohe))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the loss function\n",
    "fig, ax = plt.subplots(1, 1, figsize=(10,6))\n",
    "ax.plot(history_speight.history['loss'], 'r', label='train')\n",
    "ax.plot(history_speight.history['val_loss'], 'b' ,label='val')\n",
    "ax.set_xlabel(r'Epoch', fontsize=20)\n",
    "ax.set_ylabel(r'Loss', fontsize=20)\n",
    "ax.legend()\n",
    "ax.tick_params(labelsize=20)\n",
    "\n",
    "# Plot the accuracy\n",
    "fig, ax = plt.subplots(1, 1, figsize=(10,6))\n",
    "ax.plot(history_speight.history[\"categorical_accuracy\"], 'r', label='train')\n",
    "ax.plot(history_speight.history['val_categorical_accuracy'], 'b' ,label='val')\n",
    "ax.set_xlabel(r'Epoch', fontsize=20)\n",
    "ax.set_ylabel(r'Accuracy', fontsize=20)\n",
    "ax.legend()\n",
    "ax.tick_params(labelsize=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part 6: Show the results of the ensemble model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6/6 [==============================] - 0s 9ms/step - loss: 1.1046 - categorical_accuracy: 0.5906\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1.1045669317245483, 0.5906432867050171]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Evaluate the performance of the model\n",
    "model_speight.evaluate(x=[val_spec, val_height, val_aux], y=val_lbl_ohe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict from fitted model\n",
    "predictions = model_speight.predict([val_spec, val_height, val_aux], verbose=0)\n",
    "predicted_labels = np.argmax(predictions, axis=1)\n",
    "\n",
    "# Calculate class percentages\n",
    "class_percentages = np.unique(val_lbl, return_counts=True)[1]/len(val_lbl_ohe) * 100\n",
    "\n",
    "# Calculate predicted class percentages\n",
    "pred_class_percentages = np.unique(predicted_labels, return_counts=True)[1]/len(predicted_labels) * 100\n",
    "\n",
    "# Define class names\n",
    "CLASS_NAMES = ['Other', 'Rotbuche','Berg-Ahorn','Haenge-Birke']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let´s compare the actural proportions of each class in the original data versus the predicted proportions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual proportions\n",
      "Other: 23.98%\n",
      "Rotbuche: 55.56%\n",
      "Berg-Ahorn: 14.62%\n",
      "Haenge-Birke: 5.85%\n",
      "\n",
      "\n",
      "Predicted proportions\n",
      "Other: 18.13%\n",
      "Rotbuche: 50.29%\n",
      "Berg-Ahorn: 11.11%\n",
      "Haenge-Birke: 20.47%\n"
     ]
    }
   ],
   "source": [
    "print('Actual proportions')\n",
    "# Look at class percentages\n",
    "for class_name, percentage in zip(CLASS_NAMES, class_percentages):\n",
    "    print(f'{class_name}: {percentage:.2f}%')\n",
    "\n",
    "print('\\n')\n",
    "print('Predicted proportions')\n",
    "# Look at predicted class percentages\n",
    "for class_name, percentage in zip(CLASS_NAMES, pred_class_percentages):\n",
    "    print(f'{class_name}: {percentage:.2f}%')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "# Create matrix\n",
    "confusion = confusion_matrix(val_lbl, predicted_labels)\n",
    "\n",
    "# Plot confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(confusion, annot=True, fmt=\"d\", cmap=\"Blues\",\n",
    "            xticklabels=CLASS_NAMES, yticklabels=CLASS_NAMES)\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "       Other       0.39      0.29      0.33        41\n",
      "    Rotbuche       0.86      0.78      0.82        95\n",
      "  Berg-Ahorn       0.42      0.32      0.36        25\n",
      "Haenge-Birke       0.20      0.70      0.31        10\n",
      "\n",
      "    accuracy                           0.59       171\n",
      "   macro avg       0.47      0.52      0.46       171\n",
      "weighted avg       0.64      0.59      0.61       171\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Classification report\n",
    "report = classification_report(val_lbl, predicted_labels, target_names=CLASS_NAMES)\n",
    "print(report)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional information"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How well does the trained model work on other datasets?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we test how well our fitted model (that was trained on the data from 2022) can be transferred to another data set.\n",
    "As an example, we test our fitted model for the data from 2018."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the path to the data file\n",
    "data_path = '../images/box_images/baseline/model_images.npz'\n",
    "\n",
    "# Load the image array containing all box images in a 4D array and their\n",
    "# labels\n",
    "with np.load(data_path, allow_pickle=True) as data:\n",
    "    img_array = data[\"img_array\"]\n",
    "    labels = data[\"labels\"]\n",
    "\n",
    "# Extract only none nan values from the year 2018 \n",
    "img_array = img_array[:,0:1701,:,:,:]\n",
    "img_array = np.reshape(img_array[[2,2,2,2,2],:,:,:,:], (-1,35,35,4)) ## 2 refers to 2018\n",
    "height_array = np.reshape(height_array, (-1,11,11))\n",
    "label_array = np.reshape(labels[:,0:1701], (-1))\n",
    "\n",
    "# As tensorflow prefers integers compared to strings as target values, we \n",
    "# transform our labels array. As a first step, create a new array that\n",
    "# looks exactly like labels but is filled with zeros\n",
    "labels_int = np.zeros_like(label_array)\n",
    "\n",
    "# Loop through each label\n",
    "for i in range(len(label_array)):\n",
    "    \n",
    "    # Assign a 1 if it is a Rotbuche\n",
    "    if label_array[i] == 'Rotbuche':\n",
    "        labels_int[i] = 1\n",
    "\n",
    "    # Assign a 2 if it is a Berg-Ahorn    \n",
    "    elif label_array[i] == 'Berg-Ahorn':\n",
    "        labels_int[i] = 2\n",
    "\n",
    "    # Assign a 3 if it is a Haenge-Birke    \n",
    "    elif label_array[i] == 'Haenge-Birke':\n",
    "        labels_int[i] = 3\n",
    "    \n",
    "# As the array is still of type \"obj\", we need to change it to \"int\"\n",
    "labels_int = labels_int.astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.unique(labels_int, return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict from fitted model\n",
    "predictions = model_speight.predict([img_array, height_array], verbose=0)\n",
    "predicted_labels = np.argmax(predictions, axis=1)\n",
    "\n",
    "# Calculate class percentages\n",
    "class_percentages = np.unique(labels_int, return_counts=True)[1]/len(labels_int) * 100\n",
    "\n",
    "# Calculate predicted class percentages\n",
    "pred_class_percentages = np.unique(predicted_labels, return_counts=True)[1]/len(predicted_labels) * 100\n",
    "\n",
    "# Define class names\n",
    "CLASS_NAMES = ['Other', 'Rotbuche','Ahorn','Birke'] # Stimmt die Reihenfolge, Alex?\n",
    "\n",
    "print('Actual proportions')\n",
    "# Look at class percentages\n",
    "for class_name, percentage in zip(CLASS_NAMES, class_percentages):\n",
    "    print(f'{class_name}: {percentage:.2f}%')\n",
    "\n",
    "print('\\n')\n",
    "print('Predicted proportions')\n",
    "# Look at predicted class percentages\n",
    "for class_name, percentage in zip(CLASS_NAMES, pred_class_percentages):\n",
    "    print(f'{class_name}: {percentage:.2f}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(labels_int == predicted_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "# Create matrix\n",
    "confusion = confusion_matrix(np.reshape(labels_int, (5,-1))[1,:], np.reshape(predicted_labels, (5,-1))[1,:])\n",
    "\n",
    "# Plot confusion matrix\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(confusion, annot=True, fmt=\"d\", cmap=\"Blues\",\n",
    "            xticklabels=CLASS_NAMES, yticklabels=CLASS_NAMES)\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('True')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hyper parameter search for a CNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One possibility to find the optimal hyper parameters for a model is to use the hyper parameter tuner. We used it, inter alia, to tune the kernel_initializer, the learning rate as well as the filter and dropout rates. We used the hyperband tuning algorithm, which uses adaptive resource allocation and early-stopping to quickly converge on a high-performing model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Toolbox for hyperparameter tuning\n",
    "from kerastuner import Hyperband\n",
    "from kerastuner.engine.hyperparameters import HyperParameters\n",
    "\n",
    "# Create a callback to stop training early after reaching a certain value for the validation loss.\n",
    "stop_early = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have identified a good CNN structure, so we will use this here. \n",
    "As the Keras Tuner cannot work with Pooling layers, so they are not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the  model function\n",
    "def model_builder(hp):\n",
    "    model = tf.keras.models.Sequential()\n",
    "\n",
    "    model.add(tf.keras.layers.InputLayer(input_shape=[35,35,4]))\n",
    "    model.add(tf.keras.layers.Rescaling(1/((2**16)-1)))\n",
    "\n",
    "\n",
    "    hp_filters1 = hp.Choice('filters1', values=[16, 32, 64]) #32 is best\n",
    "    hp_dropout1 = hp.Choice('dropout1', values = [0.0, 0.2, 0.4])\n",
    "    hp_initializer1 = hp.Choice('initializer1', values = ['uniform', 'he_normal','random_normal', 'he_uniform'])\n",
    "    model.add(tf.keras.layers.Conv2D(filters=hp_filters1, kernel_size=[3, 3], strides=2, kernel_initializer= hp_initializer1, activation='relu'))\n",
    "    model.add(tf.keras.layers.Dropout(hp_dropout1))\n",
    "\n",
    "    hp_filters2 = hp.Choice('filters2', values=[64, 128, 256]) #128 is best\n",
    "    hp_dropout2 = hp.Choice('dropout2', values = [0.3, 0.4, 0.5])\n",
    "    model.add(tf.keras.layers.Conv2D(filters=hp_filters2, kernel_size=[3, 3], strides=2, kernel_initializer='uniform', activation='relu'))\n",
    "    model.add(tf.keras.layers.Dropout(hp_dropout2))\n",
    "\n",
    "    hp_filters3 = hp.Choice('filters3', values=[64, 128, 256]) #128 is best\n",
    "    hp_dropout3 = hp.Choice('dropout3', values = [ 0.0, 0.2, 0.4])\n",
    "    model.add(tf.keras.layers.Conv2D(filters=hp_filters3, kernel_size=[3,3], activation='relu'))\n",
    "    model.add(tf.keras.layers.Dropout(hp_dropout3))\n",
    "\n",
    "\n",
    "    model.add(tf.keras.layers.Flatten())\n",
    "\n",
    "    hp_filters4 = hp.Choice('filters4', values=[16, 32, 64])\n",
    "    hp_dropout4 = hp.Choice('dropout4', values = [ 0.0, 0.2, 0.4])\n",
    "    model.add(tf.keras.layers.Dense(units=hp_filters4, activation='relu'))\n",
    "    model.add(tf.keras.layers.Dropout(hp_dropout4))\n",
    "\n",
    "    model.add(tf.keras.layers.Dense(units=4, activation='softmax')) \n",
    "\n",
    "\n",
    "    # Tune the learning rate for the optimizer\n",
    "    hp_learning_rate = hp.Choice('learning_rate', values=[0.01, 0.001, 0.0001])\n",
    "\n",
    "    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=hp_learning_rate),\n",
    "            loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "            metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyperband determines the number of models to train in a bracket by \n",
    "# computing 1 + log factor(max_epochs) and rounding it up to the nearest integer.\n",
    "tuner = kt.Hyperband(model_builder,\n",
    "                    objective='val_accuracy',\n",
    "                    max_epochs=70,\n",
    "                    factor=3,\n",
    "                    directory='../data',\n",
    "                    project_name='CNN_test_initializer_v1') #always change from run to run, otherwise triggered exit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#tuner.search(img_train, label_train, epochs=70, validation_split=0.2, callbacks=[stop_early]) #for original train data\n",
    "tuner.search(img_os, label_os, epochs=10, validation_split=0.2, callbacks=[stop_early], verbose = 0) #for oversampled ata \n",
    "\n",
    "# get the optimal hyperparameters\n",
    "best_hps=tuner.get_best_hyperparameters(num_trials=1)[0]"
   ]
  }
 ],
 "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.11.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}