animal_detection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install opencv-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import os\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import cv2\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "from tensorflow.keras.layers import Dense, Dropout, BatchNormalization, MaxPooling2D, GlobalAveragePooling2D, Conv2D \n",
    "from tensorflow.keras.models import Sequential, load_model, Model\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.applications import EfficientNetV2M, MobileNetV3Large\n",
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras.utils import plot_model\n",
    "from tensorflow.keras.callbacks import Callback\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow import keras\n",
    "from sklearn.metrics import classification_report, confusion_matrix,ConfusionMatrixDisplay\n",
    "\n",
    "\n",
    "DATA_PATH = './raw-img'\n",
    "SEED=42\n",
    "N_EPOCHS=10\n",
    "BATCH_SIZE=32\n",
    "INPUT_SIZE=(224, 224)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "keras.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_datagen = ImageDataGenerator(validation_split=0.20, rescale=1./255, \n",
    "horizontal_flip=True, rotation_range = 10, width_shift_range = 0.05, height_shift_range = 0.05, brightness_range = (0.8, 1.2))\n",
    "\n",
    "\n",
    "validation_datagen = ImageDataGenerator(validation_split=0.20, rescale=1./255)\n",
    "\n",
    "\n",
    "train_datagen_flow = train_datagen.flow_from_directory(DATA_PATH, target_size=INPUT_SIZE,                                                   \n",
    "batch_size=BATCH_SIZE, class_mode='sparse', subset='training', seed=SEED)\n",
    "\n",
    "val_datagen_flow = validation_datagen.flow_from_directory(DATA_PATH, target_size=INPUT_SIZE,batch_size=BATCH_SIZE, class_mode='sparse', subset='validation', seed=SEED, shuffle = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_datagen_flow.class_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val_datagen_flow.class_indices\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "images, labels = next(train_datagen_flow)\n",
    "images = images[:20]\n",
    "labels = labels[:20]\n",
    "cols = 5\n",
    "rows = int(len(images)/cols) + 1\n",
    "plt.figure(figsize=(30,20))\n",
    "index = 1\n",
    "for image, label in zip(images, labels):\n",
    "    plt.subplot(rows, cols, index)\n",
    "    plt.imshow(image)\n",
    "    plt.title(f'Class: {int(label)}', fontsize = 15);\n",
    "    index+=1\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(Conv2D(32, (3, 3), activation='relu',input_shape= INPUT_SIZE +(3,)))\n",
    "model.add(MaxPooling2D((2, 2)))\n",
    "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(MaxPooling2D((2, 2)))\n",
    "model.add(Conv2D(128, (3, 3), activation='relu'))\n",
    "model.add(MaxPooling2D((2, 2)))\n",
    "model.add(GlobalAveragePooling2D())\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(10, activation='softmax'))\n",
    "model.compile(loss = 'sparse_categorical_crossentropy', optimizer='adam',metrics =['acc'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_checkpoint = \"model_checkpoint.keras\"\n",
    "es_callback = keras.callbacks.EarlyStopping(monitor=\"val_loss\", min_delta=0, patience=5)\n",
    "\n",
    "modelckpt_callback = keras.callbacks.ModelCheckpoint(\n",
    "    monitor=\"val_loss\",\n",
    "    filepath=path_checkpoint,\n",
    "    verbose=1,\n",
    "    save_weights_only=False,\n",
    "    save_best_only=True,\n",
    ")\n",
    "\n",
    "history = model.fit(\n",
    "    train_datagen_flow,\n",
    "    epochs=N_EPOCHS,\n",
    "    validation_data=val_datagen_flow,\n",
    "    callbacks=[es_callback, modelckpt_callback],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_metrics(history, figure_name):\n",
    "\n",
    "    train = history.history[f'{figure_name}']\n",
    "    val = history.history[f'val_{figure_name}']\n",
    "\n",
    "    epochs = range(1, len(train) + 1)\n",
    "    plt.plot(epochs, train, label=f'Training {figure_name}', color='orange')\n",
    "    plt.plot(epochs, val, label=f'Validation {figure_name}')\n",
    "    plt.title(f'Training and Validation {figure_name}')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel(f'{figure_name}')\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "check_metrics(history, 'loss')\n",
    "check_metrics(history, 'acc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = ['cane', 'cavallo', 'elefante', 'farfalla','gallina','gatto','mucca', 'pecora','ragno', 'scoiattolo' ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = load_model(\"model_checkpoint.keras\")\n",
    "model.evaluate(val_datagen_flow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_indexes = []\n",
    "y_true_indexes = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(val_datagen_flow)):\n",
    "    x_test_batch, y_test_batch = val_datagen_flow[i]\n",
    "    y_pred_batch = model.predict(x_test_batch)\n",
    "    y_pred_index = np.argmax(y_pred_batch, axis = 1)\n",
    "    y_pred_indexes.append(y_pred_index)\n",
    "    y_true_indexes.append(y_test_batch)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true_indexes = np.concatenate(y_true_indexes)\n",
    "y_pred_indexes = np.concatenate(y_pred_indexes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = confusion_matrix(y_true_indexes, y_pred_indexes)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)\n",
    "disp.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(classification_report(y_true_indexes, y_pred_indexes, target_names = labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backbone = keras.applications.MobileNetV3Large(\n",
    "    include_top=False,\n",
    "    weights=\"imagenet\",\n",
    "    pooling='max',\n",
    "    include_preprocessing=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "backbone.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(backbone)\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(10, activation='softmax'))\n",
    "model.compile(loss = 'sparse_categorical_crossentropy', optimizer='adam',metrics =['acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_checkpoint = \"model_checkpoint_mobile_net_v3.keras\"\n",
    "es_callback = keras.callbacks.EarlyStopping(monitor=\"val_loss\", min_delta=0, patience=5)\n",
    "\n",
    "modelckpt_callback = keras.callbacks.ModelCheckpoint(\n",
    "    monitor=\"val_loss\",\n",
    "    filepath=path_checkpoint,\n",
    "    verbose=1,\n",
    "    save_weights_only=False,\n",
    "    save_best_only=True,\n",
    ")\n",
    "\n",
    "history_mobile_net = model.fit(\n",
    "    train_datagen_flow,\n",
    "    epochs=N_EPOCHS,\n",
    "    validation_data=val_datagen_flow,\n",
    "    callbacks=[es_callback, modelckpt_callback],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_metrics(history_mobile_net, 'loss')\n",
    "check_metrics(history_mobile_net, 'acc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = load_model(\"model_checkpoint_mobile_net_v3.keras\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(val_datagen_flow) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_indexes = []\n",
    "y_true_indexes = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(val_datagen_flow)):\n",
    "    x_test_batch, y_test_batch = val_datagen_flow[i]\n",
    "    y_pred_batch = model.predict(x_test_batch)\n",
    "    y_pred_index = np.argmax(y_pred_batch, axis = 1)\n",
    "    y_pred_indexes.append(y_pred_index)\n",
    "    y_true_indexes.append(y_test_batch)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_indexes = np.concatenate(y_pred_indexes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_true_indexes = np.concatenate(y_true_indexes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = confusion_matrix(y_true_indexes, y_pred_indexes)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)\n",
    "disp.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(classification_report(y_true_indexes, y_pred_indexes, target_names = labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "backbone = keras.applications.EfficientNetV2M(\n",
    "    include_top=False,\n",
    "    weights=\"imagenet\",\n",
    "    pooling='max',\n",
    "    include_preprocessing=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "backbone.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(backbone)\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(10, activation='softmax'))\n",
    "model.compile(loss = 'sparse_categorical_crossentropy', optimizer='adam',metrics =['acc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_checkpoint = \"model_checkpoint_efficent.keras\"\n",
    "\n",
    "es_callback = keras.callbacks.EarlyStopping(monitor=\"val_loss\", min_delta=0, patience=5)\n",
    "\n",
    "modelckpt_callback = keras.callbacks.ModelCheckpoint(\n",
    "    monitor=\"val_loss\",\n",
    "    filepath=path_checkpoint,\n",
    "    verbose=1,\n",
    "    save_weights_only=False,\n",
    "    save_best_only=True,\n",
    ")\n",
    "\n",
    "history_mobile_net = model.fit(\n",
    "    train_datagen_flow,\n",
    "    epochs=N_EPOCHS,\n",
    "    validation_data=val_datagen_flow,\n",
    "    callbacks=[es_callback, modelckpt_callback],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_metrics(history_mobile_net, 'loss')\n",
    "check_metrics(history_mobile_net, 'acc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = load_model(\"model_checkpoint_mobile_net_v3.keras\")\n",
    "model.evaluate(val_datagen_flow) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_indexes = []\n",
    "y_true_indexes = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(val_datagen_flow)):\n",
    "    x_test_batch, y_test_batch = val_datagen_flow[i]\n",
    "    y_pred_batch = model.predict(x_test_batch)\n",
    "    y_pred_index = np.argmax(y_pred_batch, axis = 1)\n",
    "    y_pred_indexes.append(y_pred_index)\n",
    "    y_true_indexes.append(y_test_batch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_indexes = np.concatenate(y_pred_indexes)\n",
    "y_true_indexes = np.concatenate(y_true_indexes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = confusion_matrix(y_true_indexes, y_pred_indexes)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=labels)\n",
    "disp.plot()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}