Happy_calf_ED0.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "current_datetime=datetime.datetime.now()\n",
    "print(f\"Calf was last happy on: {current_datetime.strftime('%Y-%m-%d %H:%M:%S')}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import random\n",
    "import io\n",
    "import glob\n",
    "import scipy.misc\n",
    "import numpy as np\n",
    "from six import BytesIO\n",
    "from PIL import Image, ImageDraw, ImageFont\n",
    "from IPython.display import display, Javascript\n",
    "from IPython.display import Image as IPyImage\n",
    "import tensorflow as tf\n",
    "import pathlib\n",
    "import itertools\n",
    "import random\n",
    "\n",
    "from object_detection.utils import ops as utils_ops\n",
    "from object_detection.utils import label_map_util\n",
    "from object_detection.utils import visualization_utils as viz_utils\n",
    "\n",
    "from object_detection.utils import config_util\n",
    "from object_detection.builders import model_builder\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tf.config.list_physical_devices('GPU'))\n",
    "!nvidia-smi\n",
    "# !kill -9 1618764\n",
    "gpu_memory_fraction = 0.8\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "if gpus:\n",
    "    try:\n",
    "        # Set memory growth for each GPU\n",
    "        for gpu in gpus:\n",
    "            tf.config.experimental.set_virtual_device_configuration(\n",
    "                gpu,\n",
    "                [tf.config.experimental.VirtualDeviceConfiguration(memory_limit=int(gpu_memory_fraction * 1024))]\n",
    "            )\n",
    "    except RuntimeError as e:\n",
    "        print(e)\n",
    "# tf.keras.mixed_precision.set_global_policy('mixed_float16')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Download EfficientDet model \n",
    "# TODO: \n",
    "# 1. Configure the directory path for the model download.\n",
    "\n",
    "\n",
    "# import wget\n",
    "# model_link = \"http://download.tensorflow.org/models/object_detection/tf2/20200711/efficientdet_d0_coco17_tpu-32.tar.gz\"\n",
    "# model_tar_name=\"efficientdet_d0_coco17_tpu-32.tar.gz\"\n",
    "\n",
    "# # Check if model is already downloadeds\n",
    "# if not os.path.exists(model_tar_name):\n",
    "#     wget.download(model_link)\n",
    "#     # Unzip\n",
    "#     !tar -zxvf {model_tar_name} \n",
    "# else:\n",
    "#     print(f\"Model {model_tar_name} already downloaded\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training the model\n",
    "# !python3 Calf_Detection//models/research/object_detection/model_main_tf2.py \\\n",
    "#     --pipeline_config_path=Calf_Detection/new_app/config/efficientdet_d0_coco17_tpu-32.config \\\n",
    "#     --model_dir=Calf_Detection/new_app/training_ed0_epochs_100 \\\n",
    "#     --alsologtostderr\n",
    "\n",
    "# # Training the model d1\n",
    "# !python3 ./models/research/object_detection/model_main_tf2.py \\\n",
    "#     --pipeline_config_path=new_app/New_Models/config/efficientdet_d1_coco17_tpu-32.config \\\n",
    "#     --model_dir=new_app/New_Models/training/efficientdet_d1_coco17_tpu-32 \\\n",
    "#     --alsologtostderr\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualization in tensorboard \n",
    "# Todo:\n",
    "# 1. Check Tensorboard visualization\n",
    "# !cd Calf_Detection/new_app/training_ed0_epochs_100 && tensorboard --logdir=.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Export the model d0\n",
    "# pipeline_file = 'Calf_Detection/new_app/config/efficientdet_d0_coco17_tpu-32.config'\n",
    "# last_model_path = 'Calf_Detection/new_app/training_ed0_epochs_100'\n",
    "# output_directory = \"Calf_Detection/new_app/finetuned_ed0_epochs_100\"\n",
    "# !python3 Calf_Detection/models/research/object_detection/exporter_main_v2.py \\\n",
    "#     --trained_checkpoint_dir {last_model_path} \\\n",
    "#     --output_directory {output_directory} \\\n",
    "#     --pipeline_config_path {pipeline_file}\n",
    "\n",
    "# # Export the model d1\n",
    "# pipeline_file = 'new_app/New_Models/config/efficientdet_d1_coco17_tpu-32.config'\n",
    "# last_model_path = 'new_app/New_Models/training/efficientdet_d1_coco17_tpu-32'\n",
    "# output_directory = \"new_app/New_Models/finetuned/efficientdet_d1_coco17_tpu-32\"\n",
    "# !python3 models/research/object_detection/exporter_main_v2.py \\\n",
    "#     --trained_checkpoint_dir {last_model_path} \\\n",
    "#     --output_directory {output_directory} \\\n",
    "#     --pipeline_config_path {pipeline_file}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pipeline_file = 'Calf_Detection/new_app/New_Models/config/efficientdet_d0_coco17_tpu-32.config'\n",
    "last_model_path = 'Calf_Detection/new_app/New_Models/training/epochs_10/efficientdet_d0_coco17_tpu-32'\n",
    "output_directory = \"Calf_Detection/new_app/New_Models/finetuned/efficientdet_d0_coco17_tpu-32\"\n",
    "\n",
    "import pathlib\n",
    "\n",
    "def load_image_into_numpy_array(path):\n",
    "  \"\"\"Load an image from file into a numpy array.\n",
    "  Puts image into numpy array to feed into tensorflow graph.\n",
    "  Note that by convention we put it into a numpy array with shape\n",
    "  (height, width, channels), where channels=3 for RGB.\n",
    "  Args:\n",
    "    path: a file path.\n",
    "  Returns:\n",
    "    uint8 numpy array with shape (img_height, img_width, 3)\n",
    "  \"\"\"\n",
    "  img_data = tf.io.gfile.GFile(path, 'rb').read()\n",
    "  image = Image.open(BytesIO(img_data))\n",
    "  (im_width, im_height) = image.size\n",
    "  return np.array(image.getdata()).reshape(\n",
    "      (im_height, im_width, 3)).astype(np.uint8)\n",
    "\n",
    "def plot_detections(image_np,\n",
    "                    boxes,\n",
    "                    classes,\n",
    "                    scores,\n",
    "                    category_index,\n",
    "                    figsize=(12, 16),\n",
    "                    image_name=None):\n",
    "  image_np_with_annotations = image_np.copy()\n",
    "  viz_utils.visualize_boxes_and_labels_on_image_array(\n",
    "      image_np_with_annotations,\n",
    "      boxes,\n",
    "      classes,\n",
    "      scores,\n",
    "      category_index,\n",
    "      use_normalized_coordinates=True,\n",
    "      min_score_thresh=0.8)\n",
    "  if image_name:\n",
    "    plt.imsave(image_name, image_np_with_annotations)\n",
    "  else:\n",
    "    plt.imshow(image_np_with_annotations)\n",
    "\n",
    "filenames = list(pathlib.Path('Calf_Detection/new_app/New_Models/training/epochs_10/efficientdet_d0_coco17_tpu-32').glob('*.index'))\n",
    "filenames.sort()\n",
    "\n",
    "# recover our saved model\n",
    "model_dir = 'Calf_Detection/new_app/New_Models/training/epochs_10/efficientdet_d0_coco17_tpu-32'\n",
    "# Adding the last checkpoint\n",
    "configs = config_util.get_configs_from_pipeline_file(pipeline_file)\n",
    "model_config = configs['model']\n",
    "detection_model = model_builder.build(\n",
    "      model_config=model_config, is_training=False)\n",
    "\n",
    "print(detection_model)\n",
    "# Restore checkpoint\n",
    "ckpt = tf.compat.v2.train.Checkpoint(\n",
    "      model=detection_model)\n",
    "ckpt.restore(os.path.join(str(filenames[-1]).replace('.index',''))).expect_partial()\n",
    "print(os.path.join(str(filenames[-1]).replace('.index','')))\n",
    "\n",
    "def get_model_detection_function(model):\n",
    "  \"\"\"Get a tf.function for detection.\"\"\"\n",
    "\n",
    "  @tf.function\n",
    "  def detect_fn(image):\n",
    "    \"\"\"Detect objects in image.\"\"\"\n",
    "\n",
    "    image, shapes = model.preprocess(image)\n",
    "    prediction_dict = model.predict(image, shapes)\n",
    "    detections = model.postprocess(prediction_dict, shapes)\n",
    "\n",
    "    return detections, prediction_dict, tf.reshape(shapes, [-1])\n",
    "\n",
    "  return detect_fn\n",
    "\n",
    "detect_fn = get_model_detection_function(detection_model)\n",
    "# map labels for inference decoding\n",
    "label_map_path = configs['eval_input_config'].label_map_path\n",
    "label_map = label_map_util.load_labelmap(label_map_path)\n",
    "categories = label_map_util.convert_label_map_to_categories(\n",
    "    label_map,\n",
    "    max_num_classes=label_map_util.get_max_label_map_index(label_map),\n",
    "    use_display_name=True)\n",
    "category_index = label_map_util.create_category_index(categories)\n",
    "label_map_dict = label_map_util.get_label_map_dict(label_map, use_display_name=True)\n",
    "#run detector on test image\n",
    "#it takes a little longer on the first run and then runs at normal speed. \n",
    "\n",
    "TEST_IMAGE_PATHS = glob.glob('Calf_Detection/new_app/test/2018-11-20_000001.jpg')\n",
    "\n",
    "image_path = random.choice(TEST_IMAGE_PATHS)\n",
    "image_np = load_image_into_numpy_array(image_path)\n",
    "\n",
    "input_tensor = tf.convert_to_tensor(\n",
    "    np.expand_dims(image_np, 0), dtype=tf.float32)\n",
    "detections, predictions_dict, shapes = detect_fn(input_tensor)\n",
    "\n",
    "label_id_offset = 1\n",
    "image_np_with_detections = image_np.copy()\n",
    "\n",
    "viz_utils.visualize_boxes_and_labels_on_image_array(\n",
    "      image_np_with_detections,\n",
    "      detections['detection_boxes'][0].numpy(),\n",
    "      (detections['detection_classes'][0].numpy() + label_id_offset).astype(int),\n",
    "      detections['detection_scores'][0].numpy(),\n",
    "      category_index,\n",
    "      use_normalized_coordinates=True,\n",
    "      max_boxes_to_draw=1,\n",
    "      min_score_thresh=.1,\n",
    "      agnostic_mode=False,\n",
    ")\n",
    "\n",
    "plt.figure(figsize=(12,16))\n",
    "plt.imshow(image_np_with_detections)\n",
    "plt.axis(\"off\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import time\n",
    "\n",
    "# sample_image_path = 'Calf_Detection/new_app/test/2019-06-29_090001.jpg'\n",
    "# sample_image_np = load_image_into_numpy_array(sample_image_path)\n",
    "\n",
    "# # Define the number of inference iterations\n",
    "\n",
    "# # Assuming 24 fps x 60 seconds = 1440 frames per minute\n",
    "# num_iterations = 1440\n",
    "\n",
    "# total_inference_time = 0\n",
    "\n",
    "# for _ in range(num_iterations):\n",
    "#     input_tensor = tf.convert_to_tensor(\n",
    "#         np.expand_dims(sample_image_np, 0), dtype=tf.float32)\n",
    "\n",
    "#     start_time = time.time()\n",
    "#     detections, predictions_dict, shapes = detect_fn(input_tensor)\n",
    "#     end_time = time.time()\n",
    "    \n",
    "#     inference_time = end_time - start_time\n",
    "#     total_inference_time += inference_time\n",
    "\n",
    "# average_inference_time = total_inference_time \n",
    "# print(f\"Total Inference Time for 1 Minute: {average_inference_time:.5f} seconds\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Evaluate the model\n",
    "# !python3 Calf_Detection/models/research/object_detection/model_main_tf2.py \\\n",
    "#     --pipeline_config_path=Calf_Detection/new_app/config/efficientdet_d0_coco17_tpu-32.config \\\n",
    "#     --model_dir=Calf_Detection/new_app/training_ed0 \\\n",
    "#     --checkpoint_dir=Calf_Detection/new_app/training_ed0 \\\n",
    "#     --alsologtostderr\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb Cell 11\u001b[0m line \u001b[0;36m9\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=87'>88</a>\u001b[0m     \u001b[39mreturn\u001b[39;00m detections\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=89'>90</a>\u001b[0m \u001b[39m# Loading model\u001b[39;00m\n\u001b[0;32m---> <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=90'>91</a>\u001b[0m detection_model \u001b[39m=\u001b[39m load_model(pipeline_file, model_dir)\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=91'>92</a>\u001b[0m thresholds \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mlinspace(\u001b[39m0\u001b[39m, \u001b[39m1\u001b[39m, \u001b[39m50\u001b[39m)  \u001b[39m# For example, 50 thresholds from 0 to 1\u001b[39;00m\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=92'>93</a>\u001b[0m tpr_list \u001b[39m=\u001b[39m []  \u001b[39m# Store true positive rates for each threshold\u001b[39;00m\n",
      "\u001b[1;32m/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb Cell 11\u001b[0m line \u001b[0;36m7\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=67'>68</a>\u001b[0m filenames \u001b[39m=\u001b[39m \u001b[39mlist\u001b[39m(pathlib\u001b[39m.\u001b[39mPath(model_dir)\u001b[39m.\u001b[39mglob(\u001b[39m'\u001b[39m\u001b[39m*.index\u001b[39m\u001b[39m'\u001b[39m))\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=68'>69</a>\u001b[0m filenames\u001b[39m.\u001b[39msort()\n\u001b[0;32m---> <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=69'>70</a>\u001b[0m checkpoint_path \u001b[39m=\u001b[39m \u001b[39mstr\u001b[39m(filenames[\u001b[39m-\u001b[39;49m\u001b[39m1\u001b[39;49m])\u001b[39m.\u001b[39mreplace(\u001b[39m'\u001b[39m\u001b[39m.index\u001b[39m\u001b[39m'\u001b[39m,\u001b[39m'\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=70'>71</a>\u001b[0m ckpt \u001b[39m=\u001b[39m tf\u001b[39m.\u001b[39mcompat\u001b[39m.\u001b[39mv2\u001b[39m.\u001b[39mtrain\u001b[39m.\u001b[39mCheckpoint(model\u001b[39m=\u001b[39mdetection_model)\n\u001b[1;32m     <a href='vscode-notebook-cell://ssh-remote%2Btinyx.nhr.fau.de/home/woody/iwfa/iwfa030h/Calf_Detection/Happy_calf_ED0.ipynb#X13sdnNjb2RlLXJlbW90ZQ%3D%3D?line=71'>72</a>\u001b[0m ckpt\u001b[39m.\u001b[39mrestore(checkpoint_path)\u001b[39m.\u001b[39mexpect_partial()\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# Metric Evaluation\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from object_detection.utils import config_util\n",
    "from object_detection.builders import model_builder\n",
    "import xml.etree.ElementTree as ET\n",
    "import glob\n",
    "\n",
    "# Paths setup\n",
    "TEST_IMAGE_PATHS = glob.glob('Calf_Detection/new_app/test/*.jpg')\n",
    "\n",
    "# Metrics Initialization\n",
    "false_negative = 0\n",
    "true_negative = 0\n",
    "true_positive = 0\n",
    "false_positive = 0\n",
    "total_ground_truth = len(TEST_IMAGE_PATHS)\n",
    "low_iou_images = []\n",
    "pipeline_file = 'Calf_Detection/new_app/New_Models/config/efficientdet_d0_coco17_tpu-32.config'\n",
    "last_model_path = 'Calf_Detection/new_app/New_Models/training/epochs_10/efficientdet_d0_coco17_tpu-32'\n",
    "output_directory = \"Calf_Detection/new_app/New_Models/finetuned/epochs_10/efficientdet_d0_coco17_tpu-32\"\n",
    "filenames = list(pathlib.Path('Calf_Detection/new_app/New_Models/training/epochs_10/efficientdet_d0_coco17_tpu-32').glob('*.index'))\n",
    "filenames.sort()\n",
    "model_dir = 'Calf_Detection/new_app/training_ed0_epochs_100'\n",
    "\n",
    "def load_image_into_numpy_array(path):\n",
    "  img_data = tf.io.gfile.GFile(path, 'rb').read()\n",
    "  image = Image.open(BytesIO(img_data))\n",
    "  (im_width, im_height) = image.size\n",
    "  return np.array(image.getdata()).reshape(\n",
    "      (im_height, im_width, 3)).astype(np.uint8)\n",
    "\n",
    "def compute_iou(boxA, boxB):\n",
    "    \"\"\"Computes Intersection over Union (IoU) between two bounding boxes.\"\"\"\n",
    "    xA = max(boxA[0], boxB[0])\n",
    "    yA = max(boxA[1], boxB[1])\n",
    "    xB = min(boxA[2], boxB[2])\n",
    "    yB = min(boxA[3], boxB[3])\n",
    "    \n",
    "    interArea = max(0, xB - xA + 1) * max(0, yB - yA + 1)\n",
    "    boxAArea = (boxA[2] - boxA[0] + 1) * (boxA[3] - boxA[1] + 1)\n",
    "    boxBArea = (boxB[2] - boxB[0] + 1) * (boxB[3] - boxB[1] + 1)\n",
    "    \n",
    "    iou = interArea / float(boxAArea + boxBArea - interArea)\n",
    "    return iou\n",
    "\n",
    "def extract_bbox_from_xml(xml_path):\n",
    "    \"\"\"Extracts bounding box information from an XML annotation file.\"\"\"\n",
    "    tree = ET.parse(xml_path)\n",
    "    root = tree.getroot()\n",
    "    for member in root.findall('object'):\n",
    "        bbox = member.find('bndbox')\n",
    "        return [int(bbox.find(pos).text) for pos in ['xmin', 'ymin', 'xmax', 'ymax']]\n",
    "\n",
    "def get_ground_truth_for_image(image_path):\n",
    "    \"\"\"Gets ground truth bounding box for a given image.\"\"\"\n",
    "    xml_path = image_path.replace('.jpg', '.xml')  \n",
    "    return extract_bbox_from_xml(xml_path)\n",
    "\n",
    "def load_model(pipeline_file, model_dir):\n",
    "    \"\"\"Loads the saved model from checkpoint.\"\"\"\n",
    "    configs = config_util.get_configs_from_pipeline_file(pipeline_file)\n",
    "    model_config = configs['model']\n",
    "    detection_model = model_builder.build(model_config=model_config, is_training=False)\n",
    "    \n",
    "    # Restore checkpoint\n",
    "    filenames = list(pathlib.Path(model_dir).glob('*.index'))\n",
    "    filenames.sort()\n",
    "    checkpoint_path = str(filenames[-1]).replace('.index','')\n",
    "    ckpt = tf.compat.v2.train.Checkpoint(model=detection_model)\n",
    "    ckpt.restore(checkpoint_path).expect_partial()\n",
    "    \n",
    "    return detection_model\n",
    "\n",
    "def detect_objects(detection_model, image_np):\n",
    "    \"\"\"Detects objects in an image using the trained model.\"\"\"\n",
    "    input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)\n",
    "    detections = detect_fn(input_tensor, detection_model)\n",
    "    return detections\n",
    "\n",
    "@tf.function\n",
    "def detect_fn(image, model):\n",
    "    \"\"\"TF function for object detection.\"\"\"\n",
    "    image, shapes = model.preprocess(image)\n",
    "    prediction_dict = model.predict(image, shapes)\n",
    "    detections = model.postprocess(prediction_dict, shapes)\n",
    "    return detections\n",
    "\n",
    "# Loading model\n",
    "detection_model = load_model(pipeline_file, model_dir)\n",
    "thresholds = np.linspace(0, 1, 50)  # For example, 50 thresholds from 0 to 1\n",
    "tpr_list = []  # Store true positive rates for each threshold\n",
    "fpr_list = []  # Store false positive rates for each threshold\n",
    "\n",
    "\n",
    "for image_path in TEST_IMAGE_PATHS:\n",
    "    image_np = load_image_into_numpy_array(image_path)\n",
    "    detections = detect_objects(detection_model, image_np)\n",
    "    \n",
    "    detection_boxes = detections['detection_boxes'][0].numpy()\n",
    "    detection_scores = detections['detection_scores'][0].numpy()\n",
    "    valid_indices = np.where(detection_scores >= 0.5)[0]\n",
    "    valid_boxes = detection_boxes[valid_indices]\n",
    "\n",
    "    ground_truth_box = get_ground_truth_for_image(image_path)\n",
    "\n",
    "    # If no ground truth for this image, assume it means no calf present\n",
    "    if not ground_truth_box:\n",
    "        if len(valid_boxes) == 0:  # No detections\n",
    "            true_negative += 1\n",
    "        else:\n",
    "            false_positive += 1  # Model detected something when it shouldn't have\n",
    "        continue  # Move to the next image\n",
    "\n",
    "    # Normalize the ground truth bounding box\n",
    "    img_height, img_width, _ = image_np.shape\n",
    "    normalized_gt_box = [\n",
    "        ground_truth_box[1] / img_width,   # xmin\n",
    "        ground_truth_box[0] / img_height,  # ymin\n",
    "        ground_truth_box[3] / img_width,   # xmax\n",
    "        ground_truth_box[2] / img_height   # ymax\n",
    "    ]\n",
    "\n",
    "    detected = any(compute_iou(box, normalized_gt_box) >= 0.50 for box in valid_boxes)\n",
    "\n",
    "    if detected:\n",
    "        true_positive += 1\n",
    "    else:\n",
    "        false_negative += 1  # Model didn't detect when it should have\n",
    "        low_iou_images.append(image_path)\n",
    "\n",
    "precision = true_positive / (true_positive + false_positive)\n",
    "recall = true_positive / total_ground_truth\n",
    "accuracy = (true_positive + true_negative) / total_ground_truth\n",
    "\n",
    "print(f\"Precision: {precision:.2f}\")\n",
    "print(f\"Recall: {recall:.2f}\")\n",
    "print(f\"Accuracy: {accuracy:.2f}\")\n",
    "print(\"\\nConfusion Matrix:\")\n",
    "print(f\"TP: {true_positive}\")\n",
    "print(f\"FP: {false_positive}\")\n",
    "print(f\"TN: {true_negative}\")\n",
    "print(f\"FN: {false_negative}\")\n",
    "\n",
    "print(\"\\nImages that didn't meet the threshold:\")\n",
    "for img in low_iou_images:\n",
    "    print(img)\n",
    "\n",
    "print(len(low_iou_images))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Metric Evaluation\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "from object_detection.utils import config_util\n",
    "from object_detection.builders import model_builder\n",
    "import xml.etree.ElementTree as ET\n",
    "import glob\n",
    "\n",
    "# Paths setup\n",
    "TEST_IMAGE_PATHS = glob.glob('Calf_Detection/new_app/test/*.jpg')\n",
    "\n",
    "# Metrics Initialization\n",
    "false_negative = 0\n",
    "true_negative = 0\n",
    "true_positive = 0\n",
    "false_positive = 0\n",
    "total_ground_truth = len(TEST_IMAGE_PATHS)\n",
    "low_iou_images = []\n",
    "\n",
    "def compute_iou(boxA, boxB):\n",
    "    \"\"\"Computes Intersection over Union (IoU) between two bounding boxes.\"\"\"\n",
    "    xA = max(boxA[0], boxB[0])\n",
    "    yA = max(boxA[1], boxB[1])\n",
    "    xB = min(boxA[2], boxB[2])\n",
    "    yB = min(boxA[3], boxB[3])\n",
    "    \n",
    "    interArea = max(0, xB - xA + 1) * max(0, yB - yA + 1)\n",
    "    boxAArea = (boxA[2] - boxA[0] + 1) * (boxA[3] - boxA[1] + 1)\n",
    "    boxBArea = (boxB[2] - boxB[0] + 1) * (boxB[3] - boxB[1] + 1)\n",
    "    \n",
    "    iou = interArea / float(boxAArea + boxBArea - interArea)\n",
    "    return iou\n",
    "\n",
    "def extract_bbox_from_xml(xml_path):\n",
    "    \"\"\"Extracts bounding box information from an XML annotation file.\"\"\"\n",
    "    tree = ET.parse(xml_path)\n",
    "    root = tree.getroot()\n",
    "    for member in root.findall('object'):\n",
    "        bbox = member.find('bndbox')\n",
    "        return [int(bbox.find(pos).text) for pos in ['xmin', 'ymin', 'xmax', 'ymax']]\n",
    "\n",
    "def get_ground_truth_for_image(image_path):\n",
    "    \"\"\"Gets ground truth bounding box for a given image.\"\"\"\n",
    "    xml_path = image_path.replace('.jpg', '.xml')  \n",
    "    return extract_bbox_from_xml(xml_path)\n",
    "\n",
    "def load_model(pipeline_file, model_dir):\n",
    "    \"\"\"Loads the saved model from checkpoint.\"\"\"\n",
    "    configs = config_util.get_configs_from_pipeline_file(pipeline_file)\n",
    "    model_config = configs['model']\n",
    "    detection_model = model_builder.build(model_config=model_config, is_training=False)\n",
    "    \n",
    "    # Restore checkpoint\n",
    "    filenames = list(pathlib.Path(model_dir).glob('*.index'))\n",
    "    filenames.sort()\n",
    "    checkpoint_path = str(filenames[-1]).replace('.index','')\n",
    "    ckpt = tf.compat.v2.train.Checkpoint(model=detection_model)\n",
    "    ckpt.restore(checkpoint_path).expect_partial()\n",
    "    \n",
    "    return detection_model\n",
    "\n",
    "def detect_objects(detection_model, image_np):\n",
    "    \"\"\"Detects objects in an image using the trained model.\"\"\"\n",
    "    input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)\n",
    "    detections = detect_fn(input_tensor, detection_model)\n",
    "    return detections\n",
    "\n",
    "@tf.function\n",
    "def detect_fn(image, model):\n",
    "    \"\"\"TF function for object detection.\"\"\"\n",
    "    image, shapes = model.preprocess(image)\n",
    "    prediction_dict = model.predict(image, shapes)\n",
    "    detections = model.postprocess(prediction_dict, shapes)\n",
    "    return detections\n",
    "\n",
    "thresholds = [0.25, 0.50, 0.75, 1.00]\n",
    "tpr_list = []\n",
    "fpr_list = []\n",
    "\n",
    "for threshold in thresholds:\n",
    "    # Reset the metrics for each threshold\n",
    "    false_negative = 0\n",
    "    true_negative = 0\n",
    "    true_positive = 0\n",
    "    false_positive = 0\n",
    "    \n",
    "    for image_path in TEST_IMAGE_PATHS:\n",
    "        image_np = load_image_into_numpy_array(image_path)\n",
    "        detections = detect_objects(detection_model, image_np)\n",
    "        \n",
    "        detection_boxes = detections['detection_boxes'][0].numpy()\n",
    "        detection_scores = detections['detection_scores'][0].numpy()\n",
    "        valid_indices = np.where(detection_scores >= threshold)[0]\n",
    "        valid_boxes = detection_boxes[valid_indices]\n",
    "\n",
    "        ground_truth_box = get_ground_truth_for_image(image_path)\n",
    "\n",
    "        if not ground_truth_box:\n",
    "            if len(valid_boxes) == 0:\n",
    "                true_negative += 1\n",
    "            else:\n",
    "                false_positive += 1\n",
    "            continue\n",
    "\n",
    "        img_height, img_width, _ = image_np.shape\n",
    "        normalized_gt_box = [\n",
    "            ground_truth_box[1] / img_width,\n",
    "            ground_truth_box[0] / img_height,\n",
    "            ground_truth_box[3] / img_width,\n",
    "            ground_truth_box[2] / img_height\n",
    "        ]\n",
    "        detected = any(compute_iou(box, normalized_gt_box) >= 0.50 for box in valid_boxes)\n",
    "\n",
    "        if detected:\n",
    "            true_positive += 1\n",
    "        else:\n",
    "            false_negative += 1\n",
    "    \n",
    "    tpr = true_positive / (true_positive + false_negative) if (true_positive + false_negative) != 0 else 0.0\n",
    "    if (false_positive + true_negative) == 0:\n",
    "        fpr = 0.0\n",
    "    else:\n",
    "        fpr = false_positive / (false_positive + true_negative)\n",
    "    \n",
    "    tpr_list.append(tpr)\n",
    "    fpr_list.append(fpr)\n",
    "\n",
    "# Plot the ROC curve\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(fpr_list, tpr_list, '-o', label='ROC curve')\n",
    "plt.plot([0, 1], [0, 1], linestyle='--')\n",
    "\n",
    "# Annotate each point with its threshold value\n",
    "for i, threshold in enumerate(thresholds):\n",
    "    plt.annotate(f\"{threshold:.2f}\", (fpr_list[i], tpr_list[i]), \n",
    "                 textcoords=\"offset points\", \n",
    "                 xytext=(0,10), \n",
    "                 ha='center')\n",
    "\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.title('Receiver Operating Characteristic (ROC) Curve')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "save_path = 'Calf_Detection/new_app/New_Models/graphs/roc_curve_d0.png'\n",
    "\n",
    "# Save the plot to the specified path\n",
    "plt.savefig(save_path, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. Copy the images from low_iou_images to a new directory\n",
    "import shutil\n",
    "NEW_DIR = \"Calf_Detection/new_app/low_iou_images_dir\"\n",
    "if not os.path.exists(NEW_DIR):\n",
    "    os.makedirs(NEW_DIR)\n",
    "\n",
    "for image_path in low_iou_images:\n",
    "    shutil.copy(image_path, NEW_DIR)\n",
    "\n",
    "# 2. Draw bounding boxes and detection scores on those images\n",
    "def draw_boxes_on_image(image, detection_boxes, detection_scores, threshold=0.5):\n",
    "    draw = ImageDraw.Draw(image)\n",
    "    img_width, img_height = image.size\n",
    "    for box, score in zip(detection_boxes, detection_scores):\n",
    "        if score >= threshold:\n",
    "            y_min, x_min, y_max, x_max = box\n",
    "            # Convert normalized coordinates to pixel values\n",
    "            left, right, top, bottom = x_min * img_width, x_max * img_width, y_min * img_height, y_max * img_height\n",
    "            draw.rectangle([(left, top), (right, bottom)], outline=\"green\", width=2)\n",
    "            label = f\"Score: {score:.2f}\"\n",
    "            # Using PIL might not have fonts by default, so adjusting the text size instead\n",
    "            draw.text((left, top - 12), label, fill=\"green\")\n",
    "    return image\n",
    "\n",
    "for image_path in low_iou_images:\n",
    "    image = Image.open(image_path)\n",
    "    detections = detect_objects(detection_model, image)\n",
    "    detection_boxes = detections['detection_boxes'][0].numpy()\n",
    "    detection_scores = detections['detection_scores'][0].numpy()\n",
    "    image = draw_boxes_on_image(image, detection_boxes, detection_scores)\n",
    "    image.save(os.path.join(NEW_DIR, os.path.basename(image_path)))\n",
    "\n",
    "# 3. Visualize all these images in a single matplotlib frame using subplots\n",
    "num_images = len(low_iou_images)\n",
    "cols = 5  # Number of columns in the subplot grid (you can adjust this)\n",
    "rows = int(num_images / cols) + 1  # Calculate the number of rows required\n",
    "\n",
    "fig, axs = plt.subplots(rows, cols, figsize=(20, 20))\n",
    "fig.tight_layout()\n",
    "\n",
    "for idx, ax in enumerate(axs.ravel()):\n",
    "    if idx < num_images:\n",
    "        image_path = os.path.join(NEW_DIR, os.path.basename(low_iou_images[idx]))\n",
    "        image = Image.open(image_path)\n",
    "        ax.imshow(image)\n",
    "        ax.axis(\"off\")\n",
    "    else:\n",
    "        ax.axis(\"off\")  # Turn off any unused subplots\n",
    "\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf_od",
   "language": "python",
   "name": "tf_od"
  },
  "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.17"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}