whistle_classifier.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classifying dolphin whistle sounds with a Convolutional Neural Network\n",
    "\n",
    "This jupyter notebook creates a model, trains it and evaluates it.\n",
    "\n",
    "This code is fully os-independent and fs-independent, so you don't have to worry whether you are running on a windows os or IOS or linux, they will all work. But do make sure you set up a virtual environment correctly before continuing.\n",
    "\n",
    "**NB: Something that might seem counter-intuitive at first is that all \"image shape\" parameters in tensorflow and keras expect tuples in (heigh, width) order and not (width, height) or (x, y) as it was previously coded in Josh's jupyter notebook. This file does not use x and y to avoid any confusion.**\n",
    " \n",
    "To understand why tensorflow expects (height, width) order and not the other way around read ahead: it has to do with the way nested loops and 2D arrays work. By convention, a 2D array has sub arrays lined up horizontally (as rows, or x). To loop through the 2D array we would do `for subarray in range(height)` (going down 2D array) then `for element in range(width)` (going across 2D array), effectively needing height, width in this order. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import relevant packages. Set up the virtual environment as specified in the README file to avoid \"dependency-hell\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if you installed all the dependencies already, ignore this block of code\n",
    "!pip3 install -r requirements.txt "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from pathlib import Path\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras import layers, models \n",
    "from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate Training, Validation and Test Datasets\n",
    "\n",
    "Here we generate training, validation datasets from the training data directory TRAIN_DATA_DIR and testing datasets from the testing data directory TEST_DATA_DIR\n",
    "\n",
    "Before running the following cell, change the relative paths to the folders on your machine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "TRAINING_DATA_DIR = Path(\"/Users/matteohe/Desktop/DA/full-dclde-imgs/training-data\")\n",
    "TEST_DATA_DIR = Path(\"/Users/matteohe/Desktop/DA/full-dclde-imgs/testing-data\")\n",
    "\n",
    "HEIGHT, WIDTH = 202, 413\n",
    "IMAGE_SHAPE = (HEIGHT, WIDTH) # target size in imagedatagenerators accept tuple of integers (height, width)\n",
    "VALIDATION_SPLIT = 0.20 # validation split from the training data set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default here is to keep the shuffle parameter to false, since it is pretty much pointless to shuffle the testing data as weights are not updated during the testing phase. But if you are testing something you should change it to true with the following caveat:\n",
    "\n",
    "**NB: If you change the shuffle option in test_generator code to true (in case a metric you want to test requires the order to be shuffled), be mindful of what you did and definitely change the code in the bottom of this file in the Evaluation section, more specifically: the truth labels will need to be collected in a different way than it is right now in the classification report and confusion matrix code blocks.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 4777 images belonging to 3 classes.\n",
      "Found 1193 images belonging to 3 classes.\n",
      "Found 2557 images belonging to 3 classes.\n"
     ]
    }
   ],
   "source": [
    "# create an imagedatagenerator object that helps split data into training and validation datasets\n",
    "train_datagen = ImageDataGenerator(rescale=1.0 / 255, validation_split=VALIDATION_SPLIT)\n",
    "\n",
    "# create the training data generator\n",
    "train_generator = train_datagen.flow_from_directory(\n",
    "    directory=TRAINING_DATA_DIR,\n",
    "    subset=\"training\",\n",
    "    shuffle=True,\n",
    "    target_size=IMAGE_SHAPE,\n",
    "    color_mode=\"grayscale\",\n",
    ")\n",
    "\n",
    "# create the validation data generator\n",
    "validation_generator = train_datagen.flow_from_directory(\n",
    "    directory=TRAINING_DATA_DIR,\n",
    "    subset=\"validation\",\n",
    "    shuffle=True,\n",
    "    target_size=IMAGE_SHAPE,\n",
    "    color_mode=\"grayscale\",\n",
    ")\n",
    "\n",
    "# create the testing data generator\n",
    "test_generator = ImageDataGenerator(rescale=1.0 / 255).flow_from_directory(\n",
    "    directory=TEST_DATA_DIR,\n",
    "    shuffle=False,\n",
    "    target_size=IMAGE_SHAPE,\n",
    "    color_mode=\"grayscale\",\n",
    ")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building a CNN model and stacking the layers\n",
    "\n",
    "This section is dedicated to creating CNN models. \\\n",
    "Run either one of model1 and model2.\n",
    "- Model 1 uses increasingly more filters further in the model. It also uses spatial dropout before the flattening layer to mitigate overfitting (written by Matteo)\n",
    "- Model 2 is the original one by Josh and Gemma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configurations code for the model. There are a lot of things still worth exploring with the following model code. One thing that can be done is experimenting with dropout layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "KERNEL_SIZE = (3, 3) # 3x3 is the optimal size of a kernel 3x3 as agreed by the computing community\n",
    "INPUT_SHAPE = (HEIGHT, WIDTH, 1) # the last channel is used to represent the shape of the pixels. if using rgb set to 3\n",
    "LAYERS = 16\n",
    "DROPOUT_RATE = 0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# instantiate model object\n",
    "model = models.Sequential()\n",
    "\n",
    "model.add(\n",
    "    layers.Conv2D(\n",
    "        filters=LAYERS,\n",
    "        kernel_size=KERNEL_SIZE,\n",
    "        activation=\"relu\",\n",
    "        input_shape=INPUT_SHAPE,\n",
    "    )\n",
    ")\n",
    "model.add(layers.BatchNormalization())\n",
    "model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=2))\n",
    "\n",
    "model.add(layers.Conv2D(filters=LAYERS * 2, kernel_size=KERNEL_SIZE, activation=\"relu\"))\n",
    "model.add(layers.BatchNormalization())\n",
    "model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=2))\n",
    "\n",
    "model.add(layers.Conv2D(filters=LAYERS * 4, kernel_size=KERNEL_SIZE, activation=\"relu\"))\n",
    "model.add(layers.BatchNormalization())\n",
    "model.add(layers.MaxPooling2D(pool_size=(2, 2), strides=2))\n",
    "\n",
    "model.add(layers.SpatialDropout2D(rate=DROPOUT_RATE))\n",
    "\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(units=LAYERS * 2, activation=\"relu\"))\n",
    "model.add(layers.BatchNormalization())\n",
    "model.add(layers.Dense(units=3, activation=\"softmax\"))  # three final outputs (3 species)\n",
    "\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " conv2d (Conv2D)             (None, 200, 411, 16)      160       \n",
      "                                                                 \n",
      " batch_normalization (BatchN  (None, 200, 411, 16)     64        \n",
      " ormalization)                                                   \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 100, 205, 16)     0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 98, 203, 16)       2320      \n",
      "                                                                 \n",
      " batch_normalization_1 (Batc  (None, 98, 203, 16)      64        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 49, 101, 16)      0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " conv2d_2 (Conv2D)           (None, 47, 99, 16)        2320      \n",
      "                                                                 \n",
      " batch_normalization_2 (Batc  (None, 47, 99, 16)       64        \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 74448)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 64)                4764736   \n",
      "                                                                 \n",
      " batch_normalization_3 (Batc  (None, 64)               256       \n",
      " hNormalization)                                                 \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 3)                 195       \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 4,770,179\n",
      "Trainable params: 4,769,955\n",
      "Non-trainable params: 224\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-04-06 10:43:26.071850: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    }
   ],
   "source": [
    "# instantiate model object\n",
    "model = models.Sequential()\n",
    "\n",
    "# Stack layers on the sequential base model\n",
    "model.add(layers.Conv2D(LAYERS, KERNEL_SIZE, activation=\"relu\", input_shape=INPUT_SHAPE))\n",
    "model.add(layers.BatchNormalization())\n",
    "model.add(layers.MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "model.add(layers.Conv2D(LAYERS, KERNEL_SIZE, activation=\"relu\"))\n",
    "model.add(layers.BatchNormalization())\n",
    "model.add(layers.MaxPooling2D(pool_size=(2, 2)))\n",
    "\n",
    "model.add(layers.Conv2D(LAYERS, KERNEL_SIZE, activation=\"relu\"))\n",
    "model.add(layers.BatchNormalization())\n",
    "\n",
    "# Add fully connected layers\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(64, activation=\"relu\"))\n",
    "model.add(layers.BatchNormalization())\n",
    "model.add(layers.Dense(3, activation=\"softmax\"))\n",
    "\n",
    "# print out summary of code\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training the CNN model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Configurations code for the CNN training process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compile model\n",
    "model.compile(\n",
    "    optimizer=\"adam\", \n",
    "    loss=\"categorical_crossentropy\",\n",
    "    metrics=[\"categorical_accuracy\"]\n",
    ")\n",
    "\n",
    "# Configurations\n",
    "STEP_SIZE_TRAIN = train_generator.n // train_generator.batch_size\n",
    "STEP_SIZE_VALID = validation_generator.n // validation_generator.batch_size\n",
    "NUM_EPOCHS = 11\n",
    "ES = EarlyStopping(\"val_loss\", mode=\"auto\", verbose=1, patience=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the network."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] training network for 11 epochs...\n",
      "Epoch 1/11\n",
      "149/149 [==============================] - 141s 944ms/step - loss: 0.5856 - categorical_accuracy: 0.7760 - val_loss: 2.4656 - val_categorical_accuracy: 0.3767\n",
      "Epoch 2/11\n",
      "149/149 [==============================] - 141s 943ms/step - loss: 0.1165 - categorical_accuracy: 0.9646 - val_loss: 2.6569 - val_categorical_accuracy: 0.4645\n",
      "Epoch 3/11\n",
      "149/149 [==============================] - 141s 948ms/step - loss: 0.0451 - categorical_accuracy: 0.9907 - val_loss: 1.8236 - val_categorical_accuracy: 0.5177\n",
      "Epoch 4/11\n",
      "149/149 [==============================] - 141s 946ms/step - loss: 0.0246 - categorical_accuracy: 0.9954 - val_loss: 3.9119 - val_categorical_accuracy: 0.5642\n",
      "Epoch 5/11\n",
      "149/149 [==============================] - 141s 944ms/step - loss: 0.0461 - categorical_accuracy: 0.9874 - val_loss: 1.5888 - val_categorical_accuracy: 0.5887\n",
      "Epoch 6/11\n",
      "149/149 [==============================] - 141s 945ms/step - loss: 0.0206 - categorical_accuracy: 0.9956 - val_loss: 1.8261 - val_categorical_accuracy: 0.5084\n",
      "Epoch 7/11\n",
      "149/149 [==============================] - 141s 946ms/step - loss: 0.0083 - categorical_accuracy: 0.9989 - val_loss: 1.3019 - val_categorical_accuracy: 0.6149\n",
      "Epoch 8/11\n",
      "149/149 [==============================] - 142s 950ms/step - loss: 0.0038 - categorical_accuracy: 0.9998 - val_loss: 1.1600 - val_categorical_accuracy: 0.6562\n",
      "Epoch 9/11\n",
      "149/149 [==============================] - 142s 955ms/step - loss: 0.0024 - categorical_accuracy: 1.0000 - val_loss: 1.0371 - val_categorical_accuracy: 0.6985\n",
      "Epoch 10/11\n",
      "149/149 [==============================] - 141s 946ms/step - loss: 0.0017 - categorical_accuracy: 1.0000 - val_loss: 0.9947 - val_categorical_accuracy: 0.7044\n",
      "Epoch 11/11\n",
      "149/149 [==============================] - 141s 948ms/step - loss: 0.0014 - categorical_accuracy: 1.0000 - val_loss: 1.0172 - val_categorical_accuracy: 0.7002\n"
     ]
    }
   ],
   "source": [
    "print(\"[INFO] training network for {} epochs...\".format(NUM_EPOCHS))\n",
    "fitted = model.fit(\n",
    "    train_generator,\n",
    "    steps_per_epoch=STEP_SIZE_TRAIN,\n",
    "    validation_data=validation_generator,\n",
    "    validation_steps=STEP_SIZE_VALID,\n",
    "    epochs=NUM_EPOCHS,\n",
    "    callbacks=[ES],\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluating the CNN model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validation and training accuracy history plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x15d766be0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Evalutate the network - use validation set\n",
    "accuracy = \"categorical_accuracy\"\n",
    "value_accuracy = \"val_categorical_accuracy\"\n",
    "plt.plot(fitted.history[accuracy], label=accuracy)\n",
    "plt.plot(fitted.history[value_accuracy], label=value_accuracy)\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.ylim([0, 1])\n",
    "plt.title(\"Validation and Training accuracy\")\n",
    "plt.legend(loc=\"lower right\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Validation and Training Loss History Plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x15d3f1b50>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Evalutate the network - use validation set\n",
    "plt.plot(fitted.history[\"loss\"], label=\"Training loss\")\n",
    "plt.plot(fitted.history[\"val_loss\"], label=\"Validation loss\")\n",
    "plt.title(\"Validation and Training loss\")\n",
    "plt.xlabel(\"Epoch\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Testing the model with the testing dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] Testing with test-dataset ...\n",
      "80/80 - 20s - loss: 0.5748 - categorical_accuracy: 0.8303 - 20s/epoch - 246ms/step\n",
      "Test accuracy is  0.8302698731422424\n",
      "Test loss is  0.5747528672218323\n"
     ]
    }
   ],
   "source": [
    "print(\"[INFO] Testing with test-dataset ...\")\n",
    "loss, acc = model.evaluate(test_generator, verbose=2)\n",
    "print(\"Test accuracy is \", acc)\n",
    "print(\"Test loss is \", loss)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification Report of the model\n",
    "\n",
    "NB: the code below this point will not work and will produce misleading results if the test data is shuffled in the test_generator code. If you did that please change the way you get the predicted labels. You will most likely need to collect them by iterating through the test_generator to get the labels from all the batches. Of course it would be easier if the batch size includes all the data at once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Classification Report...\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "  bottlenose       0.82      0.88      0.85       962\n",
      "      common       0.85      0.80      0.82       914\n",
      "melon-headed       0.83      0.80      0.81       681\n",
      "\n",
      "    accuracy                           0.83      2557\n",
      "   macro avg       0.83      0.83      0.83      2557\n",
      "weighted avg       0.83      0.83      0.83      2557\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Running Classification Report...\")\n",
    "test_generator.reset()\n",
    "# get the predicted scores for each class\n",
    "scores = model.predict(test_generator)\n",
    "# get the label with the highest prediction\n",
    "predicted_labels = scores.argmax(axis=1)\n",
    "# get ground truth labels from test_generator.classes\n",
    "true_labels = test_generator.classes\n",
    "\n",
    "# get species names\n",
    "species = dict((v,k) for k,v in (train_generator.class_indices).items())\n",
    "species_names = np.array(list(species.values()))\n",
    "\n",
    "print(\n",
    "    classification_report(\n",
    "        true_labels, \n",
    "        predicted_labels, \n",
    "        target_names = species_names)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix of the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x15d3dd490>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(true_labels, predicted_labels)\n",
    "display = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=species_names)\n",
    "display.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save\n",
    "The current naming format has been decided to be \"date-modelname\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "today = date.today()\n",
    "today = str(today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the trained model -> could save just the weights or the entire architecture\n",
    "model_name = \"-eric\"\n",
    "model.save(today + model_name + '.model')"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "2095d8fafee06d6eda80f440969be72fcf850039ccc5b044496e51994bf5fd0a"
  },
  "kernelspec": {
   "display_name": "Python 3.9.5 ('dolphin': venv)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}