Model Evaluation Notebook_.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Evaluation process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-    After training the model we evaluate our results against ground truth values. Given that we are facing with an object detection problem, we are using a common metric called Average Precision(AP) and the mAP, which is the mean of the obtained APs from all classes. We calculate these metrics using the evaluation tools from the paper: \"A Survey on Performance Metrics for Object-Detection Algorithms\", available on the following link:\n",
    "https://github.com/rafaelpadilla/Object-Detection-Metrics. \n",
    "\n",
    "-    In order to use them we should download the repo and follow installation instructions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-    Once installed, we need two create two folders groundtruths/ and detections/ containing txt files for every sample considered for evaluation. The files I created are on the **data/voc2012_raw/VOCdevkit/VOC2012** directory.\n",
    "\n",
    "    These files follow the following format:\n",
    "\n",
    "\n",
    "    - Line format for groundtruth files: \n",
    "                class_name xmin ymin xmax ymax\n",
    "    - Line format for detection files:\n",
    "                class_name confidence_score xmin ymin xmax ymax\n",
    "                \n",
    "                \n",
    "                \n",
    "-    We will perform the whole evaluation process in 3 steps:\n",
    "\n",
    "    1. The first step is to write txt evaluation files with ground truth information for every sample based on the original XML Annotations, inside groundtruths/ folder.\n",
    "            \n",
    "    2. Second step consists on running the trained YOLO network to perform inference on selected samples and then writing txt files from the obtained outputs.        \n",
    "            \n",
    "    4. Finally, using the groundtruths/ and detections/ directories, we can calculate AP values.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Writting txt ground truth files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-     Our evaluation metrics will be obtained comparing the ground truth objects and our predictions. For that we need to create .txt files using the XML Annotations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from os import listdir\n",
    "from os.path import isfile, join\n",
    "import lxml.etree\n",
    "import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- First, we declare the path of the folder where we copied all XML Annotation files from validation samples. We also declare the path for storing the ground truth files:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "annotations = 'data/voc2012_raw/VOCdevkit/VOC2012/AnnotationsVal'\n",
    "groundtruths = 'data/voc2012_raw/VOCdevkit/VOC2012/groundtruths'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We store filenames from validation samples under annotations_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "annotations_list = [file for file in listdir(annotations) if isfile(join(annotations, file))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2020_92.xml', '2020_02_144.xml', '2020_02_203.xml']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "annotations_list[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now we define a function for traversing an xml file and returning its content on a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_xml(xml):\n",
    "    if not len(xml):\n",
    "        return {xml.tag: xml.text}\n",
    "    result = {}\n",
    "    for child in xml:\n",
    "        child_result = parse_xml(child)\n",
    "        if child.tag != \"object\":\n",
    "            result[child.tag] = child_result[child.tag]\n",
    "        else:\n",
    "            if child.tag not in result:\n",
    "                result[child.tag] = []\n",
    "            result[child.tag].append(child_result[child.tag])\n",
    "    return {xml.tag: result}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We declare a function build_example for accesing the class names and bounding box coordinates from a dictionary generated by the parse_xml function, and then storing the result on a txt file file_tmp under the groundtruths/ directory.\n",
    "\n",
    "\n",
    "- Let's remember that every line on the groundtruth .txt files should follow the following format:\n",
    "        \n",
    "                                    class_name xmin ymin xmax ymax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_example(name,annotation, class_map):\n",
    "    file_name = join(groundtruths, name[:-4] + '.txt')\n",
    "    file_tmp = open(file_name,'w')\n",
    "    \n",
    "    if \"object\" in annotation:\n",
    "        for obj in annotation[\"object\"]:  \n",
    "            #we skip this class because we didnt optimize the network for this case, only for with_mask and without_mask classes\n",
    "            if obj['name'] == 'mask_weared_incorrect': \n",
    "                continue\n",
    "            line = obj[\"name\"] +  ' ' + str(int(obj[\"bndbox\"][\"xmin\"])) + ' ' + str(int(obj[\"bndbox\"][\"ymin\"]))+ ' '+ str(int(obj[\"bndbox\"][\"xmax\"])) + ' ' + str(int(obj[\"bndbox\"][\"ymax\"]))\n",
    "            #Writing into file_tmp\n",
    "            print(line,file=file_tmp)\n",
    "    \n",
    "    file_tmp.close()\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now we load class names from the voc2012.names file, and create a dictionary mapping class names to class ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "classes = 'data/voc2012.names'\n",
    "class_map = {\n",
    "    name: idx for idx, name in enumerate(open(classes).read().splitlines())\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Finally, we iterate over every file stored on annotations_list. First we read the file, then we parse the content from the xml, we access the bounding box and class information inside the 'annotation' key and read its contents to write the ground truth files into the corresponding folder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image  0\n",
      "Image  50\n",
      "Image  100\n",
      "Image  150\n",
      "Image  200\n",
      "Image  250\n",
      "Image  300\n",
      "Image  350\n",
      "Image  400\n",
      "Image  450\n",
      "Image  500\n",
      "Image  550\n",
      "Image  600\n"
     ]
    }
   ],
   "source": [
    "for i,image in enumerate(annotations_list):\n",
    "        if (i%50)==0:\n",
    "            print('Image ',i)\n",
    "        name = image\n",
    "        annotation_xml = os.path.join(annotations, name)\n",
    "        annotation_xml = lxml.etree.fromstring(open(annotation_xml).read())\n",
    "        annotation = parse_xml(annotation_xml)[\"annotation\"]\n",
    "        build_example(name,annotation, class_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now we can find a ground truth txt file for every sample used in the evaluation process inside the grountruths/ directory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Writing detection files from YOLO output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now we need to store Yolo detections into txt files on the detections/ directory. We will also have a separate txt file per sample with its detections.\n",
    "\n",
    "- The transformation will be done by the **write_detection** function:\n",
    "\n",
    "- Let's remember that every line on these txt files should follow the following format:\n",
    "        \n",
    "                              class_name confidence_score xmin ymin xmax ymax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_detections(filename,img,boxes,scores,classes,nums):  \n",
    "    file_tmp = open(detections + filename + '.txt','w')\n",
    "    boxes, scores, classes, nums = boxes[0], scores[0], classes[0], nums[0]\n",
    "    wh = np.flip(img.shape[0:2])\n",
    "    for i in range(nums):\n",
    "        x1y1 = tuple((np.array(boxes[i][0:2]) * wh).astype(np.int32))\n",
    "        x2y2 = tuple((np.array(boxes[i][2:4]) * wh).astype(np.int32))\n",
    "        class_name = class_names[int(classes[i])]\n",
    "        line = class_name +  ' ' + str(x1y1[0]) + str(x1y1[1]) + str(x2y2[0]) + str(x2y2[1])\n",
    "        file_tmp.write(line)\n",
    "    file_tmp.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now it's time to use the write_detections functions on our predictions. For that, we need to initialize YOLO architecture and perform inference on our samples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Inference using trained model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Our best trained model was obtained on epoch 125. We are using those weights to perform inference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "WEIGHTS = 'checkpoints/yolov3_train_125.tf'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Model definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from absl import app, logging, flags\n",
    "from absl.flags import FLAGS\n",
    "import time\n",
    "import cv2\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from yolov3_tf2.models import (\n",
    "    YoloV3, YoloV3Tiny\n",
    ")\n",
    "from yolov3_tf2.dataset import transform_images, load_tfrecord_dataset\n",
    "from yolov3_tf2.utils import draw_outputs\n",
    "\n",
    "flags.DEFINE_string('classes', './data/coco.names', 'path to classes file')\n",
    "flags.DEFINE_string('weights', WEIGHTS,\n",
    "                    'path to weights file')\n",
    "flags.DEFINE_boolean('tiny', False, 'yolov3 or yolov3-tiny')\n",
    "flags.DEFINE_integer('size', 416, 'resize images to')\n",
    "flags.DEFINE_string('image', './data/girl.png', 'path to input image')\n",
    "flags.DEFINE_string('tfrecord', None, 'tfrecord instead of image')\n",
    "flags.DEFINE_string('output', './output.jpg', 'path to output image')\n",
    "flags.DEFINE_integer('num_classes', 80, 'number of classes in the model')\n",
    "\n",
    "#LOAD WEIGHTS AND CREATE MODEL\n",
    "FLAGS.num_classes = 3\n",
    "FLAGS.classes = 'data/voc2012.names'\n",
    "FLAGS.weights = WEIGHTS\n",
    "FLAGS.tiny = False\n",
    "\n",
    "# Lower threshold due to insufficient training\n",
    "FLAGS.yolo_iou_threshold = 0.2\n",
    "FLAGS.yolo_score_threshold = 0.2\n",
    "\n",
    "app._run_init(['yolov3'], app.parse_flags_with_usage)\n",
    "\n",
    "if FLAGS.tiny:\n",
    "    yolo = YoloV3Tiny(classes=FLAGS.num_classes)\n",
    "else:\n",
    "    yolo = YoloV3(classes=FLAGS.num_classes)\n",
    "\n",
    "yolo.load_weights(FLAGS.weights).expect_partial()\n",
    "logging.info('weights loaded')\n",
    "\n",
    "class_names = [c.strip() for c in open(FLAGS.classes).readlines()]\n",
    "logging.info('classes loaded')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now we read val.txt file to extract validation filenames for inference:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_val =  'data/voc2012_raw/VOCdevkit/VOC2012/ImageSets/Main/'\n",
    "val = open(path_val + 'val.txt',\"r\")\n",
    "Lines = val.readlines() \n",
    "names_val = []\n",
    "for line in Lines: \n",
    "    name = line.split()[0]\n",
    "    names_val.append(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Now we iterate through the samples stored on names_val and perform inference using the previously trained weights. After every iteration, we use inference outputs to write the detection files using **write_eval_file** funtion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image, display\n",
    "from yolov3_tf2.utils import draw_outputs\n",
    "\n",
    "import os\n",
    "\n",
    "#path for loading images for inference\n",
    "image_path = 'data/voc2012_raw/VOCdevkit/VOC2012/JPEGImages/'\n",
    "names = names_val\n",
    "\n",
    "for i, filename in enumerate(names):\n",
    "  if (i%50) == 0:\n",
    "    print(\"Image \",i)\n",
    "    print(image_path + FLAGS.image)\n",
    "\n",
    "  FLAGS.image = filename + '.png'\n",
    "  try:  \n",
    "    img_raw = tf.image.decode_image(\n",
    "        open(image_path + FLAGS.image, 'rb').read(), channels=3)\n",
    "  except:\n",
    "    try:\n",
    "      FLAGS.image = filename + '.jpg'\n",
    "      img_raw = tf.image.decode_image(\n",
    "        open(image_path + FLAGS.image, 'rb').read(), channels=3)\n",
    "    except:\n",
    "        try:            \n",
    "            FLAGS.image = filename + '.JPG'\n",
    "            img_raw = tf.image.decode_image(\n",
    "            open(image_path + FLAGS.image, 'rb').read(), channels=3)\n",
    "        except:\n",
    "            print(\"wrong image\")\n",
    "            continue\n",
    "\n",
    "  img = tf.expand_dims(img_raw, 0)\n",
    "  img = transform_images(img, FLAGS.size)\n",
    "\n",
    "  \n",
    "  boxes, scores, classes, nums = yolo(img) #performing inference on an image\n",
    "  img = cv2.cvtColor(img_raw.numpy(), cv2.COLOR_RGB2BGR)\n",
    "  write_detections(filename,img,boxes,scores,classes,nums) #writting inference file from predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluating predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- At this point we have both groundtruth/, as well as detections/ directories containing .txt files for the final evaluation. As we mentioned on the beggining, after installing the Object Detection Metrics repo, we perform evaluation with the following command:\n",
    "\n",
    "\n",
    "                                                python pascalvoc.py -t 0.3\n",
    "- Where t=0.3 is the evaluation threshold."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- We can observe evaluation results for classes with_mask and without_mask:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Average Precision (AP) per class**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "\n",
    "fig=plt.figure(figsize=(15, 15))\n",
    "columns = 2\n",
    "rows = 1\n",
    "\n",
    "images = ['with_mask','without_mask']\n",
    "for i in range(1, columns*rows +1):\n",
    "    img=mpimg.imread('./' + images[i-1] + '.png')\n",
    "    fig.add_subplot(rows, columns, i)\n",
    "    plt.imshow(img)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Results:\n",
    "\n",
    "\n",
    "**AP with_mask: 68.75%**\n",
    "\n",
    "\n",
    "**AP without_mask: 55.46%**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We note that the axis from the AP plots for each class are: recall on the y axis and precision on the x axis. In order to better understand this metrics we need to define precision and recall:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Precision**: Fraction correctly predicted positive samples.\n",
    "\n",
    "**Recall**: Fraction of correctly predicted samples from the set of all positive samples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- There is a tradeoff between precision and recall, and depending on our threshold for classifying a sample being positive or negative, we can obtain different precision recall values.\n",
    "\n",
    "\n",
    "**Precision - Recall trade-off example**: If we set a very high treshold for predicting positive samples, we will obtain a very high precision given that the fraction of correctly predicted positive samples is going to be high due to a harder constrain imposed by the threshold. On the other hand recall is low, because that fraction of positive predicted samples is small compared to all positive samples from the ground truth.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**mAP (Mean Average Precision)**: mAP, is as the name says the mean of AP values from all classes, in this case:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mAP score:  62.11 %\n"
     ]
    }
   ],
   "source": [
    "AP_with_mask = 68.75\n",
    "AP_without_mask = 55.46\n",
    "mAP = (AP_with_mask + AP_without_mask)/2\n",
    "print('mAP score: ',round(mAP,2),'%')"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}