bed_pytorch_2BB_cosine.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "225b20d5-15c5-4de6-b91b-228405789ed7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.10/site-packages/transformers/utils/generic.py:441: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
      "  _torch_pytree._register_pytree_node(\n",
      "/opt/conda/lib/python3.10/site-packages/transformers/utils/generic.py:309: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n",
      "  _torch_pytree._register_pytree_node(\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import logging\n",
    "from pathlib import Path\n",
    "import datetime\n",
    "import xml.etree.ElementTree as ET\n",
    "\n",
    "from tqdm import tqdm\n",
    "import numpy as np\n",
    "import math\n",
    "import pandas as pd\n",
    "import random\n",
    "\n",
    "from collections import Counter # for mAP\n",
    "\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "# Not needed\n",
    "# from torchvision.transforms import ToTensor \n",
    "# from torchvision.transforms.v2 import (Compose, ToImage, ToDtype, \n",
    "#                                        Normalize, RandomPhotometricDistort)\n",
    "\n",
    "import albumentations as A\n",
    "from albumentations.pytorch import ToTensorV2\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch.nn as nn \n",
    "from torch.nn.utils import parameters_to_vector\n",
    "import torch.optim as optim\n",
    "from pytorch_accelerated.schedulers import CosineLrScheduler\n",
    "\n",
    "import cv2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a744c25c-0962-4cc8-986f-2ca69aca323e",
   "metadata": {},
   "source": [
    "# Logger"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c4072248-8bb2-4cb7-a71b-7b4586d8b188",
   "metadata": {},
   "outputs": [],
   "source": [
    "log_path = 'bed_pytorch_results/cosine/'\n",
    "\n",
    "logger = logging.getLogger(__name__)\n",
    "logger.setLevel(logging.INFO)\n",
    "file_handler = logging.FileHandler(log_path + 'logfile.log')\n",
    "formatter = logging.Formatter('%(message)s')\n",
    "file_handler.setFormatter(formatter)\n",
    "\n",
    "# add file handler to logger\n",
    "logger.addHandler(file_handler)\n",
    "\n",
    "logger.info('BIG BED after adding cosine with warmup')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c28235c-9cc5-4676-b2b1-c31b3c214e83",
   "metadata": {},
   "source": [
    "# Folders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "af468cf3-f6ef-4eff-9713-3034a68830c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train dir: ['labels - copia.cache', 'labels.cache', 'labels', 'images']\n",
      "val dir: ['labels.cache', 'labels', 'labels_2.cache', 'images']\n"
     ]
    }
   ],
   "source": [
    "ds_dir = 'ds2fire/dfire_yolo/'\n",
    "\n",
    "train_dir = ds_dir + 'train/'\n",
    "train_imgs = train_dir + 'images/'\n",
    "train_labels = train_dir + 'labels/'\n",
    "\n",
    "#val_dir = ds_dir + 'test/'\n",
    "\n",
    "val_dir = ds_dir + 'test/'\n",
    "val_imgs = val_dir + 'images/'\n",
    "val_labels = val_dir + 'labels/'\n",
    "\n",
    "print(f'Train dir: {os.listdir(train_dir)}')\n",
    "print(f'val dir: {os.listdir(val_dir)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "676dbf6f-f393-4b79-8d23-bda75a58caea",
   "metadata": {},
   "source": [
    "# Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f92b6578-e873-4f1b-a47e-b0788f9c612a",
   "metadata": {},
   "outputs": [],
   "source": [
    "CLASSES = [\"smoke\", \"fire\"]\n",
    "#CLASSES = [\"cat\", \"dog\"]\n",
    "\n",
    "#IMG_DIM = {'W':88, 'H':88} # (W, H)\n",
    "#IMG_DIM = {'W':160, 'H':120} # (W, H)\n",
    "#IMG_DIM = {'W':448, 'H':448} # (W, H)\n",
    "IMG_DIM = {'W':224, 'H':224} # (W, H)\n",
    "\n",
    "SX = 7\n",
    "SY = 7\n",
    "B = 2 # Number of bounding boxes to predict.\n",
    "C = len(CLASSES) # Number of classes in the dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8704ff2a-2926-4fc7-b2fc-ac3a3fcff843",
   "metadata": {},
   "source": [
    "# Utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7b30097d-3161-4cc1-81fa-ebdf9f0c4e2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def yolo2pixel(bbox):\n",
    "    '''\n",
    "    Transforms yolo coordinates of the box to pixel coordinates. \n",
    "    \n",
    "    Arguments:\n",
    "        - bbox: yolo coordinates [xc, yc, width, height]\n",
    "    \n",
    "    Returns: \n",
    "        - pixel coordinates [xmin, xmax, ymin, ymax]\n",
    "    '''\n",
    "    xc = bbox[0]\n",
    "    yc = bbox[1]\n",
    "    width = bbox[2]\n",
    "    height = bbox[3]\n",
    "      \n",
    "    xmin = xc - (width/2)          \n",
    "    xmax = xc + (width/2)         \n",
    "    ymin = yc - (height/2)            \n",
    "    ymax = yc + (height/2)\n",
    "        \n",
    "    nbox = [xmin, ymin, xmax, ymax]\n",
    "    \n",
    "    return nbox\n",
    "\n",
    "\n",
    "def iou_tensor(\n",
    "    boxes_preds, boxes_labels, \n",
    "    box_format=\"midpoint\",\n",
    "    epsilon=1e-6\n",
    "):\n",
    "    \"\"\"\n",
    "    Calculates intersection over union for bounding boxes.\n",
    "    \n",
    "    :param boxes_preds (tensor): Bounding box predictions of shape (BATCH_SIZE, 4)\n",
    "    :param boxes_labels (tensor): Ground truth bounding box of shape (BATCH_SIZE, 4)\n",
    "    :param box_format (str): midpoint/corners, if boxes (x,y,w,h) format or (x1,y1,x2,y2) format\n",
    "    :param epsilon: Small value to prevent division by zero.\n",
    "    Returns:\n",
    "        tensor: Intersection over union for all examples\n",
    "    \"\"\"\n",
    "\n",
    "    if box_format == 'midpoint':\n",
    "        box1_x1 = boxes_preds[..., 0:1] - boxes_preds[..., 2:3] / 2\n",
    "        box1_y1 = boxes_preds[..., 1:2] - boxes_preds[..., 3:4] / 2\n",
    "        box1_x2 = boxes_preds[..., 0:1] + boxes_preds[..., 2:3] / 2\n",
    "        box1_y2 = boxes_preds[..., 1:2] + boxes_preds[..., 3:4] / 2\n",
    "        box2_x1 = boxes_labels[..., 0:1] - boxes_labels[..., 2:3] / 2\n",
    "        box2_y1 = boxes_labels[..., 1:2] - boxes_labels[..., 3:4] / 2\n",
    "        box2_x2 = boxes_labels[..., 0:1] + boxes_labels[..., 2:3] / 2\n",
    "        box2_y2 = boxes_labels[..., 1:2] + boxes_labels[..., 3:4] / 2\n",
    "\n",
    "    if box_format == 'corners':\n",
    "        box1_x1 = boxes_preds[..., 0:1]\n",
    "        box1_y1 = boxes_preds[..., 1:2]\n",
    "        box1_x2 = boxes_preds[..., 2:3]\n",
    "        box1_y2 = boxes_preds[..., 3:4] \n",
    "        box2_x1 = boxes_labels[..., 0:1]\n",
    "        box2_y1 = boxes_labels[..., 1:2]\n",
    "        box2_x2 = boxes_labels[..., 2:3]\n",
    "        box2_y2 = boxes_labels[..., 3:4]\n",
    "\n",
    "    x1 = torch.max(box1_x1, box2_x1)\n",
    "    y1 = torch.max(box1_y1, box2_y1)\n",
    "    x2 = torch.min(box1_x2, box2_x2)\n",
    "    y2 = torch.min(box1_y2, box2_y2)\n",
    "\n",
    "    intersection = (x2 - x1).clamp(0) * (y2 - y1).clamp(0)\n",
    "\n",
    "    box1_area = abs((box1_x2 - box1_x1) * (box1_y2 - box1_y1))\n",
    "    box2_area = abs((box2_x2 - box2_x1) * (box2_y2 - box2_y1))\n",
    "\n",
    "    union = (box1_area + box2_area - intersection + epsilon)\n",
    "\n",
    "    iou = intersection / union\n",
    "    #print(f'IOU is numpy: {iou.numpy()}')\n",
    "\n",
    "    return iou\n",
    "\n",
    "def nms_yv1(bboxes, iou_threshold, threshold, box_format=\"corners\"):\n",
    "    \"\"\"\n",
    "    Does Non Max Suppression given bboxes\n",
    "\n",
    "    Parameters:\n",
    "        bboxes (list): list of lists containing all bboxes with each bboxes\n",
    "        specified as [x1, y1, x2, y2, confidence, class_id] MY FORMAT VERSION       \n",
    "        iou_threshold (float): threshold where predicted bboxes is correct\n",
    "        threshold (float): threshold to remove predicted bboxes (independent of IoU) \n",
    "        box_format (str): \"midpoint\" or \"corners\" used to specify bboxes\n",
    "\n",
    "    Returns:\n",
    "        list: bboxes after performing NMS given a specific IoU threshold\n",
    "    \"\"\"\n",
    "\n",
    "    assert type(bboxes) == list\n",
    "\n",
    "    bboxes = [box for box in bboxes if box[4] > threshold]\n",
    "    bboxes = sorted(bboxes, key=lambda x: x[4], reverse=True)\n",
    "    bboxes_after_nms = []\n",
    "\n",
    "    while bboxes:\n",
    "        chosen_box = bboxes.pop(0)\n",
    "\n",
    "        bboxes = [\n",
    "            box\n",
    "            for box in bboxes\n",
    "            if box[5] != chosen_box[5]\n",
    "            or iou_tensor(\n",
    "                torch.tensor(chosen_box[:4]),\n",
    "                torch.tensor(box[:4]),\n",
    "                box_format=box_format,\n",
    "            )\n",
    "            < iou_threshold\n",
    "        ]\n",
    "\n",
    "        bboxes_after_nms.append(chosen_box)\n",
    "\n",
    "    return bboxes_after_nms\n",
    "\n",
    "def nms_yv1_getBBoxes(bboxes, iou_threshold, threshold, box_format=\"corners\"):\n",
    "    \"\"\"\n",
    "    Does Non Max Suppression given bboxes\n",
    "\n",
    "    Parameters:\n",
    "        bboxes (list): list of lists containing all bboxes with each bboxes\n",
    "        specified as [class_id, score, xc, yc, w, h] Output of outcell_2_outboxes       \n",
    "        iou_threshold (float): threshold where predicted bboxes is correct\n",
    "        threshold (float): threshold to remove predicted bboxes (independent of IoU) \n",
    "        box_format (str): \"midpoint\" or \"corners\" used to specify bboxes\n",
    "\n",
    "    Returns:\n",
    "        list: bboxes after performing NMS given a specific IoU threshold\n",
    "    \"\"\"\n",
    "\n",
    "    assert type(bboxes) == list\n",
    "\n",
    "    bboxes = [box for box in bboxes if box[1] > threshold]\n",
    "    bboxes = sorted(bboxes, key=lambda x: x[1], reverse=True)\n",
    "    bboxes_after_nms = []\n",
    "\n",
    "    while bboxes:\n",
    "        chosen_box = bboxes.pop(0)\n",
    "\n",
    "        bboxes = [\n",
    "            box\n",
    "            for box in bboxes\n",
    "            if box[0] != chosen_box[0]\n",
    "            or iou_tensor(\n",
    "                torch.tensor(chosen_box[2:6]),\n",
    "                torch.tensor(box[2:6]),\n",
    "                box_format=box_format,\n",
    "            )\n",
    "            < iou_threshold\n",
    "        ]\n",
    "\n",
    "        bboxes_after_nms.append(chosen_box)\n",
    "\n",
    "    return bboxes_after_nms\n",
    "\n",
    "\n",
    "\n",
    "def mAP(\n",
    "    pred_boxes, true_boxes, iou_threshold=0.5, box_format=\"midpoint\", num_classes=2\n",
    "):\n",
    "    \"\"\"\n",
    "    Calculates mean average precision \n",
    "\n",
    "    Parameters:\n",
    "        pred_boxes (list): list of lists containing all bboxes with each bboxes\n",
    "        specified as [train_idx, class_prediction, prob_score, x1, y1, x2, y2]\n",
    "        true_boxes (list): Similar as pred_boxes except all the correct ones \n",
    "        iou_threshold (float): threshold where predicted bboxes is correct\n",
    "        box_format (str): \"midpoint\" or \"corners\" used to specify bboxes\n",
    "        num_classes (int): number of classes\n",
    "\n",
    "    Returns:\n",
    "        float: mAP value across all classes given a specific IoU threshold \n",
    "    \"\"\"\n",
    "\n",
    "    # list storing all AP for respective classes\n",
    "    average_precisions = []\n",
    "    avg_prec = {}\n",
    "\n",
    "    # Precision and Recall for each class\n",
    "    cls_prec = {}\n",
    "    cls_rec = {}\n",
    "\n",
    "    # used for numerical stability later on\n",
    "    epsilon = 1e-6\n",
    "\n",
    "    #for c in range(num_classes):\n",
    "    for c in tqdm(range(num_classes), desc =\"mAP:@.5\"):\n",
    "        detections = []\n",
    "        ground_truths = []\n",
    "\n",
    "        # Go through all predictions and targets,\n",
    "        # and only add the ones that belong to the\n",
    "        # current class c\n",
    "        for detection in pred_boxes:\n",
    "            if detection[1] == c:\n",
    "                detections.append(detection)\n",
    "        \n",
    "        #print(f'Detections of class {c}: {detections}')\n",
    "        \n",
    "        for true_box in true_boxes:\n",
    "            if true_box[1] == c:\n",
    "                ground_truths.append(true_box)\n",
    "\n",
    "        # find the amount of bboxes for each training example\n",
    "        # Counter here finds how many ground truth bboxes we get\n",
    "        # for each training example, so let's say img 0 has 3,\n",
    "        # img 1 has 5 then we will obtain a dictionary with:\n",
    "        # amount_bboxes = {0:3, 1:5}\n",
    "        amount_bboxes = Counter([gt[0] for gt in ground_truths])\n",
    "        \n",
    "        #print(f'Amount bboxes of class {c}: {amount_bboxes}')\n",
    "\n",
    "        # We then go through each key, val in this dictionary\n",
    "        # and convert to the following (w.r.t same example):\n",
    "        # ammount_bboxes = {0:torch.tensor[0,0,0], 1:torch.tensor[0,0,0,0,0]}\n",
    "        for key, val in amount_bboxes.items():\n",
    "            amount_bboxes[key] = torch.zeros(val)\n",
    "\n",
    "        #print(f'Amount bboxes of class {c} converted: {amount_bboxes}')\n",
    "        \n",
    "        # sort by box probabilities which is index 2\n",
    "        detections.sort(key=lambda x: x[2], reverse=True)\n",
    "        TP = torch.zeros((len(detections)))\n",
    "        FP = torch.zeros((len(detections)))\n",
    "        total_true_bboxes = len(ground_truths)\n",
    "       \n",
    "        #print(f'Total true bboxes of class {c}: {total_true_bboxes}')\n",
    "        \n",
    "        # If none exists for this class then we can safely skip\n",
    "        # Maybe removing this is enough to take into account False Positives\n",
    "        # for images with no objects\n",
    "        if total_true_bboxes == 0:\n",
    "            continue\n",
    "\n",
    "        for detection_idx, detection in enumerate(detections):\n",
    "            # Only take out the ground_truths that have the same\n",
    "            # training idx as detection\n",
    "            ground_truth_img = [\n",
    "                bbox for bbox in ground_truths if bbox[0] == detection[0]\n",
    "            ]\n",
    "\n",
    "            num_gts = len(ground_truth_img)\n",
    "            best_iou = 0\n",
    "\n",
    "            for idx, gt in enumerate(ground_truth_img):\n",
    "                iou = iou_tensor(\n",
    "                    torch.tensor(detection[3:]),\n",
    "                    torch.tensor(gt[3:]),\n",
    "                    box_format=box_format,\n",
    "                )\n",
    "                # iou, _, _ = ut.iou(detection[3:], \n",
    "                #                    gt[3:]) \n",
    "\n",
    "                if iou > best_iou:\n",
    "                    best_iou = iou\n",
    "                    best_gt_idx = idx\n",
    "\n",
    "            if best_iou > iou_threshold:\n",
    "                # only detect ground truth detection once\n",
    "                if amount_bboxes[detection[0]][best_gt_idx] == 0:\n",
    "                    # true positive and add this bounding box to seen\n",
    "                    TP[detection_idx] = 1\n",
    "                    amount_bboxes[detection[0]][best_gt_idx] = 1\n",
    "                else:\n",
    "                    FP[detection_idx] = 1\n",
    "\n",
    "            # if IOU is lower then the detection is a false positive\n",
    "            else:\n",
    "                FP[detection_idx] = 1\n",
    "\n",
    "        #print(f'True Positives class {c}: {TP}')\n",
    "        #print(f'False Positives class {c}: {FP}')\n",
    "\n",
    "        TP_cumsum = torch.cumsum(TP, dim=0)\n",
    "        FP_cumsum = torch.cumsum(FP, dim=0)\n",
    "        recalls = TP_cumsum / (total_true_bboxes + epsilon)\n",
    "        precisions = TP_cumsum / (TP_cumsum + FP_cumsum + epsilon)\n",
    "\n",
    "        if precisions.numel() > 0:\n",
    "            #cls_prec.update({c: precisions[-1].numpy()})\n",
    "            cls_prec.update({c: precisions[-1].item()})\n",
    "        else:\n",
    "            cls_prec.update({c: 0.})\n",
    "        if recalls.numel() > 0:\n",
    "            #cls_rec.update({c: recalls[-1].numpy()})\n",
    "            cls_rec.update({c: recalls[-1].item()})\n",
    "        else:\n",
    "            cls_rec.update({c: 0.})\n",
    "\n",
    "        precisions = torch.cat((torch.tensor([1]), precisions))\n",
    "        recalls = torch.cat((torch.tensor([0]), recalls))\n",
    "        # torch.trapz for numerical integration\n",
    "        average_precisions.append(torch.trapz(precisions, recalls))\n",
    "        avg_prec.update({c: torch.trapz(precisions, recalls)})\n",
    "\n",
    "    mAP = sum(average_precisions) / (len(average_precisions) + epsilon)\n",
    "\n",
    "    #return mAP, average_precisions, cls_prec, cls_rec\n",
    "    return (mAP, \n",
    "            avg_prec,\n",
    "            cls_prec, \n",
    "            cls_rec)\n",
    "\n",
    "\n",
    "def get_bboxes(\n",
    "    loader,\n",
    "    model,\n",
    "    SX,\n",
    "    SY,\n",
    "    B,\n",
    "    C,\n",
    "    mask,\n",
    "    iou_threshold,\n",
    "    threshold,\n",
    "    device,\n",
    "    box_format=\"midpoint\"):\n",
    "    \n",
    "    \n",
    "    all_pred_boxes = []\n",
    "    all_true_boxes = []\n",
    "\n",
    "    # make sure model is in eval before get bboxes\n",
    "    model.eval()\n",
    "    train_idx = 0\n",
    "\n",
    "    #for batch_idx, (imgs, labels, _, _) in enumerate(loader):\n",
    "    for batch_idx, (imgs, labels) in enumerate(loader):\n",
    "        imgs = imgs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            predictions = model(imgs)\n",
    "\n",
    "        batch_size = imgs.shape[0]\n",
    "        true_bboxes = outcell_2_outboxes(out_cells=labels, \n",
    "                                         SX=SX, SY=SY, B=B, C=C, \n",
    "                                         mask=mask, \n",
    "                                         device='cpu', # Changed to cpu\n",
    "                                         is_pred=False)\n",
    "        bboxes = outcell_2_outboxes(out_cells=predictions, \n",
    "                                    SX=SX, SY=SY, B=B, C=C, \n",
    "                                    mask=mask, \n",
    "                                    device='cpu', # Changed to cpu\n",
    "                                    is_pred=True)\n",
    "\n",
    "        for idx in range(batch_size):\n",
    "            #nms_boxes = nms_yv1(\n",
    "            nms_boxes = nms_yv1_getBBoxes(\n",
    "                bboxes[idx],\n",
    "                iou_threshold=iou_threshold,\n",
    "                threshold=threshold,\n",
    "                box_format=box_format, # Midpoint, to use iou_tensor inside\n",
    "            )\n",
    "\n",
    "\n",
    "            #if batch_idx == 0 and idx == 0:\n",
    "            #    plot_image(x[idx].permute(1,2,0).to(\"cpu\"), nms_boxes)\n",
    "            #    print(nms_boxes)\n",
    "\n",
    "            for nms_box in nms_boxes:\n",
    "                all_pred_boxes.append([train_idx] + nms_box)\n",
    "\n",
    "            for box in true_bboxes[idx]:\n",
    "                # many will get converted to 0 pred\n",
    "                if box[1] > threshold:\n",
    "                    all_true_boxes.append([train_idx] + box)\n",
    "\n",
    "            train_idx += 1\n",
    "\n",
    "    model.train()\n",
    "    return all_pred_boxes, all_true_boxes\n",
    "\n",
    "\n",
    "def outcell_2_outboxes(out_cells, SX, SY, B, C, mask, device, is_pred = True):\n",
    "    '''\n",
    "    Convert batch of cells to batch of boxes: out_cells must be of shape (BATCH_SIZE, SX, SY, B*5+C) \n",
    "        [xcel, ycel, w, h, conf, class_0, class_1] -> [pred_class, score, xc, yc, w, h]\n",
    "    \n",
    "    Arguments:\n",
    "        - out_cells: labels at loader output or predictions at model output\n",
    "            Format: [xcel, ycel, w, h, conf, class_0, class_1]\n",
    "    Return:\n",
    "        - all_bboxes: list of bounding boxes\n",
    "            Format: [[bboxes idx 0], [bboxes idx 1], ... [bboxes idx BATCH_SIZE-1]]\n",
    "    '''\n",
    "\n",
    "    out_cells = out_cells.to(device) # TAKE A LOOK TO CPU DECISION\n",
    "\n",
    "    out_cells[out_cells <= 0] = 0 # Zeroing all negative values. Avoid (-conf * -class_id) = +score\n",
    "    #out_cells[out_cells >= 1] = 1 # Clamping all values to 1. Avoid being out of the image. Maybe afterwards, although it does not hurt here.\n",
    "                                   # This is due to yolo2pixel transformation, which could led to out of image values, depending on (w, h)\n",
    "\n",
    "    batch_size = out_cells.shape[0]\n",
    "    if is_pred:\n",
    "        out_cells = out_cells.reshape(batch_size, SY, SX, B*5+C)\n",
    "    else:\n",
    "        out_cells = out_cells.reshape(batch_size, SY, SX, 5+C)\n",
    "    \n",
    "    # With 2 BBoxes, choose the one with highest confidence. How highest IOU, without label?\n",
    "    if (B>1 and is_pred):\n",
    "        '''\n",
    "        2 BB: [xcell, ycell, w, h, confidence_A, xcell, ycell, w, h, confidence_B, class_0, class_1]\n",
    "        '''\n",
    "        bbox1 = out_cells[..., :4]\n",
    "        bbox2 = out_cells[..., 5:9]\n",
    "        score = torch.cat((out_cells[..., 4:5],out_cells[..., 9:10]), dim=-1)\n",
    "        best_score, idx = torch.max(score, dim=-1, keepdim=True)\n",
    "\n",
    "        bestbbox = (1-idx)*bbox1 + idx*bbox2\n",
    "\n",
    "        #class_prob = a[..., 10:12] # Esto no hace falta, se hace debajo\n",
    "        #cls_pred = class_prob.argmax(dim=-1, keepdim=True)\n",
    "        out_cells = torch.cat((bestbbox, best_score, out_cells[..., 10:12]), dim=-1)\n",
    "        \n",
    "    \n",
    "    # All cells are converted to boxes. Format will be [xc, yc, w, h, conf, class_0, class_1]\n",
    "    boxes = cell2boxes(cells = out_cells, mask = mask)\n",
    "\n",
    "    # ================================================================================================================== #\n",
    "    #                                                                                                                    #\n",
    "    #     Convert [xc, yc, w, h, conf, class_0, class_1] to [pred_class, score, xc, yc, w, h]                            #\n",
    "    #         Identify class predicted: class_0 > class_1 ??? or the opposite                                            #\n",
    "    #         Multiply (conf * class_id) to get score and compare to threshold afterwards. It will be 1 for ground truth #\n",
    "    #                                                                                                                    #\n",
    "    # ================================================================================================================== #\n",
    "    classes = boxes[...,5:7].argmax(-1).unsqueeze(-1) # Indices of class predictes, matching class_id: index 0 -> smoke, class id = 0 // same for fire\n",
    "    #print(f'Tensor of classes predicted\\n {classes}')   \n",
    "    \n",
    "    # If SOFTMAX is used, there is no need to multiply conf * class_prob\n",
    "    # scores = ( boxes[...,4].unsqueeze(-1) ) * boxes[...,5:7] # score = confidence * [class_0_prob, class_1_prob]\n",
    "    # scores, _ = torch.max(scores, dim=-1, keepdim=True) # Get maximum values -> score of class predicted\n",
    "    scores = boxes[..., 4:5]\n",
    "    #print(f'Scores together\\n {scores}')     \n",
    "    \n",
    "    out_boxes = torch.concat((classes, scores, boxes[...,:4]), dim=-1) # Concat all data\n",
    "    #print(f'Final Output {out_boxes}')    \n",
    "\n",
    "    # =========================================== #\n",
    "    #                                             #\n",
    "    #             Convert boxes to List           #\n",
    "    #                                             #\n",
    "    #    [[bboxes idx 0] , [bboxes idx 1], etc]   #\n",
    "    #                                             #\n",
    "    # =========================================== #\n",
    "    all_bboxes = []\n",
    "\n",
    "    for ex_idx in range(batch_size):\n",
    "        bboxes = []\n",
    "\n",
    "#         for bbox_i in range(SX):\n",
    "#             for bbox_j in range(SY):\n",
    "#                 bboxes.append([x.item() for x in out_boxes[ex_idx, bbox_i, bbox_j, :]])\n",
    "        for bbox_i in range(SX):\n",
    "            for bbox_j in range(SY):\n",
    "                bboxes.append([x.item() for x in out_boxes[ex_idx, bbox_j, bbox_i, :]])     \n",
    "        all_bboxes.append(bboxes)\n",
    "    \n",
    "    return all_bboxes\n",
    "\n",
    "\n",
    "def cell2boxes(cells, mask):\n",
    "    '''\n",
    "    Converts cells to boxes using the cell2box_mask and broadcasting over batches\n",
    "    In targets, sum only when score = 1\n",
    "\n",
    "    Arguments:\n",
    "        - cells: cells to convert, as yield by Dataloader in batches\n",
    "        - mask: mask used for conversion\n",
    "\n",
    "    Return:\n",
    "        - cells converted to boxes\n",
    "    '''\n",
    "\n",
    "    #out_boxes = cells.clone().detach()\n",
    "    out_boxes = cells.detach().clone()\n",
    "    out_boxes[...,0:1] = (out_boxes[...,0:1] + mask[...,0:1])/SX \n",
    "    out_boxes[...,1:2] = (out_boxes[...,1:2] + mask[...,1:2])/SY \n",
    "\n",
    "    return out_boxes\n",
    "\n",
    "\n",
    "def plot_preds(ori_img, img_w, img_h, nms_preds, names, colors):\n",
    "    '''\n",
    "    It draws the bounding boxes over the image.\n",
    "\n",
    "    Arguments:\n",
    "        - ori_img: original image with no modification or letterbox\n",
    "        - nms_preds: Non Maximum Supression predictions [x0, y0, x1, y1, class_id, score]\n",
    "        - names: list of class names\n",
    "        - colors: list of colors asigned to each class in cv2 format (B,G,R)\n",
    "        - ratio: ratio of letterbox conversion\n",
    "        - dwdh: paddings of letterbox conversion\n",
    "\n",
    "    Returns:\n",
    "        - pic: picture with bounding boxes on top of original picture\n",
    "    '''\n",
    "    \n",
    "    pic = ori_img.copy()\n",
    "    \n",
    "    for i,(xc,yc,w,h,score,class_id) in enumerate(nms_preds):\n",
    "        box = np.array(yolo2pixel([xc,yc,w,h]))\n",
    "        box[0] = box[0]*img_w\n",
    "        box[1] = box[1]*img_h\n",
    "        box[2] = box[2]*img_w\n",
    "        box[3] = box[3]*img_h\n",
    "        box = box.round().astype(np.int32).tolist()\n",
    "        cls_id = int(class_id)\n",
    "        score = round(float(score),3)\n",
    "        name = names[cls_id]\n",
    "        color = colors[name]\n",
    "        name += ' '+str(score)\n",
    "        cv2.rectangle(pic,box[:2],box[2:],color,2) # 1 -> rectangle thickness\n",
    "        cv2.putText(pic,name,(box[0]+6, box[1] + 20),cv2.FONT_HERSHEY_SIMPLEX,0.4,[225, 255, 255],thickness=1)  # 0.5 -> font size\n",
    "\n",
    "    return pic\n",
    "\n",
    "def save_log(epochs, \n",
    "             train_total_loss,\n",
    "             train_box_loss,\n",
    "             train_class_loss,\n",
    "             train_confidence_loss,\n",
    "             train_noobj_loss,\n",
    "             train_mAP,\n",
    "             train_class_AP,\n",
    "             train_class_precision,\n",
    "             train_class_recall,\n",
    "             val_total_loss,\n",
    "             val_box_loss,\n",
    "             val_class_loss,\n",
    "             val_confidence_loss,\n",
    "             val_noobj_loss,\n",
    "             val_mAP,\n",
    "             val_class_AP,\n",
    "             val_class_precision,\n",
    "             val_class_recall,\n",
    "             log_file_dst):\n",
    "    \n",
    "    '''\n",
    "    Create a dictionary with all metrics\n",
    "    Save the dictionary as excel file with Pandas\n",
    "    '''\n",
    "    \n",
    "    epoch_range = range(epochs)\n",
    "    log_file = {}\n",
    "    log_file.update({\"epoch\": epoch_range})\n",
    "    \n",
    "    # Train Losses\n",
    "    log_file.update({\"train_total_loss\": train_total_loss})\n",
    "    log_file.update({\"train_box_loss\": train_box_loss})\n",
    "    log_file.update({\"train_class_loss\": train_class_loss})\n",
    "    log_file.update({\"train_confidence_loss\": train_confidence_loss})\n",
    "    log_file.update({\"train_noobj_loss\": train_noobj_loss})\n",
    "    \n",
    "    # Train mAP, Class AP, Precision, Recall\n",
    "    train_mAP_log = []\n",
    "    for e in train_mAP:\n",
    "        #train_mAP_log.append(e.numpy())\n",
    "        #train_mAP_log.append(e)\n",
    "        train_mAP_log.append(e.item())\n",
    "    log_file.update({\"train_mAP\": train_mAP_log})\n",
    "    \n",
    "    train_smk_AP = []\n",
    "    train_fire_AP = []\n",
    "    for e in train_class_AP:\n",
    "        #train_smk_AP.append(e[0].numpy())\n",
    "        #train_smk_AP.append(e[0])\n",
    "        train_smk_AP.append(e[0].item())\n",
    "        #train_fire_AP.append(e[1].numpy())\n",
    "        #train_fire_AP.append(e[1])\n",
    "        train_fire_AP.append(e[1].item())\n",
    "    log_file.update({\"train_smk_AP\": train_smk_AP})\n",
    "    log_file.update({\"train_fire_AP\": train_fire_AP})\n",
    "    \n",
    "    \n",
    "    train_smk_precision = []\n",
    "    train_fire_precision = []\n",
    "    for e in train_class_precision:\n",
    "        #train_smk_precision.append(e[0].numpy())\n",
    "        train_smk_precision.append(e[0])\n",
    "        #train_fire_precision.append(e[1].numpy())\n",
    "        train_fire_precision.append(e[1])\n",
    "    log_file.update({\"train_smk_precision\": train_smk_precision})\n",
    "    log_file.update({\"train_fire_precision\": train_fire_precision})\n",
    "        \n",
    "    train_smk_recall = []\n",
    "    train_fire_recall = []\n",
    "    for e in train_class_recall:\n",
    "        #train_smk_recall.append(e[0].numpy())\n",
    "        train_smk_recall.append(e[0])\n",
    "        #train_fire_recall.append(e[1].numpy())\n",
    "        train_fire_recall.append(e[1])\n",
    "    log_file.update({\"train_smk_recall\": train_smk_recall})\n",
    "    log_file.update({\"train_fire_recall\": train_fire_recall})\n",
    "    \n",
    "    # Validation Losses\n",
    "    log_file.update({\"val_total_loss\": val_total_loss})\n",
    "    log_file.update({\"val_box_loss\": val_box_loss})\n",
    "    log_file.update({\"val_class_loss\": val_class_loss})\n",
    "    log_file.update({\"val_confidence_loss\": val_confidence_loss})\n",
    "    log_file.update({\"val_noobj_loss\": val_noobj_loss})\n",
    "    \n",
    "    # Val mAP, Class AP, Precision, Recall\n",
    "    val_mAP_log = []\n",
    "    for e in val_mAP:\n",
    "        #val_mAP_log.append(e.numpy())\n",
    "        val_mAP_log.append(e.item())\n",
    "    log_file.update({\"val_mAP\": val_mAP_log})\n",
    "    \n",
    "    val_smk_AP = []\n",
    "    val_fire_AP = []\n",
    "    for e in val_class_AP:\n",
    "        val_smk_AP.append(e[0].item())\n",
    "        val_fire_AP.append(e[1].item())\n",
    "    log_file.update({\"val_smk_AP\": val_smk_AP})\n",
    "    log_file.update({\"val_fire_AP\": val_fire_AP})\n",
    "    \n",
    "    val_smk_precision = []\n",
    "    val_fire_precision = []\n",
    "    for e in val_class_precision:\n",
    "        val_smk_precision.append(e[0])\n",
    "        val_fire_precision.append(e[1])\n",
    "    log_file.update({\"val_smk_precision\": val_smk_precision})\n",
    "    log_file.update({\"val_fire_precision\": val_fire_precision})\n",
    "    \n",
    "    val_smk_recall = []\n",
    "    val_fire_recall = []\n",
    "    for e in val_class_recall:\n",
    "        val_smk_recall.append(e[0])\n",
    "        val_fire_recall.append(e[1])\n",
    "    log_file.update({\"val_smk_recall\": val_smk_recall})\n",
    "    log_file.update({\"val_fire_recall\": val_fire_recall})\n",
    "    \n",
    "    df = pd.DataFrame(log_file)\n",
    "    df.to_excel(log_file_dst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5891d5e-3ee7-45b3-ad2a-fe9d6c1ff00b",
   "metadata": {},
   "source": [
    "# Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b76e6703-39c8-41d1-940a-91c1de8c8809",
   "metadata": {},
   "source": [
    "# DFire"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c57d78ca-ac32-41b6-bff4-991135f5e9cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DFireDataset(Dataset):\n",
    "    '''\n",
    "    Creates a Pytorch Dataset to train the Yolov1 Network.\n",
    "    Encodes labels to match the format [xcell, ycell, w, h, confidence, class_0 (smoke), class_1 (fire)]\n",
    "        - Final encoding format is: [xcell, ycell, w, h, conf=1, smoke?, fire?]\n",
    "\n",
    "    Discard images when there are more than 1 object in the same cell\n",
    "    \n",
    "    Arguments:\n",
    "        - img_h:            image height\n",
    "        - img_w:            image width\n",
    "        - img_dir:          path to images folder\n",
    "        - label_dir:        path to labels folder\n",
    "        - SX:               number of cells in X axis (horizontal -> width)\n",
    "        - SY:               number of cells in Y axis (vertical -> height)\n",
    "        - C:                number of classes, 2 in this case\n",
    "        - transform:        transformation applied to input images -> Albumentations\n",
    "        - target_transform: transformation applied to labels -> nothing by default\n",
    "\n",
    "    Return:\n",
    "        - img:              1 image of the dataset\n",
    "        - target:           corresponding label encoded\n",
    "    '''\n",
    "\n",
    "    def __init__(self, img_h, img_w, img_dir, label_dir, \n",
    "                 SX, SY, C, \n",
    "                 transform=None, target_transform=None):\n",
    "        self.img_h = img_h\n",
    "        self.img_w = img_w\n",
    "        self.img_dir = img_dir\n",
    "        self.label_dir = label_dir\n",
    "        self.SX = SX\n",
    "        self.SY = SY\n",
    "        self.C = C\n",
    "        self.transform = transform\n",
    "        self.target_transform = target_transform\n",
    "\n",
    "        self.labels_list = sorted(\n",
    "            [\n",
    "                os.path.join(self.label_dir, file_name)\n",
    "                for file_name in os.listdir(self.label_dir)\n",
    "                if file_name.endswith(\".txt\")\n",
    "            ]\n",
    "        )\n",
    "        \n",
    "        self.images, self.bboxes, self.labels = self.__build_ds__(self.labels_list)\n",
    "        \n",
    "        self.num_samples = self.images.shape[0]\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.num_samples\n",
    "    \n",
    "    def __bbox_check__(self, bbox):\n",
    "        eps = 1e-6\n",
    "        \n",
    "        xc, yc, w, h = bbox[0], bbox[1], bbox[2], bbox[3]\n",
    "        xmin = xc - w/2\n",
    "        ymin = yc - h/2\n",
    "        xmax = xc + w/2\n",
    "        ymax = yc + h/2\n",
    "        \n",
    "        xmin = max(xmin, 0 + eps)\n",
    "        ymin = max(ymin, 0 + eps)\n",
    "        xmax = min(xmax, 1)\n",
    "        ymax = min(ymax, 1)\n",
    "        \n",
    "        bbox = np.array([ \n",
    "                (xmin+xmax)/2,\n",
    "                (ymin+ymax)/2,\n",
    "                xmax-xmin,\n",
    "                ymax-ymin\n",
    "                 ]).astype(np.float32)\n",
    "        \n",
    "        return bbox        \n",
    "\n",
    "\n",
    "    def __build_ds__(self, labels_list):\n",
    "        bboxes = []\n",
    "        labels = []\n",
    "        images = []\n",
    "        wrong_imgs = 0\n",
    "        overlapping_rem = 0\n",
    "        more_than_3 = 0\n",
    "                \n",
    "        for label in labels_list:\n",
    "            fname = Path(label).stem\n",
    "            image_path = self.img_dir + fname + '.jpg'   \n",
    "            #print(fname, image_path)\n",
    "                                   \n",
    "            if cv2.imread(image_path) is None:\n",
    "                print(f'{image_path} cannot be read by cv2 -> removed')\n",
    "                wrong_imgs += 1\n",
    "            \n",
    "            else:\n",
    "                \n",
    "                label_mtx = np.zeros((self.SY, self.SX))\n",
    "                overlapping_object = 0\n",
    "\n",
    "                one_bboxes = []\n",
    "                one_labels = []\n",
    "            \n",
    "                with open(label) as f:\n",
    "                    lines = f.readlines()\n",
    "\n",
    "                    # Restrict to 3 boxes per sample\n",
    "                    if len(lines) > 3:\n",
    "                        more_than_3 += 1\n",
    "                        continue\n",
    "                        \n",
    "                    for line in lines:\n",
    "                        class_id, x, y, w, h = line.strip().split()\n",
    "                        class_id = int(class_id)\n",
    "                        box = np.array([x, y, w, h]).astype(np.float32)\n",
    "                        x, y, w, h = box[0], box[1], box[2], box[3]\n",
    "                        box_ok = self.__bbox_check__([x, y, w, h])\n",
    "                        x, y, w, h = box_ok[0], box_ok[1], box_ok[2], box_ok[3]\n",
    "                        i, j = math.floor(y * self.SY), math.floor(x * self.SX)\n",
    "                        if label_mtx[i, j] == 1:\n",
    "                            overlapping_object = 1\n",
    "                            overlapping_rem += 1\n",
    "                            #print(f'Removed {label} due to overlapping object in cell {i, j}')\n",
    "                            break\n",
    "                        else:\n",
    "                            label_mtx[i, j] = 1\n",
    "                            one_bboxes.append([x, y, w, h])\n",
    "                            # smoke\n",
    "                            if class_id == 0:\n",
    "                                one_labels.append(0)\n",
    "                            # fire\n",
    "                            elif class_id == 1:\n",
    "                                one_labels.append(1)\n",
    "                            else:\n",
    "                                print(f'File {label} errored in cell {i, j}')\n",
    "\n",
    "                    if overlapping_object == 0:\n",
    "                        # Padding to SX*SY labels and bounding boxes, so you can store tensors\n",
    "                        # Label -1 indicates no box\n",
    "                        for idx in range(self.SX*self.SY - len(one_labels)):\n",
    "                            one_bboxes.append([0, 0, 0, 0])\n",
    "                            one_labels.append(-1)\n",
    "                        # print(f'\\nBboxes and Labels of image {image_path}')\n",
    "                        # print(\"Bboxes\")\n",
    "                        # for box in one_bboxes:\n",
    "                        #     print(box)\n",
    "                        # print(\"Labels\")\n",
    "                        # for label in one_labels:\n",
    "                        #     print(label)\n",
    "                        bboxes.append(one_bboxes)\n",
    "                        labels.append(one_labels)\n",
    "                        images.append(image_path)\n",
    "        \n",
    "        print(f'Removed wrong images: {wrong_imgs}')\n",
    "        print(f'Removed due to overlapping: {overlapping_rem}')\n",
    "        print(f'Removed due to more than 3: {more_than_3}')\n",
    "        logger.info(f'Removed wrong images: {wrong_imgs}')\n",
    "        logger.info(f'Removed due to overlapping: {overlapping_rem}')\n",
    "        logger.info(f'Removed due to more than 3: {more_than_3}')\n",
    "\n",
    "        labels_np = np.array(labels)\n",
    "        labels_tensor = torch.tensor(labels_np, dtype=torch.float32)\n",
    "        bboxes_np = np.array(bboxes)\n",
    "        bboxes_tensor = torch.tensor(bboxes_np, dtype=torch.float32)\n",
    "        images_array = np.array(images)\n",
    "        # print(f'Images array {images_array}')\n",
    "        # print(f'Bboxes tensor {bboxes_tensor}')\n",
    "        # print(f'Labels tensor {labels_tensor}')\n",
    "        \n",
    "        return images_array, bboxes_tensor, labels_tensor\n",
    "        #return images, bboxes, labels\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "\n",
    "        # Image processing\n",
    "        img_file = self.images[index]\n",
    "        img = cv2.imread(img_file)\n",
    "        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)   \n",
    "        #img = cv2.resize(img, (self.img_w, self.img_h), interpolation = cv2.INTER_NEAREST)\n",
    "\n",
    "        # Labels processing\n",
    "        bboxes = self.bboxes[index]\n",
    "        bboxes = bboxes[~torch.all(bboxes == torch.tensor([0,0,0,0]), dim=1)]\n",
    "        bboxes = bboxes.numpy().tolist()\n",
    "        #print(bboxes)\n",
    "        labels = self.labels[index]\n",
    "        labels = labels[labels != -1.]\n",
    "        labels = labels.numpy().tolist()\n",
    "        #print(f'Labels inside dataset {labels}')\n",
    "        \n",
    "        # Data Augmentation\n",
    "        if self.transform is not None:\n",
    "            try:\n",
    "                aug = self.transform(image=img, bboxes=bboxes, class_labels=labels)\n",
    "                img = aug['image']\n",
    "                bboxes = aug['bboxes']\n",
    "                labels = aug['class_labels']\n",
    "            except:\n",
    "                #print(f'Error trying to augment image {img_file}')\n",
    "                img = cv2.resize(img, (self.img_w, self.img_h), interpolation = cv2.INTER_NEAREST)\n",
    "                img = img / 255.\n",
    "                img = torch.tensor(img, dtype=torch.float32)\n",
    "                img = img.permute(2, 0, 1)\n",
    "        \n",
    "        label_mtx = np.zeros((self.SY, self.SX, 5+self.C))\n",
    "        \n",
    "        for box, label in zip(bboxes, labels):\n",
    "            class_id = int(label)\n",
    "            i, j = int(box[1]*self.SY), int(box[0]*self.SX)\n",
    "            xcell, ycell = box[0]*self.SX - j, box[1]*self.SY - i\n",
    "            label_mtx[i, j, :5] = [xcell, ycell, box[2], box[3], 1]\n",
    "            label_mtx[i, j, 5+class_id] = 1\n",
    "\n",
    "        label_mtx = torch.tensor(label_mtx, dtype=torch.float32)\n",
    "        \n",
    "        #return img, label_mtx, img_file\n",
    "        return img, label_mtx"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bee1de61-d47b-470c-8521-26823fee52f0",
   "metadata": {},
   "source": [
    "# DFS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "79dac75c-3e82-4be0-acde-dea4e7007e86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DFS number of samples: 9462\n",
      "DFS train samples: 7569\n",
      "DFS test samples: 1893\n"
     ]
    }
   ],
   "source": [
    "dfs_base_dir = 'ds2fire/dfs_xml/'\n",
    "dfs_images_dir = dfs_base_dir + 'images/'\n",
    "dfs_labels_dir = dfs_base_dir + 'labels/'\n",
    "\n",
    "\n",
    "# Get all txt file paths in path_annot and sort them\n",
    "dfs_xml_files = sorted(\n",
    "    [\n",
    "        os.path.join(dfs_labels_dir, file_name)\n",
    "        for file_name in os.listdir(dfs_labels_dir)\n",
    "        if file_name.endswith(\".xml\")\n",
    "    ]\n",
    ")\n",
    "\n",
    "dfs_len = len(dfs_xml_files)\n",
    "dfs_train_elements = int(dfs_len*0.8)\n",
    "dfs_test_elements = dfs_len - dfs_train_elements\n",
    "\n",
    "random.shuffle(dfs_xml_files)\n",
    "dfs_train_list = dfs_xml_files[:dfs_train_elements]\n",
    "dfs_test_list = dfs_xml_files[dfs_train_elements:]\n",
    "\n",
    "print(f'DFS number of samples: {dfs_len}')\n",
    "print(f'DFS train samples: {len(dfs_train_list)}')\n",
    "print(f'DFS test samples: {len(dfs_test_list)}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5564261d-60af-404b-9bda-ab4af2f44448",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DFSDataset(Dataset):\n",
    "    '''\n",
    "    Creates a Pytorch Dataset to train the Yolov1 Network.\n",
    "    Encodes labels to match the format [xcell, ycell, w, h, confidence, class_0 (smoke), class_1 (fire)]\n",
    "        - Final encoding format is: [xcell, ycell, w, h, conf=1, smoke?, fire?]\n",
    "\n",
    "    Discard images when there are more than 1 object in the same cell\n",
    "    \n",
    "    Arguments:\n",
    "        - img_h:            image height\n",
    "        - img_w:            image width\n",
    "        - img_dir:          path to images folder\n",
    "        - label_dir:        path to labels folder\n",
    "        - SX:               number of cells in X axis (horizontal -> width)\n",
    "        - SY:               number of cells in Y axis (vertical -> height)\n",
    "        - C:                number of classes, 2 in this case\n",
    "        - transform:        transformation applied to input images -> Albumentations\n",
    "        - target_transform: transformation applied to labels -> nothing by default\n",
    "\n",
    "    Return:\n",
    "        - img:              1 image of the dataset\n",
    "        - target:           corresponding label encoded\n",
    "    '''\n",
    "\n",
    "    def __init__(self, img_h, img_w, img_dir, labels_list, \n",
    "                 SX, SY, C, \n",
    "                 transform=None, target_transform=None):\n",
    "        self.img_h = img_h\n",
    "        self.img_w = img_w\n",
    "        self.img_dir = img_dir\n",
    "        self.labels_list = labels_list\n",
    "        self.SX = SX\n",
    "        self.SY = SY\n",
    "        self.C = C\n",
    "        self.transform = transform\n",
    "        self.target_transform = target_transform\n",
    "        \n",
    "        self.images, self.bboxes, self.labels = self.__build_ds__(self.labels_list)\n",
    "        \n",
    "        self.num_samples = self.images.shape[0]\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.num_samples\n",
    "    \n",
    "    def __bbox_check__(self, bbox):\n",
    "        eps = 1e-6\n",
    "        \n",
    "        xmin, ymin, xmax, ymax = bbox[0], bbox[1], bbox[2], bbox[3]\n",
    "        \n",
    "        xmin = max(xmin, 0 + eps)\n",
    "        ymin = max(ymin, 0 + eps)\n",
    "        xmax = min(xmax, 1)\n",
    "        ymax = min(ymax, 1)\n",
    "        \n",
    "        bbox = np.array([ \n",
    "                (xmin+xmax)/2,\n",
    "                (ymin+ymax)/2,\n",
    "                xmax-xmin,\n",
    "                ymax-ymin\n",
    "                 ]).astype(np.float32)\n",
    "        \n",
    "        return bbox        \n",
    "\n",
    "\n",
    "    def __build_ds__(self, labels_list):\n",
    "        bboxes = []\n",
    "        labels = []\n",
    "        images = []\n",
    "        wrong_imgs = 0\n",
    "        overlapping_rem = 0\n",
    "        more_than_3 = 0\n",
    "        \n",
    "        \n",
    "        for xml_file in labels_list:\n",
    "#             fname = Path(xml_file).stem\n",
    "#             image_path = self.img_dir + fname + '.jpg'   \n",
    "            #print(fname, image_path)\n",
    "            \n",
    "            tree = ET.parse(xml_file)\n",
    "            root = tree.getroot()\n",
    "\n",
    "            image_name = root.find(\"filename\").text\n",
    "            image_path = os.path.join(self.img_dir, image_name)\n",
    "            #print(image_name, image_path)\n",
    "            \n",
    "            if cv2.imread(image_path) is None:\n",
    "                print(f'{image_path} cannot be read by cv2 -> removed')\n",
    "                wrong_imgs += 1\n",
    "            \n",
    "            else:\n",
    "                overlapping_object = 0\n",
    "                more_than_3_in = 0\n",
    "\n",
    "                label_mtx = np.zeros((self.SY, self.SX))\n",
    "\n",
    "                size = root.find(\"size\")\n",
    "                img_w = float(size.find(\"width\").text)\n",
    "                img_h = float(size.find(\"height\").text)\n",
    "\n",
    "                one_bboxes = []\n",
    "                one_labels = []\n",
    "\n",
    "                for obj in root.iter(\"object\"):\n",
    "                    class_name = obj.find(\"name\").text\n",
    "                    if class_name == 'smoke':\n",
    "                        class_id = 0\n",
    "                        more_than_3_in += 1\n",
    "                    elif class_name == 'fire':\n",
    "                        class_id = 1\n",
    "                        more_than_3_in += 1\n",
    "                    else:\n",
    "                        continue \n",
    "                    bbox = obj.find(\"bndbox\")\n",
    "                    xmin = float(bbox.find(\"xmin\").text)/img_w\n",
    "                    ymin = float(bbox.find(\"ymin\").text)/img_h\n",
    "                    xmax = float(bbox.find(\"xmax\").text)/img_w\n",
    "                    ymax = float(bbox.find(\"ymax\").text)/img_h\n",
    "\n",
    "                    box = self.__bbox_check__([xmin, ymin, xmax, ymax])\n",
    "                    #print(f'Class: {class_name} - Class_id: {class_id}. Coords: x={x}, y={y}, w={w}, h={h}')\n",
    "\n",
    "                    x, y, w, h = box[0], box[1], box[2], box[3]\n",
    "                    i, j = math.floor(y * self.SY), math.floor(x * self.SX)\n",
    "                    if label_mtx[i, j] == 1:\n",
    "                        overlapping_object = 1\n",
    "                        overlapping_rem += 1\n",
    "                        break\n",
    "                    else:\n",
    "                        label_mtx[i, j] = 1\n",
    "                        one_bboxes.append([x, y, w, h])\n",
    "                        # smoke\n",
    "                        if class_id == 0:\n",
    "                            one_labels.append(0)\n",
    "                        # fire\n",
    "                        elif class_id == 1:\n",
    "                            one_labels.append(1)\n",
    "                        else:\n",
    "                            print(f'File {label} errored in cell {i, j}') \n",
    "                \n",
    "                if more_than_3_in > 3:\n",
    "                    more_than_3 += 1\n",
    "                    continue\n",
    "                \n",
    "                if (overlapping_object == 0) and (more_than_3_in < 4):\n",
    "                    # Padding to SX*SY labels and bounding boxes, so you can store tensors\n",
    "                    # Label -1 indicates no box\n",
    "                    for idx in range(self.SX*self.SY - len(one_labels)):\n",
    "                        one_bboxes.append([0, 0, 0, 0])\n",
    "                        one_labels.append(-1)\n",
    "                    # print(f'\\nBboxes and Labels of image {image_path}')\n",
    "                    # print(\"Bboxes\")\n",
    "                    # for box in one_bboxes:\n",
    "                    #     print(box)\n",
    "                    # print(\"Labels\")\n",
    "                    # for label in one_labels:\n",
    "                    #     print(label)\n",
    "                    bboxes.append(one_bboxes)\n",
    "                    labels.append(one_labels)\n",
    "                    images.append(image_path)\n",
    "\n",
    "        print(f'Removed wrong images: {wrong_imgs}')\n",
    "        print(f'Removed due to overlapping: {overlapping_rem}')\n",
    "        print(f'Removed due to more than 3: {more_than_3}')\n",
    "        logger.info(f'Removed wrong images: {wrong_imgs}')\n",
    "        logger.info(f'Removed due to overlapping: {overlapping_rem}')\n",
    "        logger.info(f'Removed due to more than 3: {more_than_3}')\n",
    "\n",
    "        labels_np = np.array(labels)\n",
    "        labels_tensor = torch.tensor(labels_np, dtype=torch.float32)\n",
    "        bboxes_np = np.array(bboxes)\n",
    "        bboxes_tensor = torch.tensor(bboxes_np, dtype=torch.float32)\n",
    "        images_array = np.array(images)\n",
    "        # print(f'Images array {images_array}')\n",
    "        # print(f'Bboxes tensor {bboxes_tensor}')\n",
    "        # print(f'Labels tensor {labels_tensor}')\n",
    "        \n",
    "        return images_array, bboxes_tensor, labels_tensor\n",
    "        #return images, bboxes, labels\n",
    "\n",
    "\n",
    " \n",
    "    def __getitem__(self, index):\n",
    "\n",
    "        # Image processing\n",
    "        img_file = self.images[index]\n",
    "        img = cv2.imread(img_file)\n",
    "        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)   \n",
    "        #img = cv2.resize(img, (self.img_w, self.img_h), interpolation = cv2.INTER_NEAREST)\n",
    "\n",
    "        # Labels processing\n",
    "        bboxes = self.bboxes[index]\n",
    "        bboxes = bboxes[~torch.all(bboxes == torch.tensor([0,0,0,0]), dim=1)]\n",
    "        bboxes = bboxes.numpy().tolist()\n",
    "        #print(bboxes)\n",
    "        labels = self.labels[index]\n",
    "        labels = labels[labels != -1.]\n",
    "        labels = labels.numpy().tolist()\n",
    "        #print(f'Labels inside dataset {labels}')\n",
    "        \n",
    "        # Data Augmentation\n",
    "        if self.transform is not None:\n",
    "            try:\n",
    "                aug = self.transform(image=img, bboxes=bboxes, class_labels=labels)\n",
    "                img = aug['image']\n",
    "                bboxes = aug['bboxes']\n",
    "                labels = aug['class_labels']\n",
    "            except:\n",
    "                #print(f'Error trying to augment image {img_file}')\n",
    "                img = cv2.resize(img, (self.img_w, self.img_h), interpolation = cv2.INTER_NEAREST)\n",
    "                img = img / 255.\n",
    "                img = torch.tensor(img, dtype=torch.float32)\n",
    "                img = img.permute(2, 0, 1)\n",
    "        \n",
    "        label_mtx = np.zeros((self.SY, self.SX, 5+self.C))\n",
    "        \n",
    "        for box, label in zip(bboxes, labels):\n",
    "            class_id = int(label)\n",
    "            i, j = int(box[1]*self.SY), int(box[0]*self.SX)\n",
    "            xcell, ycell = box[0]*self.SX - j, box[1]*self.SY - i\n",
    "            label_mtx[i, j, :5] = [xcell, ycell, box[2], box[3], 1]\n",
    "            label_mtx[i, j, 5+class_id] = 1\n",
    "\n",
    "        label_mtx = torch.tensor(label_mtx, dtype=torch.float32)\n",
    "        \n",
    "        #return img, label_mtx, img_file\n",
    "        return img, label_mtx"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec8b488d-9139-4a9e-8af5-de827368eff1",
   "metadata": {},
   "source": [
    "# Visualize some examples with a Test Train Loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1d709355-0e9b-4793-bbbc-35e59c93e77e",
   "metadata": {},
   "outputs": [],
   "source": [
    "view_dir = 'dfire4ex/train/'\n",
    "\n",
    "view_train_imgs = view_dir + 'images/'\n",
    "view_train_labels = view_dir + 'labels/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0adcae50-29e5-4ccd-a546-77bca415fdf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "VIEW_BATCH_SIZE = 16\n",
    "VIEW_NUM_WORKERS = 1\n",
    "VIEW_PIN_MEMORY = True\n",
    "\n",
    "VIEW_S = 7\n",
    "VIEW_C = 2\n",
    "VIEW_B = 1\n",
    "\n",
    "VIEW_IMG_W = 224\n",
    "VIEW_IMG_H = 224"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92020f5e-55c6-4ab9-be81-100e1dae17de",
   "metadata": {},
   "source": [
    "# Data Aug Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2186e383-3cf2-42b8-b704-7f478b099532",
   "metadata": {},
   "outputs": [],
   "source": [
    "view_transform = A.Compose([\n",
    "    A.HorizontalFlip(p=0.5),\n",
    "    A.RandomBrightnessContrast(p=0.5),\n",
    "    A.RandomSizedBBoxSafeCrop(height=int(1.4*VIEW_IMG_H),\n",
    "                              width= int(1.4*VIEW_IMG_W),\n",
    "                              erosion_rate=0.6,\n",
    "                              p=0.3),\n",
    "    A.HueSaturationValue(hue_shift_limit=10, p=0.2),\n",
    "    A.Blur(blur_limit=(3,3), p=0.2),\n",
    "    A.CLAHE(clip_limit=2.0, p=0.3),\n",
    "    # Shifting, scaling and rotation could dive 2 bbox inside same grid...\n",
    "    #A.ShiftScaleRotate(rotate_limit=5, p=0.2),\n",
    "    A.Resize(VIEW_IMG_H, VIEW_IMG_W, p=1),\n",
    "    #A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1),\n",
    "    ToTensorV2(p=1),\n",
    "], bbox_params=A.BboxParams(format='yolo', \n",
    "                            #min_area=6*6, \n",
    "                            #min_visibility=0.05, \n",
    "                            label_fields=['class_labels']))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81c4ce4e-d822-4277-84c9-0998d8738dc5",
   "metadata": {},
   "source": [
    "# DFS Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "063fe2e3-a1b4-489f-96e1-8031cfbd09c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removed wrong images: 0\n",
      "Removed due to overlapping: 63\n",
      "Removed due to more than 3: 298\n"
     ]
    }
   ],
   "source": [
    "logger.info('\\nBefore View Dataset Examples')\n",
    "\n",
    "view_dfs_dataset = DFSDataset(img_h = VIEW_IMG_H,\n",
    "                              img_w = VIEW_IMG_W,\n",
    "                              img_dir = dfs_images_dir,\n",
    "                              labels_list = dfs_test_list,\n",
    "                              SX = VIEW_S,\n",
    "                              SY = VIEW_S,\n",
    "                              C = VIEW_C,\n",
    "                              transform=view_transform)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "055a826a-f1b0-41b2-816b-fce4fed5f5b5",
   "metadata": {},
   "source": [
    "# View Loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "09f1e84b-dcbe-42d1-93bd-3c37ee0d755d",
   "metadata": {},
   "outputs": [],
   "source": [
    "view_loader = DataLoader(dataset=view_dfs_dataset,\n",
    "                         batch_size=VIEW_BATCH_SIZE,\n",
    "                         num_workers=VIEW_NUM_WORKERS,\n",
    "                         pin_memory=VIEW_PIN_MEMORY,\n",
    "                         shuffle=True,\n",
    "                         drop_last=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c89089a0-13b7-4248-b7cb-9b7228fa62c8",
   "metadata": {},
   "source": [
    "# Utils to Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b95cbbb1-2531-482e-9ecf-f78144210e4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_bboxes_from_label_mtx(label_mtx):\n",
    "\n",
    "    c2b_mtx = np.zeros((VIEW_S, VIEW_S, 2))\n",
    "    for j in range(VIEW_S):\n",
    "        for i in range(VIEW_S):\n",
    "            c2b_mtx[i, j, 0] = j\n",
    "            c2b_mtx[i, j, 1] = i\n",
    "\n",
    "    label_mtx = label_mtx.numpy()\n",
    "    label_xy = label_mtx[..., :2]\n",
    "    label_rest = label_mtx[..., 2:]\n",
    "\n",
    "    c2b_xy = (c2b_mtx+label_xy)/VIEW_S\n",
    "    out = np.concatenate((c2b_xy, label_rest), axis=-1)\n",
    "    #print(f'Concat out\\n {out}')\n",
    "\n",
    "    bboxes_list = np.reshape(out, (VIEW_S*VIEW_S, 5+VIEW_C))\n",
    "\n",
    "    bboxes_list = [bbox for bbox in bboxes_list.tolist() if bbox[4]==1]\n",
    "\n",
    "    return bboxes_list\n",
    "\n",
    "\n",
    "def plot_pytorch(ds_img, img_w, img_h, nms_preds):\n",
    "    '''\n",
    "    It draws the bounding boxes over the image.\n",
    "\n",
    "    Arguments:\n",
    "        - ori_img: original image with no modification or letterbox\n",
    "        - nms_preds: Non Maximum Supression predictions [x0, y0, x1, y1, class_id, score]\n",
    "        - names: list of class names\n",
    "        - colors: list of colors asigned to each class in cv2 format (B,G,R)\n",
    "        - ratio: ratio of letterbox conversion\n",
    "        - dwdh: paddings of letterbox conversion\n",
    "\n",
    "    Returns:\n",
    "        - pic: picture with bounding boxes on top of original picture\n",
    "    '''\n",
    "\n",
    "    names ={0: 'smoke', 1: 'fire'}\n",
    "    colors = {'smoke': (0,255,255), 'fire': (255,255,0)}\n",
    "    # NEVER remove copy() or use np.ascontiguousarray()\n",
    "    pic = ds_img.numpy().copy()       \n",
    "\n",
    "    for i,(xc,yc,w,h,score,smoke,fire) in enumerate(nms_preds):\n",
    "        xmin, ymin, xmax, ymax = xc - w/2, yc - h/2, xc + w/2, yc + h/2\n",
    "        box = np.array([xmin, ymin, xmax, ymax]).astype(np.float32)\n",
    "        box[0] = box[0]*img_w\n",
    "        box[1] = box[1]*img_h\n",
    "        box[2] = box[2]*img_w-1 # avoid out of limits due to rounding\n",
    "        box[3] = box[3]*img_h-1 # avoid out of limits due to rounding\n",
    "        box = box.round().astype(np.uint8).tolist()\n",
    "        if smoke == 1:\n",
    "            cls_id = 0\n",
    "        elif fire == 1:\n",
    "            cls_id = 1\n",
    "        else:\n",
    "            print(\"Error: no valid class\")\n",
    "        score = round(float(score),3)\n",
    "        name = names[cls_id]\n",
    "        color = colors[name]\n",
    "        name += ' '+str(score)\n",
    "        cv2.rectangle(pic, box[:2], box[2:], color, 1) \n",
    "        cv2.putText(pic,name,(box[0]+6, box[1] + 20),\n",
    "                    cv2.FONT_HERSHEY_SIMPLEX,0.4,[225, 255, 255],\n",
    "                    thickness=1)  # 0.5 -> font size\n",
    "\n",
    "    return pic"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31188003-ce10-432d-99ba-f8658141aa35",
   "metadata": {},
   "source": [
    "# Plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "52d065b7-b186-4d68-b558-96546ee48898",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_345278/3091386464.py:26: UserWarning: Tight layout not applied. tight_layout cannot make axes width small enough to accommodate all axes decorations\n",
      "  plt.tight_layout(w_pad=100)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 6400x3200 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#for i, (img, label_mtx, img_path) in enumerate(view_loader):\n",
    "\n",
    "plt.figure(figsize=(64, 32))\n",
    "\n",
    "for i, (img, label_mtx) in enumerate(view_loader):\n",
    "    #print(f'Batch id = {i}')\n",
    "\n",
    "    plt.subplots(2,4)\n",
    "\n",
    "    for idx in range(VIEW_BATCH_SIZE):\n",
    "        #print(f'Index inside batch = {idx}')\n",
    "        #print(img_path[idx])\n",
    "        bboxes = get_bboxes_from_label_mtx(label_mtx[idx])\n",
    "        #print(bboxes)\n",
    "        img_ds = plot_pytorch(img[idx].permute(1, 2, 0), \n",
    "                              VIEW_IMG_W, \n",
    "                              VIEW_IMG_H, \n",
    "                              bboxes)\n",
    "        plt.subplot(2, 4, idx+1)\n",
    "        plt.imshow(img_ds)\n",
    "        #plt.imshow(img[idx].permute(1, 2, 0))\n",
    "        \n",
    "        if (idx == 7):\n",
    "            break\n",
    "    #if (idx == 1):\n",
    "    plt.tight_layout(w_pad=100)\n",
    "    plt.show()\n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c108028-a23a-410d-8af0-2853e5b85f90",
   "metadata": {},
   "source": [
    "# BED"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f7209620-aa42-4946-aa62-9f645e07f926",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BED(nn.Module):\n",
    "    def __init__(self, num_classes, S, B, in_channels=3):\n",
    "        super(BED, self).__init__()\n",
    "        self.in_channels = in_channels\n",
    "        self.num_classes = num_classes\n",
    "        self.S = S\n",
    "        self.B = B\n",
    "        \n",
    "        self.model = self.__create_BED__()\n",
    "\n",
    "        \n",
    "    def __create_BED__(self):\n",
    "        BED_model = nn.Sequential(\n",
    "            # Conv2d [in_channels, out_channels, kernel_size, stride, padding, bias]\n",
    "\n",
    "            # CNNBlock 224x224\n",
    "            nn.Conv2d(self.in_channels, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 112x112\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.Conv2d(64, 24, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(24, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 56x56\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            # kernel = 1 in github\n",
    "            nn.Conv2d(24, 16, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(16, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            # kernel = 1 in github\n",
    "            nn.Conv2d(32, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 28x28\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.Conv2d(64, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 14x14\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2), \n",
    "            nn.Conv2d(64, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            # CNNBlock 7x7\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            # CNNBlock Out\n",
    "            nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 16, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(16, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(16, 16, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(16, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(16, self.B*5 + self.num_classes, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            \n",
    "        )\n",
    "        return BED_model\n",
    "        \n",
    "          \n",
    "\n",
    "    def _initialize_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_in',\n",
    "                    nonlinearity='relu'\n",
    "                )\n",
    "                if m.bias is not None:\n",
    "                        nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.normal_(m.weight, 0, 0.01)\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "\n",
    "    # [xc1, yc1, w1, h1, conf1, xc2, yc2, w2, h2, conf2, smoke, fire]\n",
    "    # [0 ................. 4,    5 ................ 9      10    11 ]\n",
    "    def forward(self, x):\n",
    "        x_out = self.model(x)\n",
    "        x = x_out.permute(0, 2, 3, 1)\n",
    "        if self.B == 1:\n",
    "            class_softmax = torch.softmax(x[..., 5:7], dim=-1)\n",
    "            x = torch.cat((torch.sigmoid(x[..., 0:5]), class_softmax), dim=-1)  \n",
    "        else:\n",
    "            class_softmax = torch.softmax(x[..., 10:12], dim=-1)\n",
    "            x = torch.cat((torch.sigmoid(x[..., 0:10]), class_softmax), dim=-1)\n",
    "        return x "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c98be1fe-8fc5-45c8-82a2-7270a058699f",
   "metadata": {},
   "source": [
    "# BIG BED"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "26f631ef-0823-4e9f-af72-e9a82d92b790",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BIG_BED(nn.Module):\n",
    "    def __init__(self, num_classes, S, B, in_channels=3):\n",
    "        super(BIG_BED, self).__init__()\n",
    "        self.in_channels = in_channels\n",
    "        self.num_classes = num_classes\n",
    "        self.S = S\n",
    "        self.B = B\n",
    "        \n",
    "        self.model = self.__create_BED__()\n",
    "\n",
    "        \n",
    "    def __create_BED__(self):\n",
    "        BED_model = nn.Sequential(\n",
    "            # Conv2d [in_channels, out_channels, kernel_size, stride, padding, bias]\n",
    "\n",
    "            # CNNBlock 224x224\n",
    "            nn.Conv2d(self.in_channels, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 112x112\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.Conv2d(128, 48, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(48, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 56x56\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            # kernel = 1 in github\n",
    "            nn.Conv2d(48, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            # kernel = 1 in github\n",
    "            nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 28x28\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "\n",
    "            # CNNBlock 14x14\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2), \n",
    "            nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(128, 64, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(64, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            # CNNBlock 7x7\n",
    "            nn.MaxPool2d(kernel_size=2, stride=2),\n",
    "            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            # CNNBlock Out\n",
    "            nn.Conv2d(128, 128, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(128, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(128, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, 32, kernel_size=1, stride=1, padding=0,  bias=False),\n",
    "            nn.BatchNorm2d(32, affine=False),\n",
    "            nn.ReLU(),\n",
    "            \n",
    "            nn.Conv2d(32, self.B*5 + self.num_classes, kernel_size=1, stride=1, padding=0,  bias=True),\n",
    "            \n",
    "        )\n",
    "        return BED_model\n",
    "        \n",
    "          \n",
    "\n",
    "    def _initialize_weights(self):\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Conv2d):\n",
    "                nn.init.kaiming_normal_(m.weight, mode='fan_in',\n",
    "                    nonlinearity='relu'\n",
    "                )\n",
    "                if m.bias is not None:\n",
    "                        nn.init.constant_(m.bias, 0)\n",
    "            elif isinstance(m, nn.Linear):\n",
    "                nn.init.normal_(m.weight, 0, 0.01)\n",
    "                nn.init.constant_(m.bias, 0)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x_out = self.model(x)\n",
    "        x = x_out.permute(0, 2, 3, 1)\n",
    "        if self.B == 1:\n",
    "            class_softmax = torch.softmax(x[..., 5:7], dim=-1)\n",
    "            out = torch.cat((torch.sigmoid(x[..., 0:5]), class_softmax), dim=-1)\n",
    "        else:\n",
    "            class_softmax = torch.softmax(x[..., 10:12], dim=-1)\n",
    "            out = torch.cat((torch.sigmoid(x[..., 0:10]), class_softmax), dim=-1)   \n",
    "        return out "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02fea177-6d98-47b4-9cce-8981461388ab",
   "metadata": {},
   "source": [
    "# Yolo Loss 2BB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "42606acc-7693-488f-8f8a-4609738c1739",
   "metadata": {},
   "outputs": [],
   "source": [
    "class YoloLossMSE_2BBox(nn.Module):\n",
    "    '''\n",
    "    Calculates Yolo V1 loss function, detailed in the paper\n",
    "\n",
    "    Prediction format [xcell, ycell, w, h, confidence, class_0, class_1]\n",
    "    Future update to 2 BB: [xcell, ycell, w, h, confidence_A, xcell, ycell, w, h, confidence_B, class_0, class_1]\n",
    "    '''\n",
    "\n",
    "    def __init__(self, SX, SY, B, C):\n",
    "        super(YoloLossMSE_2BBox, self).__init__()\n",
    "        \n",
    "        self.mse = nn.MSELoss(reduction=\"sum\")\n",
    "\n",
    "        self.SX = SX\n",
    "        self.SY = SY\n",
    "        self.B = B\n",
    "        self.C = C\n",
    "\n",
    "        self.lambda_coord = 5\n",
    "        self.lambda_noobj = 0.5\n",
    "        \n",
    "        self.last_box_xy = 0.0\n",
    "        self.last_box_wh = 0.0\n",
    "        self.last_obj = 0.0\n",
    "        self.last_noobj =0.0\n",
    "        self.last_class = 0.0\n",
    "\n",
    "    def forward(self, ground_truth, predictions):\n",
    "\n",
    "        #predictions = predictions.reshape(-1, self.SY, self.SX, self.B*5 + self.C)\n",
    "        assert predictions.shape == (BATCH_SIZE, self.SY, self.SX, self.B*5 + self.C) \n",
    "        assert ground_truth.shape == (BATCH_SIZE, self.SY, self.SX, 5 + self.C) \n",
    "        \n",
    "        # =========================== #\n",
    "        #        Exists Box?          #\n",
    "        # =========================== #\n",
    "        exists_box = ground_truth[..., 4:5] == 1\n",
    "        pred_box1 = exists_box*predictions[..., 0:4]\n",
    "        pred_box2 = exists_box*predictions[..., 5:9]\n",
    "        target_box = exists_box*ground_truth[..., :4]\n",
    "\n",
    "        # =========================== #\n",
    "        #            IOU              #\n",
    "        # =========================== #\n",
    "        # Calculate IoU for the two predicted bounding boxes with target bbox\n",
    "        iou1 = iou_tensor(boxes_preds=pred_box1, \n",
    "                   boxes_labels=target_box,\n",
    "                   box_format=\"midpoint\")\n",
    "        #print(f'IOU 1\\n{iou1}')\n",
    "        iou2 = iou_tensor(boxes_preds=pred_box2, \n",
    "                   boxes_labels=target_box,\n",
    "                   box_format=\"midpoint\")\n",
    "        #print(f'IOU 2\\n{iou2}')\n",
    "        ious = torch.cat([iou1, iou2], dim=-1)\n",
    "        #print(f'IOUs\\n{ious}')\n",
    "        \n",
    "        iou_maxes, best_boxes = torch.max(ious, keepdim=True, dim=-1)\n",
    "        pred_boxes = best_boxes*pred_box2[..., :4]+(1-best_boxes)*pred_box1[..., :4]\n",
    "\n",
    "        # =============== #\n",
    "        #   Center Loss   #\n",
    "        # =============== #\n",
    "        xy_loss = self.mse(pred_boxes[..., :2],\n",
    "                           target_box[..., :2])\n",
    "        self.last_box_xy = xy_loss.item()\n",
    "        #print('\\nCenter Loss', center_loss)\n",
    "\n",
    "        # ====================== #\n",
    "        #   Width, Height Loss   #\n",
    "        # ====================== #\n",
    "        # Use torch.sign to undo torch.abs and preserve gradient sign \n",
    "        wh_loss = self.mse(torch.sign(pred_boxes[..., 2:4])*torch.sqrt(torch.abs(pred_boxes[..., 2:4])+1e-6),\n",
    "                           torch.sqrt(target_box[..., 2:4]))\n",
    "        #print(f'WH Loss {wh_loss:.6f}')\n",
    "        self.last_box_wh = wh_loss.item()\n",
    "\n",
    "        # =================== #\n",
    "        #   Confidence Loss   #\n",
    "        # =================== #\n",
    "        conf_pred_box = exists_box*( best_boxes*predictions[..., 9:10] + (1-best_boxes) * predictions[..., 4:5])\n",
    "        #print(f'Conf pred boxes \\n {conf_pred_box}')\n",
    "        # conf_loss = self.mse(conf_pred_box,\n",
    "        #                      iou_maxes)\n",
    "        conf_loss = self.mse(conf_pred_box,\n",
    "                             exists_box*ground_truth[..., 4:5])\n",
    "        #print(f'Conf loss {conf_loss:.6f}')\n",
    "        self.last_obj = conf_loss.item()\n",
    "\n",
    "        # ================== #\n",
    "        #   No Object Loss   #\n",
    "        # ================== #\n",
    "        noobj_box1 = self.mse((~exists_box)*predictions[..., 4:5],\n",
    "                              (~exists_box)*ground_truth[..., 4:5])\n",
    "        noobj_box2 = self.mse((~exists_box)*predictions[..., 9:10],\n",
    "                              (~exists_box)*ground_truth[..., 4:5])    \n",
    "        noobj_loss = noobj_box1 + noobj_box2\n",
    "        #print(f'No Obj loss {noobj_loss:.6f}')\n",
    "        self.last_noobj = noobj_loss.item()\n",
    "\n",
    "        # ======================= #\n",
    "        #   Classification Loss   #\n",
    "        # ======================= #\n",
    "        class_loss = self.mse(exists_box*predictions[..., 10:12],\n",
    "                              exists_box*ground_truth[..., 5:7]) \n",
    "        #print(f'Class Loss {class_loss:.6f}')\n",
    "        self.last_class = class_loss.item()\n",
    "\n",
    "        # ============== #\n",
    "        #   Total Loss   #\n",
    "        # ============== #\n",
    "        total_loss = (\n",
    "            self.lambda_coord*(xy_loss + wh_loss)\n",
    "            + conf_loss\n",
    "            + self.lambda_noobj*noobj_loss \n",
    "            + class_loss\n",
    "        )\n",
    "\n",
    "        return total_loss\n",
    "\n",
    "    def get_last_losses(self):     \n",
    "        return (\n",
    "            5*self.last_box_xy,\n",
    "            5*self.last_box_wh,\n",
    "            self.last_obj,\n",
    "            0.5*self.last_noobj,\n",
    "            self.last_class\n",
    "            )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0707cc5-1db0-4a95-a183-cbad80adae89",
   "metadata": {},
   "source": [
    "# Train Loop Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4bada441-b601-4aa1-9274-ce50c616d1f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Train function\n",
    "'''\n",
    "def get_lr(optimizer):\n",
    "    for param_group in optimizer.param_groups:\n",
    "        return param_group['lr']\n",
    "\n",
    "def train_fn(loader, model, optimizer, loss_fn, device):\n",
    "    \n",
    "    print(f'Learning Rate = {get_lr(optimizer=optimizer)}\\n')\n",
    "    logger.info(f'Learning Rate = {get_lr(optimizer=optimizer)}')\n",
    "\n",
    "    model.train()\n",
    "    loop = tqdm(loader, desc='Training', leave=True)\n",
    "    train_mean_loss = []\n",
    "    mean_box_loss = []\n",
    "    mean_confidence_loss = []\n",
    "    mean_noobj_loss = []\n",
    "    mean_class_loss = []\n",
    "\n",
    "    for batch_idx, (x, y) in enumerate(loop):\n",
    "#     for batch_idx, (x, y) in enumerate(loader):\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        out = model(x)\n",
    "        train_loss = loss_fn(ground_truth=y, \n",
    "                             predictions=out)\n",
    "#         loss = loss_fn.forward(ground_truth=y, \n",
    "#                        predictions=out)\n",
    "        \n",
    "        # Gradient Descent\n",
    "        optimizer.zero_grad()\n",
    "        train_loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # update progress bar\n",
    "        #loop.set_postfix(loss=loss.item())\n",
    "        #print(f'Partial Train Loss: {loss.item()}')\n",
    "\n",
    "        xy_loss, wh_loss, obj_loss, noobj_loss, class_loss = loss_fn.get_last_losses()\n",
    "        # Appending each loss\n",
    "        train_mean_loss.append(train_loss.item())\n",
    "        box_loss = xy_loss + wh_loss\n",
    "        mean_box_loss.append(box_loss)\n",
    "        mean_confidence_loss.append(obj_loss)\n",
    "        mean_noobj_loss.append(noobj_loss)\n",
    "        mean_class_loss.append(class_loss)\n",
    "\n",
    "    train_mean_loss_out = sum(train_mean_loss)/len(train_mean_loss)\n",
    "    #print(\"\\nTRAIN losses\")\n",
    "    logger.info(\"\\nTRAIN losses\")\n",
    "#     print(f\"Mean total loss was {train_mean_loss_out:.3f}\") # TQDM prints last batch loss\n",
    "    mean_box_loss_out = sum(mean_box_loss)/len(mean_box_loss)\n",
    "    mean_confidence_loss_out = sum(mean_confidence_loss)/len(mean_confidence_loss)\n",
    "    mean_noobj_loss_out = sum(mean_noobj_loss)/len(mean_noobj_loss)\n",
    "    mean_class_loss_out = sum(mean_class_loss)/len(mean_class_loss)  \n",
    "#     print(f\"Mean box loss was {mean_box_loss_out:.3f}\") \n",
    "#     print(f\"Mean confidence loss was {mean_confidence_loss_out:.3f}\") \n",
    "#     print(f\"Mean noobj loss was {mean_noobj_loss_out:.3f}\") \n",
    "#     print(f\"Mean class loss was {mean_class_loss_out:.3f}\") \n",
    "\n",
    "    print(\"Total Loss\".ljust(12) + \"|\" + \n",
    "          \"Box Loss\".ljust(12) + \"|\" + \n",
    "          \"Conf Loss\".ljust(12) + \"|\" + \n",
    "          \"No Obj Loss\".ljust(12) + \"|\" + \n",
    "          \"Class Loss\".ljust(12))\n",
    "    print(\"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12))\n",
    "    print(f'{train_mean_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_box_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_confidence_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_noobj_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_class_loss_out:.3f}'.ljust(12) + \"\\n\")\n",
    "    \n",
    "    logger.info(\"Total Loss\".ljust(12) + \"|\" + \n",
    "                  \"Box Loss\".ljust(12) + \"|\" + \n",
    "                  \"Conf Loss\".ljust(12) + \"|\" + \n",
    "                  \"No Obj Loss\".ljust(12) + \"|\" + \n",
    "                  \"Class Loss\".ljust(12))\n",
    "    logger.info(\"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12))\n",
    "    logger.info(f'{train_mean_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_box_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_confidence_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_noobj_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_class_loss_out:.3f}'.ljust(12))\n",
    "    \n",
    "    return (train_mean_loss_out, \n",
    "            mean_box_loss_out, \n",
    "            mean_confidence_loss_out, \n",
    "            mean_noobj_loss_out, \n",
    "            mean_class_loss_out)\n",
    "    \n",
    "#     return train_mean_loss_out\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee0f4a05-7b83-45a0-8c9a-256d44095322",
   "metadata": {},
   "source": [
    "# Validation Loop Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "abce844b-bf71-40d1-a8e7-6a67c5e01a4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "Evaluation Function\n",
    "'''\n",
    "def eval_fn(loader, model, loss_fn, device):\n",
    "    \n",
    "    model.eval()\n",
    "    loop = tqdm(loader, desc='Validating', leave=True)\n",
    "    val_mean_loss = []\n",
    "    mean_box_loss = []\n",
    "    mean_confidence_loss = []\n",
    "    mean_noobj_loss = []\n",
    "    mean_class_loss = []\n",
    "\n",
    "    for batch_idx, (x, y) in enumerate(loop):\n",
    "#     for batch_idx, (x, y) in enumerate(loader):\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        out = model(x)\n",
    "        val_loss = loss_fn(ground_truth=y, \n",
    "                           predictions=out)\n",
    "#         loss = loss_fn.forward(ground_truth=y, \n",
    "#                                predictions=out)\n",
    "        \n",
    "        xy_loss, wh_loss, obj_loss, noobj_loss, class_loss = loss_fn.get_last_losses()\n",
    "        # Appending each loss\n",
    "        val_mean_loss.append(val_loss.item())\n",
    "        box_loss = xy_loss + wh_loss\n",
    "        mean_box_loss.append(box_loss)\n",
    "        mean_confidence_loss.append(obj_loss)\n",
    "        mean_noobj_loss.append(noobj_loss)\n",
    "        mean_class_loss.append(class_loss)\n",
    "        \n",
    "        # update progress bar\n",
    "        #loop.set_postfix(loss=loss.item())\n",
    "\n",
    "    val_mean_loss_out = sum(val_mean_loss)/len(val_mean_loss)\n",
    "    #print(\"\\nVAL losses\")\n",
    "    logger.info(\"\\nVAL losses\")\n",
    "#     print(f\"Mean total loss was {val_mean_loss_out:.3f}\") # TQDM prints last batch loss\n",
    "    mean_box_loss_out = sum(mean_box_loss)/len(mean_box_loss)\n",
    "    mean_confidence_loss_out = sum(mean_confidence_loss)/len(mean_confidence_loss)\n",
    "    mean_noobj_loss_out = sum(mean_noobj_loss)/len(mean_noobj_loss)\n",
    "    mean_class_loss_out = sum(mean_class_loss)/len(mean_class_loss)  \n",
    "#     print(f\"Mean box loss was {mean_box_loss_out:.3f}\") \n",
    "#     print(f\"Mean confidence loss was {mean_confidence_loss_out:.3f}\") \n",
    "#     print(f\"Mean noobj loss was {mean_noobj_loss_out:.3f}\") \n",
    "#     print(f\"Mean class loss was {mean_class_loss_out:.3f}\") \n",
    "\n",
    "    print(\"Total Loss\".ljust(12) + \"|\" + \n",
    "          \"Box Loss\".ljust(12) + \"|\" + \n",
    "          \"Conf Loss\".ljust(12) + \"|\" + \n",
    "          \"No Obj Loss\".ljust(12) + \"|\" + \n",
    "          \"Class Loss\".ljust(12))\n",
    "    print(\"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12) + \" \" + \n",
    "          \"------------\".ljust(12))\n",
    "    print(f'{val_mean_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_box_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_confidence_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_noobj_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "          f'{mean_class_loss_out:.3f}'.ljust(12))\n",
    "\n",
    "    logger.info(\"Total Loss\".ljust(12) + \"|\" + \n",
    "                  \"Box Loss\".ljust(12) + \"|\" + \n",
    "                  \"Conf Loss\".ljust(12) + \"|\" + \n",
    "                  \"No Obj Loss\".ljust(12) + \"|\" + \n",
    "                  \"Class Loss\".ljust(12))\n",
    "    logger.info(\"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12) + \" \" + \n",
    "                  \"------------\".ljust(12))\n",
    "    logger.info(f'{val_mean_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_box_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_confidence_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_noobj_loss_out:.3f}'.ljust(12) + \"|\" +\n",
    "                  f'{mean_class_loss_out:.3f}'.ljust(12))\n",
    "    \n",
    "    return (val_mean_loss_out, \n",
    "            mean_box_loss_out, \n",
    "            mean_confidence_loss_out, \n",
    "            mean_noobj_loss_out, \n",
    "            mean_class_loss_out)\n",
    "    \n",
    "#     return val_loss_out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d47f51-5c7b-434a-af27-a0e2596596bc",
   "metadata": {},
   "source": [
    "# Hyperparameters and Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "79142328-c910-4425-afd7-f6d38bd9baf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "''' ============================\n",
    "    Hyperparameters and More\n",
    "============================ '''\n",
    "\n",
    "#LEARNING_RATE = 5e-4\n",
    "LEARNING_RATE = 1e-3\n",
    "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "BATCH_SIZE = 64 \n",
    "#WEIGHT_DECAY = 5e-4\n",
    "WEIGHT_DECAY = 0\n",
    "EPOCHS = 110\n",
    "NUM_WORKERS = 2\n",
    "PIN_MEMORY = True\n",
    "#LOAD_MODEL = False\n",
    "#LOAD_MODEL_FILE = \"overfit.pth.tar\"\n",
    "\n",
    "TRAIN_IMG_DIR = train_imgs\n",
    "TRAIN_LABEL_DIR = train_labels\n",
    "EVAL_IMG_DIR = val_imgs\n",
    "EVAL_LABEL_DIR = val_labels\n",
    "\n",
    "LOG_FILE = \"log_file.xlsx\"\n",
    "\n",
    "IOU_THRES = 0.4\n",
    "THRESHOLD = 0.2\n",
    "\n",
    "''' ============================\n",
    "    Configuration\n",
    "============================ '''\n",
    "IMG_W = IMG_DIM['W']\n",
    "IMG_H = IMG_DIM['H']\n",
    "\n",
    "CELL_SIZE_X = 1/SX\n",
    "CELL_SIZE_Y = 1/SY\n",
    "\n",
    "\n",
    "''' ============================\n",
    "    Metrics\n",
    "============================ '''\n",
    "# mAP output\n",
    "## Train\n",
    "train_mAP = []\n",
    "train_class_AP = []\n",
    "train_class_precision = []\n",
    "train_class_recall = []\n",
    "## Val\n",
    "val_mAP = []\n",
    "val_class_AP = []\n",
    "val_class_precision = []\n",
    "val_class_recall = []\n",
    "\n",
    "# Loss output\n",
    "## Train\n",
    "train_total_loss = []\n",
    "train_box_loss = []\n",
    "train_confidence_loss = []\n",
    "train_noobj_loss = []\n",
    "train_class_loss = []\n",
    "## Val\n",
    "val_total_loss = []\n",
    "val_box_loss = []\n",
    "val_confidence_loss = []\n",
    "val_noobj_loss = []\n",
    "val_class_loss = []"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba95ccfe-a797-45cd-82bb-37bcc9af62ff",
   "metadata": {},
   "source": [
    "# Main Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "22ef85f5-39b7-473a-855b-0561de058bbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "\n",
    "    ''' ============================\n",
    "        Print Config Values\n",
    "    ============================ '''\n",
    "    print(f'Device: {DEVICE}')\n",
    "    print(f'Learning Rate: {LEARNING_RATE}')\n",
    "    print(f'Batch Size: {BATCH_SIZE}')\n",
    "    print(f'IMG DIMS: ({IMG_H}, {IMG_W})')\n",
    "    print(f'W: {IMG_W}\\nH: {IMG_H}')\n",
    "    print(f'SX: {SX}\\nSY: {SY}\\nB: {B}\\nC: {C}')\n",
    "    print(f'Cell size:\\n\\tx = {CELL_SIZE_X}\\n\\ty = {CELL_SIZE_Y}')\n",
    "\n",
    "    logger.info(f'Device: {DEVICE}')\n",
    "    logger.info(f'Learning Rate: {LEARNING_RATE}')\n",
    "    logger.info(f'Batch Size: {BATCH_SIZE}')\n",
    "    logger.info(f'IMG DIMS: ({IMG_H}, {IMG_W})')\n",
    "    logger.info(f'W: {IMG_W}\\nH: {IMG_H}')\n",
    "    logger.info(f'SX: {SX}\\nSY: {SY}\\nB: {B}\\nC: {C}')\n",
    "    logger.info(f'Cell size:\\n\\tx = {CELL_SIZE_X}\\n\\ty = {CELL_SIZE_Y}')\n",
    "\n",
    "    ''' ============================\n",
    "        Cell to Box Mask\n",
    "    ============================ '''\n",
    "    cell2box_mask = torch.zeros((SY, SX, 2))\n",
    "    for i in range(SY):\n",
    "        for j in range(SX):\n",
    "            cell2box_mask[i,j,0] = j\n",
    "            cell2box_mask[i,j,1] = i    \n",
    "#     print(cell2box_mask)\n",
    "#     print(\"\\n\")\n",
    "\n",
    "    ''' ======================================\n",
    "        SETUP: Model, Loss, Dataset, Loader\n",
    "    ====================================== '''\n",
    "    if IMG_W == 88:\n",
    "        print(\"Using Tinyssimo 88x88\")\n",
    "        logger.info(\"Using Tinyssimo 88x88\")\n",
    "        #model_tynss = Tinyssimo_fixed_88x88(num_classes=C).to(DEVICE)\n",
    "        model_tynss = Tinyssimo_fixed_88x88_BatchNorm(num_classes=C).to(DEVICE)\n",
    "        #model_tynss = Tinyssimo_fixed_88x88_NANO(num_classes=C).to(DEVICE)\n",
    "    elif IMG_W == 448:\n",
    "        print(\"Using Tinyssimo 448x448\")\n",
    "        logger.info(\"Using Tinyssimo 448x448\")\n",
    "        model_tynss = Tinyssimo_fixed_448x448(num_classes=C).to(DEVICE)\n",
    "    elif IMG_W == 224:\n",
    "        print(\"Using BED 224x224\")\n",
    "        logger.info(\"Using BED 224x224\")\n",
    "        model_tynss = BIG_BED(num_classes = C,\n",
    "                          S = SX,\n",
    "                          B = B,\n",
    "                          in_channels = 3).to(DEVICE)\n",
    "    else:\n",
    "        print(\"Using Tinyssimo 160x120\")\n",
    "        logger.info(\"Using Tinyssimo 160x120\")\n",
    "        model_tynss = Tinyssimo_fixed_160x120(num_classes=C).to(DEVICE)\n",
    "    \n",
    "    model_tynss._initialize_weights()\n",
    "\n",
    "    # Check model shape\n",
    "    in_rand_np = np.random.rand(4, 3, IMG_H, IMG_W)\n",
    "    in_rand = torch.tensor(in_rand_np, dtype=torch.float32, device=DEVICE)\n",
    "    out_test = model_tynss(in_rand)\n",
    "    print(f'Model shape is {out_test.shape}')\n",
    "    print(f'BED Model Arquitecture\\n{model_tynss}')\n",
    "    logger.info(f'Model shape is {out_test.shape}')\n",
    "    logger.info(f'BED Model Arquitecture\\n{model_tynss}')   \n",
    "    \n",
    "    optimizer = optim.Adam(model_tynss.parameters(), \n",
    "                           lr=LEARNING_RATE, \n",
    "                           weight_decay=WEIGHT_DECAY)\n",
    "    \n",
    "    # scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, \n",
    "    #                                                  mode='min',\n",
    "    #                                                  factor=0.9, \n",
    "    #                                                  patience=2, \n",
    "    #                                                  threshold=0.1, \n",
    "    #                                                  threshold_mode='abs',\n",
    "    #                                                  min_lr=1e-5)\n",
    "    \n",
    "\n",
    "    scheduler = CosineLrScheduler(optimizer, \n",
    "                                  total_num_epochs=EPOCHS, \n",
    "                                  num_update_steps_per_epoch=1, \n",
    "                                  num_warmup_epochs=10)\n",
    "\n",
    "    #     optimizer = torch.optim.SGD(model_tynss.parameters(), \n",
    "#                                 lr=LEARNING_RATE,\n",
    "#                                 momentum=0.9, \n",
    "#                                 weight_decay=WEIGHT_DECAY, \n",
    "#                                 nesterov=True)\n",
    "    \n",
    "    n_trainable = sum(p.numel() for p in model_tynss.parameters() if p.requires_grad)\n",
    "    print(f'\\nTrainable parameters = {n_trainable}')\n",
    "    logger.info(f'\\nTrainable parameters = {n_trainable}')\n",
    "\n",
    "    n_params = parameters_to_vector(model_tynss.parameters()).numel()\n",
    "    print(f'Total parameters = {n_params}\\n')\n",
    "    logger.info(f'Total parameters = {n_params}\\n')\n",
    "    \n",
    "    if B == 1:\n",
    "        print(f'Using YoloLossMSE')\n",
    "        logger.info(f'Using YoloLossMSE')\n",
    "        loss_fn = YoloLossMSE(SX=SX, \n",
    "                              SY=SY, \n",
    "                              B=B, \n",
    "                              C=C)\n",
    "    elif B == 2:\n",
    "        print(f'Using YoloLossMSE_2BBox')\n",
    "        logger.info(f'Using YoloLossMSE_2BBox')\n",
    "        loss_fn = YoloLossMSE_2BBox(SX=SX, \n",
    "                                    SY=SY, \n",
    "                                    B=B, \n",
    "                                    C=C)\n",
    "    else:\n",
    "        print(\"Wrong B bounding boxes configuration\")\n",
    "        logger.info(\"Wrong B bounding boxes configuration\")\n",
    "\n",
    "    train_transform = A.Compose([\n",
    "        A.HorizontalFlip(p=0.5),\n",
    "        A.RandomBrightnessContrast(p=0.5),\n",
    "        # If boxes are to close, it can remove some because they fall inside same cell\n",
    "        A.RandomSizedBBoxSafeCrop(height=int(1.4*IMG_H),\n",
    "                                  width= int(1.4*IMG_W),\n",
    "                                  erosion_rate=0.6,\n",
    "                                  p=0.3),\n",
    "        A.HueSaturationValue(hue_shift_limit=10, p=0.2),\n",
    "        A.Blur(blur_limit=(3,3), p=0.2),\n",
    "        A.CLAHE(clip_limit=2.0, p=0.3),\n",
    "            # Shifting, scaling and rotation could dive 2 bbox inside same grid...\n",
    "            #A.ShiftScaleRotate(rotate_limit=10, p=0.2),\n",
    "        A.Resize(IMG_H, IMG_W, p=1),\n",
    "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1),\n",
    "        ToTensorV2(p=1),\n",
    "    ], bbox_params=A.BboxParams(format='yolo', \n",
    "                                min_area=8*8, \n",
    "                                min_visibility=0.05, \n",
    "                                label_fields=['class_labels']))\n",
    "    # TRAIN\n",
    "    print(\"\\nTRAIN DFIRE dataset\")\n",
    "    logger.info(\"\\nTRAIN DFIRE dataset\")\n",
    "    train_dataset = DFireDataset(img_h = IMG_H,\n",
    "                                 img_w = IMG_W,\n",
    "                                 img_dir = TRAIN_IMG_DIR,\n",
    "                                 label_dir = TRAIN_LABEL_DIR,\n",
    "                                 SX = SX,\n",
    "                                 SY = SY,\n",
    "                                 C = C,\n",
    "                                 transform=train_transform)\n",
    "    \n",
    "    print(\"TRAIN DFS dataset\")\n",
    "    logger.info(\"TRAIN DFS dataset\")\n",
    "    train_dfs_dataset = DFSDataset(img_h = IMG_H,\n",
    "                                   img_w = IMG_W,\n",
    "                                   img_dir = dfs_images_dir,\n",
    "                                   labels_list = dfs_train_list,\n",
    "                                   SX = SX,\n",
    "                                   SY = SY,\n",
    "                                   C = C,\n",
    "                                   transform=train_transform)\n",
    "\n",
    "    print(\"Concatenate Train DFire and DFS datasets\")\n",
    "    logger.info(\"Concatenate Train DFire and DFS datasets\")\n",
    "    full_train_ds = torch.utils.data.ConcatDataset((train_dataset, train_dfs_dataset))\n",
    "    print(f'Train dataset len: {len(full_train_ds)}')\n",
    "    logger.info(f'Train dataset len: {len(full_train_ds)}')\n",
    "\n",
    "    \n",
    "    # VALIDATION\n",
    "    val_transform = A.Compose([\n",
    "        A.Resize(IMG_H, IMG_W, p=1),\n",
    "        A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1),\n",
    "        ToTensorV2(p=1),\n",
    "    ], bbox_params=A.BboxParams(format='yolo', label_fields=['class_labels']))\n",
    "    \n",
    "    print(\"\\nTEST DFire dataset\")\n",
    "    logger.info(\"\\nTEST DFire dataset\")\n",
    "    eval_dataset = DFireDataset(img_h = IMG_H,\n",
    "                                img_w = IMG_W,\n",
    "                                img_dir = EVAL_IMG_DIR,\n",
    "                                label_dir = EVAL_LABEL_DIR,\n",
    "                                SX = SX,\n",
    "                                SY = SY,\n",
    "                                C = C,\n",
    "                                transform=val_transform)\n",
    "    print(\"TEST DFS dataset\")\n",
    "    logger.info(\"TEST DFS dataset\")\n",
    "    test_dfs_dataset = DFSDataset(img_h = IMG_H,\n",
    "                                  img_w = IMG_W,\n",
    "                                  img_dir = dfs_images_dir,\n",
    "                                  labels_list = dfs_test_list,\n",
    "                                  SX = SX,\n",
    "                                  SY = SY,\n",
    "                                  C = C,\n",
    "                                  transform=val_transform)\n",
    "    \n",
    "    print(\"Concatenate Test DFire and DFS datasets\")\n",
    "    logger.info(\"Concatenate Test DFire and DFS datasets\")\n",
    "    full_test_ds = torch.utils.data.ConcatDataset((eval_dataset, test_dfs_dataset))\n",
    "    print(f'Test dataset len: {len(full_test_ds)}')\n",
    "    logger.info(f'Test dataset len: {len(full_test_ds)}')\n",
    "    \n",
    "    # LOADERS\n",
    "    train_loader = DataLoader(dataset=full_train_ds,\n",
    "                              batch_size=BATCH_SIZE,\n",
    "                              num_workers=NUM_WORKERS,\n",
    "                              pin_memory=PIN_MEMORY,\n",
    "                              shuffle=True,\n",
    "                              drop_last=True)\n",
    "\n",
    "    eval_loader = DataLoader(dataset=full_test_ds,\n",
    "                             batch_size=BATCH_SIZE,\n",
    "                             num_workers=NUM_WORKERS,\n",
    "                             pin_memory=PIN_MEMORY,\n",
    "                             shuffle=False,\n",
    "                             drop_last=True)\n",
    "\n",
    "\n",
    "    ''' ==============================================================\n",
    "                                TRAINING LOOP\n",
    "    ============================================================== '''\n",
    "    # Start with infinite validation loss\n",
    "    best_valid_loss = np.inf\n",
    "    best_mAP = -1\n",
    "\n",
    "    start = datetime.datetime.now()\n",
    "    start_time = start.strftime(\"%H:%M:%S\")\n",
    "    print(f'\\n***Start Training: {start_time}\\n')\n",
    "    logger.info(f'\\n***Start Training: {start_time}\\n')\n",
    "    \n",
    "    for epoch in range(EPOCHS):\n",
    "\n",
    "        print(f'\\n=== EPOCH {epoch}/{EPOCHS-1} ===')\n",
    "        logger.info(f'\\n=== EPOCH {epoch}/{EPOCHS-1} ===')\n",
    "        \n",
    "        # TRAINING\n",
    "        t_loss, b_loss, conf_loss, n_loss, cls_loss = train_fn(loader=train_loader, \n",
    "                                                               model=model_tynss, \n",
    "                                                               optimizer=optimizer, \n",
    "                                                               loss_fn=loss_fn,\n",
    "                                                               device=DEVICE)\n",
    "        # Appending Train Losses\n",
    "        train_total_loss.append(t_loss)\n",
    "        train_box_loss.append(b_loss)\n",
    "        train_confidence_loss.append(conf_loss)\n",
    "        train_noobj_loss.append(n_loss)\n",
    "        train_class_loss.append(cls_loss)\n",
    "        \n",
    "        ##### NO LOGS, ONLY TOTAL LOSS\n",
    "#         t_loss = train_fn(loader=train_loader, \n",
    "#                           model=model_tynss, \n",
    "#                           optimizer=optimizer, \n",
    "#                           loss_fn=loss_fn,\n",
    "#                           device=DEVICE)\n",
    "#         # Appending Train Losses\n",
    "#         train_total_loss.append(t_loss)\n",
    "\n",
    "\n",
    "        # TRAIN MEAN AVERAGE PRECISION\n",
    "        if ( (epoch+1) % 15 ) == 0:\n",
    "            pred_boxes, target_boxes = get_bboxes(loader=train_loader, \n",
    "                                                  model=model_tynss,\n",
    "                                                  SX=SX,\n",
    "                                                  SY=SY,\n",
    "                                                  B=B,\n",
    "                                                  C=C,\n",
    "                                                  mask=cell2box_mask,\n",
    "                                                  iou_threshold=IOU_THRES, \n",
    "                                                  threshold=THRESHOLD,\n",
    "                                                  device=DEVICE,\n",
    "                                                  box_format=\"midpoint\")\n",
    "\n",
    "            mean_avg_prec, avg_prec, cls_prec, cls_rec = mAP(pred_boxes=pred_boxes, \n",
    "                                                             true_boxes=target_boxes, \n",
    "                                                             iou_threshold=IOU_THRES, \n",
    "                                                             box_format=\"midpoint\",\n",
    "                                                             num_classes=C)\n",
    "\n",
    "            train_mAP.append(mean_avg_prec)\n",
    "            train_class_AP.append(avg_prec)   \n",
    "            train_class_precision.append(cls_prec)\n",
    "            train_class_recall.append(cls_rec)\n",
    "            print(f\"\\nTrain mAP: {mean_avg_prec:.3f}\")\n",
    "            logger.info(f\"\\nTrain mAP: {mean_avg_prec:.3f}\")\n",
    "        \n",
    "        # VALIDATING\n",
    "        with torch.no_grad():\n",
    "            v_loss, b_loss, conf_loss, n_loss, cls_loss = eval_fn(loader=eval_loader, \n",
    "                                                                  model=model_tynss,                         \n",
    "                                                                  loss_fn=loss_fn,\n",
    "                                                                  device=DEVICE)\n",
    "            # Appending Validation Losses\n",
    "            val_total_loss.append(v_loss)\n",
    "            val_box_loss.append(b_loss)\n",
    "            val_confidence_loss.append(conf_loss)\n",
    "            val_noobj_loss.append(n_loss)\n",
    "            val_class_loss.append(cls_loss)\n",
    "            \n",
    "            #scheduler.step(v_loss) # for reduce on plateau\n",
    "            scheduler.step() # for cosine with warmup\n",
    "            \n",
    "            ##### NO LOGS, ONLY TOTAL LOSS\n",
    "#             v_loss = eval_fn(loader=eval_loader, \n",
    "#                              model=model_tynss,                         \n",
    "#                              loss_fn=loss_fn,\n",
    "#                              device=DEVICE)\n",
    "#             # Appending Validation Losses\n",
    "#             val_total_loss.append(v_loss)\n",
    "\n",
    "            # VALIDATION MEAN AVERAGE PRECISION\n",
    "            if ( (epoch+1) % 5 ) == 0:\n",
    "                pred_boxes, target_boxes = get_bboxes(loader=eval_loader, \n",
    "                                                      model=model_tynss,\n",
    "                                                      SX=SX,\n",
    "                                                      SY=SY,\n",
    "                                                      B=B,\n",
    "                                                      C=C,\n",
    "                                                      mask=cell2box_mask,\n",
    "                                                      iou_threshold=IOU_THRES, \n",
    "                                                      threshold=THRESHOLD,\n",
    "                                                      device=DEVICE,\n",
    "                                                      box_format=\"midpoint\")\n",
    "\n",
    "                mean_avg_prec, avg_prec, cls_prec, cls_rec = mAP(pred_boxes=pred_boxes, \n",
    "                                                                 true_boxes=target_boxes, \n",
    "                                                                 iou_threshold=IOU_THRES, \n",
    "                                                                 box_format=\"midpoint\",\n",
    "                                                                 num_classes=C)\n",
    "\n",
    "                val_mAP.append(mean_avg_prec)\n",
    "                val_class_AP.append(avg_prec)   \n",
    "                val_class_precision.append(cls_prec)\n",
    "                val_class_recall.append(cls_rec)\n",
    "                print(f\"\\nValidation mAP: {mean_avg_prec:.3f}\")\n",
    "                logger.info(f\"\\nValidation mAP: {mean_avg_prec:.3f}\")\n",
    "\n",
    "                if best_mAP < mean_avg_prec:\n",
    "                    best_mAP = mean_avg_prec\n",
    "                    print(f\"\\nSaving model with new best val mAP: {best_mAP:.3f}\")\n",
    "                    logger.info(f\"\\nSaving model with new best val mAP: {best_mAP:.3f}\")\n",
    "                    torch.save({\n",
    "                        'epoch': epoch,\n",
    "                        'model_state_dict': model_tynss.state_dict(),\n",
    "                        'optimizer_state_dict': optimizer.state_dict(),}, log_path + 'bed_best_2BB_mAP.pt')  \n",
    "\n",
    "        if ( (epoch+1) % 5 ) == 0:\n",
    "            torch.save(model_tynss.state_dict(), log_path + 'bed_2BB_5epoch.pt')\n",
    "            \n",
    "        if best_valid_loss > v_loss:\n",
    "            best_valid_loss = v_loss\n",
    "            print(f\"\\nSaving model with new best validation loss: {best_valid_loss:.3f}\")\n",
    "            logger.info(f\"\\nSaving model with new best validation loss: {best_valid_loss:.3f}\")\n",
    "            torch.save(model_tynss.state_dict(), log_path + 'best_2BB.pt')     \n",
    "        \n",
    "    logger.info('Saving last model')   \n",
    "    torch.save(model_tynss.state_dict(), log_path + 'last_2BB.pt') \n",
    "    \n",
    "#     save_log(epochs=EPOCHS, \n",
    "#              train_total_loss=train_total_loss,\n",
    "#              train_box_loss=train_box_loss,\n",
    "#              train_class_loss=train_class_loss,\n",
    "#              train_confidence_loss=train_confidence_loss,\n",
    "#              train_noobj_loss=train_noobj_loss,\n",
    "#              train_mAP=train_mAP,\n",
    "#              train_class_AP=train_class_AP,\n",
    "#              train_class_precision=train_class_precision,\n",
    "#              train_class_recall=train_class_recall,\n",
    "#              val_total_loss=val_total_loss,\n",
    "#              val_box_loss=val_box_loss,\n",
    "#              val_class_loss=val_class_loss,\n",
    "#              val_confidence_loss=val_confidence_loss,\n",
    "#              val_noobj_loss=val_noobj_loss,\n",
    "#              val_mAP=val_mAP,\n",
    "#              val_class_AP=val_class_AP,\n",
    "#              val_class_precision=val_class_precision,\n",
    "#              val_class_recall=val_class_recall,\n",
    "#              log_file_dst=LOG_FILE)\n",
    "\n",
    "    end = datetime.datetime.now()\n",
    "    end_time = end.strftime(\"%H:%M:%S\")\n",
    "    print(f'\\n***Script finished: {end_time}\\n')  \n",
    "    print(f'Time elapsed: {end-start}')\n",
    "    logger.info(f'\\n***Script finished: {end_time}\\n')  \n",
    "    logger.info(f'Time elapsed: {end-start}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae580f4-e175-4035-a2f7-dabd179db9a3",
   "metadata": {},
   "source": [
    "# Main Execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28659625-6ba4-44ac-ad2c-576b16425dcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting script\n",
      "\n",
      "Device: cuda\n",
      "Learning Rate: 0.001\n",
      "Batch Size: 64\n",
      "IMG DIMS: (224, 224)\n",
      "W: 224\n",
      "H: 224\n",
      "SX: 7\n",
      "SY: 7\n",
      "B: 2\n",
      "C: 2\n",
      "Cell size:\n",
      "\tx = 0.14285714285714285\n",
      "\ty = 0.14285714285714285\n",
      "Using BED 224x224\n",
      "Model shape is torch.Size([4, 7, 7, 12])\n",
      "BED Model Arquitecture\n",
      "BIG_BED(\n",
      "  (model): Sequential(\n",
      "    (0): Conv2d(3, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (2): ReLU()\n",
      "    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (4): Conv2d(128, 48, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (5): BatchNorm2d(48, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (6): ReLU()\n",
      "    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (8): Conv2d(48, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (9): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (10): ReLU()\n",
      "    (11): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (12): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (13): ReLU()\n",
      "    (14): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (15): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (16): ReLU()\n",
      "    (17): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (18): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (19): ReLU()\n",
      "    (20): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (21): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (22): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (23): ReLU()\n",
      "    (24): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (25): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (26): ReLU()\n",
      "    (27): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (28): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (29): ReLU()\n",
      "    (30): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (31): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (32): ReLU()\n",
      "    (33): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (34): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (35): ReLU()\n",
      "    (36): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (37): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (38): ReLU()\n",
      "    (39): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (40): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (41): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (42): ReLU()\n",
      "    (43): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (44): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (45): ReLU()\n",
      "    (46): Conv2d(128, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (47): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (48): ReLU()\n",
      "    (49): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (50): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (51): ReLU()\n",
      "    (52): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (53): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (54): ReLU()\n",
      "    (55): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (56): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (57): ReLU()\n",
      "    (58): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
      "    (59): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (60): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (61): ReLU()\n",
      "    (62): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
      "    (63): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (64): ReLU()\n",
      "    (65): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (66): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (67): ReLU()\n",
      "    (68): Conv2d(128, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (69): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (70): ReLU()\n",
      "    (71): Conv2d(32, 32, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
      "    (72): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=False, track_running_stats=True)\n",
      "    (73): ReLU()\n",
      "    (74): Conv2d(32, 12, kernel_size=(1, 1), stride=(1, 1))\n",
      "  )\n",
      ")\n",
      "\n",
      "Trainable parameters = 1177868\n",
      "Total parameters = 1177868\n",
      "\n",
      "Using YoloLossMSE_2BBox\n",
      "\n",
      "TRAIN DFIRE dataset\n",
      "Removed wrong images: 0\n",
      "Removed due to overlapping: 546\n",
      "Removed due to more than 3: 1764\n",
      "TRAIN DFS dataset\n",
      "Removed wrong images: 0\n",
      "Removed due to overlapping: 283\n",
      "Removed due to more than 3: 1210\n",
      "Concatenate Train DFire and DFS datasets\n",
      "Train dataset len: 21131\n",
      "\n",
      "TEST DFire dataset\n",
      "Removed wrong images: 0\n",
      "Removed due to overlapping: 118\n",
      "Removed due to more than 3: 445\n",
      "TEST DFS dataset\n",
      "Removed wrong images: 0\n",
      "Removed due to overlapping: 63\n",
      "Removed due to more than 3: 298\n",
      "Concatenate Test DFire and DFS datasets\n",
      "Test dataset len: 5311\n",
      "\n",
      "***Start Training: 20:23:16\n",
      "\n",
      "\n",
      "=== EPOCH 0/109 ===\n",
      "Learning Rate = 1e-06\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:15<00:00,  2.44it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "712.626     |97.263      |21.717      |560.716     |32.930      \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:23<00:00,  3.43it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "725.436     |106.904     |21.982      |563.753     |32.798      \n",
      "\n",
      "Saving model with new best validation loss: 725.436\n",
      "\n",
      "=== EPOCH 1/109 ===\n",
      "Learning Rate = 1e-06\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:15<00:00,  2.43it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "688.408     |97.018      |22.061      |537.175     |32.154      \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:24<00:00,  3.31it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "729.381     |106.920     |21.953      |567.664     |32.844      \n",
      "\n",
      "=== EPOCH 2/109 ===\n",
      "Learning Rate = 0.00010090000000000001\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:13<00:00,  2.48it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "378.889     |83.705      |29.902      |241.603     |23.679      \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:23<00:00,  3.52it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "269.589     |81.320      |34.219      |134.461     |19.589      \n",
      "\n",
      "Saving model with new best validation loss: 269.589\n",
      "\n",
      "=== EPOCH 3/109 ===\n",
      "Learning Rate = 0.00020080000000000003\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:14<00:00,  2.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "216.330     |70.180      |37.316      |91.382      |17.452      \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:24<00:00,  3.30it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "189.079     |66.180      |39.274      |69.784      |13.841      \n",
      "\n",
      "Saving model with new best validation loss: 189.079\n",
      "\n",
      "=== EPOCH 4/109 ===\n",
      "Learning Rate = 0.0003007000000000001\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:14<00:00,  2.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "162.896     |60.268      |41.026      |48.845      |12.757      \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:23<00:00,  3.46it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "144.119     |55.698      |42.802      |35.580      |10.039      \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "mAP:@.5: 100%|██████████| 2/2 [00:00<00:00,  2.25it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Validation mAP: 0.014\n",
      "\n",
      "Saving model with new best val mAP: 0.014\n",
      "\n",
      "Saving model with new best validation loss: 144.119\n",
      "\n",
      "=== EPOCH 5/109 ===\n",
      "Learning Rate = 0.0004006000000000001\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:13<00:00,  2.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "135.236     |52.028      |43.069      |29.469      |10.670      \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:24<00:00,  3.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "129.516     |49.441      |43.394      |27.695      |8.986       \n",
      "\n",
      "Saving model with new best validation loss: 129.516\n",
      "\n",
      "=== EPOCH 6/109 ===\n",
      "Learning Rate = 0.0005005000000000001\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:15<00:00,  2.44it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "120.003     |47.249      |44.040      |19.501      |9.213       \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:23<00:00,  3.50it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "112.953     |44.431      |43.904      |17.195      |7.423       \n",
      "\n",
      "Saving model with new best validation loss: 112.953\n",
      "\n",
      "=== EPOCH 7/109 ===\n",
      "Learning Rate = 0.0006004000000000002\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:15<00:00,  2.44it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "110.833     |44.340      |44.356      |14.101      |8.036       \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:23<00:00,  3.48it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "104.396     |42.233      |43.860      |11.354      |6.948       \n",
      "\n",
      "Saving model with new best validation loss: 104.396\n",
      "\n",
      "=== EPOCH 8/109 ===\n",
      "Learning Rate = 0.0007003000000000002\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:14<00:00,  2.45it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "102.943     |41.344      |43.651      |10.470      |7.478       \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:24<00:00,  3.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "98.334      |39.085      |41.692      |11.496      |6.062       \n",
      "\n",
      "Saving model with new best validation loss: 98.334\n",
      "\n",
      "=== EPOCH 9/109 ===\n",
      "Learning Rate = 0.0008002000000000002\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:12<00:00,  2.49it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "97.664      |39.477      |42.419      |8.908       |6.860       \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating: 100%|██████████| 82/82 [00:23<00:00,  3.51it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "92.853      |38.215      |40.614      |8.682       |5.342       \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "mAP:@.5: 100%|██████████| 2/2 [00:01<00:00,  1.27it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Validation mAP: 0.105\n",
      "\n",
      "Saving model with new best val mAP: 0.105\n",
      "\n",
      "Saving model with new best validation loss: 92.853\n",
      "\n",
      "=== EPOCH 10/109 ===\n",
      "Learning Rate = 0.0009001000000000001\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Training: 100%|██████████| 330/330 [02:14<00:00,  2.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Loss  |Box Loss    |Conf Loss   |No Obj Loss |Class Loss  \n",
      "------------ ------------ ------------ ------------ ------------\n",
      "93.180      |37.205      |41.788      |7.888       |6.299       \n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Validating:   4%|▎         | 3/82 [00:01<00:48,  1.64it/s]"
     ]
    }
   ],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    print(\"Starting script\\n\")\n",
    "    logger.info(\"Starting script\\n\")\n",
    "    #print(torch.cuda.is_available())\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ebb2ee54-7f44-4ec5-a2e7-8b0f7aa7dda7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#plt.figure(figsize=(8,8))\n",
    "fig, axs = plt.subplots(2,3, figsize=(8, 5))\n",
    "fig.suptitle('BIG BED Loss & mAP', fontsize=15)\n",
    "\n",
    "plt.subplot(2,3,1)\n",
    "plt.plot(train_total_loss, label=\"train\")\n",
    "plt.plot(val_total_loss, label=\"val\")\n",
    "plt.title(\"Total Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2,3,2)\n",
    "plt.plot(train_box_loss, label=\"train\")\n",
    "plt.plot(val_box_loss, label=\"val\")\n",
    "plt.title(\"Box Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2,3,3)\n",
    "plt.plot(train_confidence_loss, label=\"train\")\n",
    "plt.plot(val_confidence_loss, label=\"val\")\n",
    "plt.title(\"Confidence Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2,3,4)\n",
    "plt.plot(train_noobj_loss, label=\"train\")\n",
    "plt.plot(val_noobj_loss, label=\"val\")\n",
    "plt.title(\"NoObj Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2,3,5)\n",
    "plt.plot(train_class_loss, label=\"train\")\n",
    "plt.plot(val_class_loss, label=\"val\")\n",
    "plt.title(\"Class Loss\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.subplot(2,3,6)\n",
    "plt.plot(val_mAP, label=\"val mAP\")\n",
    "plt.title(\"Val mAP\")\n",
    "plt.ylim([0,1])\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"mAP:@.50\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(log_path + \"bed_loss_map.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8191af27-dd22-4718-ab87-6f118df9e476",
   "metadata": {},
   "outputs": [],
   "source": [
    "# val_class_AP\n",
    "# val_class_precision\n",
    "# val_class_recall\n",
    "\n",
    "smoke_prec = []\n",
    "fire_prec = []\n",
    "for prec in val_class_precision:\n",
    "    smoke_prec.append(prec[0])\n",
    "    fire_prec.append(prec[1])\n",
    "\n",
    "smoke_recall = []\n",
    "fire_recall = []\n",
    "for rec in val_class_recall:\n",
    "    smoke_recall.append(rec[0])\n",
    "    fire_recall.append(rec[1])\n",
    "\n",
    "smoke_ap = []\n",
    "fire_ap = []\n",
    "for ap in val_class_AP:\n",
    "    smoke_ap.append(ap[0])\n",
    "    fire_ap.append(ap[1])\n",
    "\n",
    "fig, axs = plt.subplots(1, 2, figsize=(8, 3))\n",
    "fig.suptitle('BIG BED precision, recall, class AP')\n",
    "\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(smoke_prec, label=\"smoke\")\n",
    "plt.plot(fire_prec, label=\"fire\")\n",
    "plt.title(\"Precision\")\n",
    "plt.ylim([0,1])\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(smoke_recall, label=\"smoke\")\n",
    "plt.plot(fire_recall, label=\"fire\")\n",
    "plt.title(\"Recall\")\n",
    "plt.ylim([0,1])\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(smoke_ap, label=\"smoke\")\n",
    "plt.plot(fire_ap, label=\"fire\")\n",
    "plt.title(\"Class AP\")\n",
    "plt.ylim([0,1])\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(log_path + \"bed_precision_recall_classAP.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab478d8e-df7f-4977-a5cb-d050b8de5d6b",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}