yolov5_based/inference_all.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "96050423-1a12-4fd6-b931-71e537077846",
   "metadata": {},
   "source": [
    "# Yolov5 Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1ce6684d-849c-4ee4-93a3-0806f5596fdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "# os.environ[\"CUDA_VISIBLE_DEVICES\"]=\"0\"\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import natsort\n",
    "import pandas as pd\n",
    "import cv2\n",
    "import json\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "\n",
    "from mmcv import Config\n",
    "from mmdet.apis import async_inference_detector, inference_detector, show_result_pyplot\n",
    "from mmdet.apis.inference import init_detector\n",
    "\n",
    "from ensemble_boxes import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8b8c52a2-ef85-40b1-af4c-146e57673bba",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_image_file_names(IMAGE_DIR):\n",
    "    \n",
    "    file_format = ['jpg']\n",
    "    \n",
    "    file_names = os.listdir(IMAGE_DIR)\n",
    "    image_file_names = []\n",
    "    for file_name in tqdm(file_names):\n",
    "        if file_name.split('.')[-1] in file_format:\n",
    "            image_file_names.append(file_name)\n",
    "   \n",
    "    return natsort.natsorted(image_file_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c39e287e-7521-4605-8675-ad98ec8156b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_json_data(label_path):\n",
    "    with open(label_path, encoding='utf-8-sig') as f:\n",
    "        json_data = json.load(f)\n",
    "    return json_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "845b3ce7-a93b-48aa-89f4-ca6c4edbe1e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_iou(pred_box, gt_box):\n",
    "    ixmin = max(pred_box[0], gt_box[0])\n",
    "    ixmax = min(pred_box[2], gt_box[2])\n",
    "    iymin = max(pred_box[1], gt_box[1])\n",
    "    iymax = min(pred_box[3], gt_box[3])\n",
    "    iw = np.maximum(ixmax-ixmin+1., 0.)\n",
    "    ih = np.maximum(iymax-iymin+1., 0.)\n",
    "    inters = iw*ih\n",
    "    uni = ((pred_box[2]-pred_box[0]+1.) * (pred_box[3]-pred_box[1]+1.) +\n",
    "           (gt_box[2] - gt_box[0] + 1.) * (gt_box[3] - gt_box[1] + 1.) -\n",
    "           inters)\n",
    "    iou = inters / uni\n",
    "    return iou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9c475ca0-e6e5-4e77-9a0d-8ce46b0fd617",
   "metadata": {},
   "outputs": [],
   "source": [
    "one_stage_checkpoints = ['/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/yt_x_800/best.pt', #best single\n",
    "                         '/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/yolov5x_928_augment_med/best (1).pt',\n",
    "                         '/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/GTX_3090_yolov5l6_1280_augment_high/best (2).pt',\n",
    "                         '/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/x_640/best (1) (1).pt',\n",
    "                         '/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/x_640_augment_high/best (3).pt'\n",
    "                        ]\n",
    "IMAGE_SIZES = [832, 928, 1280, 640, 640]\n",
    "\n",
    "two_stage_checkpoints = ['/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/india_vfnet_resnet101_train_all_aug/epoch_10.pth']\n",
    "\n",
    "two_stage_configs = ['/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/india_vfnet_resnet101_train_all_aug/india_vfnet_train_all_augment.py']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a961989-a32d-49cb-871b-261bf07dc2ee",
   "metadata": {},
   "source": [
    "## Load models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d01c1654-37be-4d7a-9694-a3cfe421f911",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "YOLOv5 🚀 v6.2-185-ge4398cf Python-3.7.11 torch-1.10.1 CUDA:0 (NVIDIA GeForce RTX 3090, 24267MiB)\n",
      "\n",
      "Fusing layers... \n",
      "Model summary: 444 layers, 86193601 parameters, 0 gradients, 203.8 GFLOPs\n",
      "Adding AutoShape... \n",
      "YOLOv5 🚀 v6.2-185-ge4398cf Python-3.7.11 torch-1.10.1 CUDA:0 (NVIDIA GeForce RTX 3090, 24267MiB)\n",
      "\n",
      "Fusing layers... \n",
      "Model summary: 444 layers, 86193601 parameters, 0 gradients, 203.8 GFLOPs\n",
      "Adding AutoShape... \n",
      "YOLOv5 🚀 v6.2-185-ge4398cf Python-3.7.11 torch-1.10.1 CUDA:0 (NVIDIA GeForce RTX 3090, 24267MiB)\n",
      "\n",
      "Fusing layers... \n",
      "Model summary: 476 layers, 76141740 parameters, 0 gradients, 109.9 GFLOPs\n",
      "Adding AutoShape... \n",
      "YOLOv5 🚀 v6.2-185-ge4398cf Python-3.7.11 torch-1.10.1 CUDA:0 (NVIDIA GeForce RTX 3090, 24267MiB)\n",
      "\n",
      "Fusing layers... \n",
      "Model summary: 444 layers, 86193601 parameters, 0 gradients, 203.8 GFLOPs\n",
      "Adding AutoShape... \n",
      "YOLOv5 🚀 v6.2-185-ge4398cf Python-3.7.11 torch-1.10.1 CUDA:0 (NVIDIA GeForce RTX 3090, 24267MiB)\n",
      "\n",
      "Fusing layers... \n",
      "Model summary: 444 layers, 86193601 parameters, 0 gradients, 203.8 GFLOPs\n",
      "Adding AutoShape... \n"
     ]
    }
   ],
   "source": [
    "one_stage_model_1 = torch.hub.load('.', 'custom', path=one_stage_checkpoints[0], source='local') \n",
    "one_stage_model_2 = torch.hub.load('.', 'custom', path=one_stage_checkpoints[1], source='local') \n",
    "one_stage_model_3 = torch.hub.load('.', 'custom', path=one_stage_checkpoints[2], source='local') \n",
    "one_stage_model_4 = torch.hub.load('.', 'custom', path=one_stage_checkpoints[3], source='local') \n",
    "one_stage_model_5 = torch.hub.load('.', 'custom', path=one_stage_checkpoints[4], source='local') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6ac8d701-0229-4f98-9e2d-e1dadb95523a",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "load checkpoint from local path: /media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/trained_weights/india_vfnet_resnet101_train_all_aug/epoch_10.pth\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-10-05 14:56:44,148 - root - INFO - ModulatedDeformConvPack backbone.layer2.0.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,487 - root - INFO - ModulatedDeformConvPack backbone.layer2.1.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,490 - root - INFO - ModulatedDeformConvPack backbone.layer2.2.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,492 - root - INFO - ModulatedDeformConvPack backbone.layer2.3.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,496 - root - INFO - ModulatedDeformConvPack backbone.layer3.0.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,501 - root - INFO - ModulatedDeformConvPack backbone.layer3.1.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,504 - root - INFO - ModulatedDeformConvPack backbone.layer3.2.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,507 - root - INFO - ModulatedDeformConvPack backbone.layer3.3.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,512 - root - INFO - ModulatedDeformConvPack backbone.layer3.4.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,515 - root - INFO - ModulatedDeformConvPack backbone.layer3.5.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,519 - root - INFO - ModulatedDeformConvPack backbone.layer3.6.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,522 - root - INFO - ModulatedDeformConvPack backbone.layer3.7.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,525 - root - INFO - ModulatedDeformConvPack backbone.layer3.8.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,529 - root - INFO - ModulatedDeformConvPack backbone.layer3.9.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,533 - root - INFO - ModulatedDeformConvPack backbone.layer3.10.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,536 - root - INFO - ModulatedDeformConvPack backbone.layer3.11.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,542 - root - INFO - ModulatedDeformConvPack backbone.layer3.12.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,547 - root - INFO - ModulatedDeformConvPack backbone.layer3.13.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,550 - root - INFO - ModulatedDeformConvPack backbone.layer3.14.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,554 - root - INFO - ModulatedDeformConvPack backbone.layer3.15.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,559 - root - INFO - ModulatedDeformConvPack backbone.layer3.16.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,562 - root - INFO - ModulatedDeformConvPack backbone.layer3.17.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,566 - root - INFO - ModulatedDeformConvPack backbone.layer3.18.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,570 - root - INFO - ModulatedDeformConvPack backbone.layer3.19.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,573 - root - INFO - ModulatedDeformConvPack backbone.layer3.20.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,576 - root - INFO - ModulatedDeformConvPack backbone.layer3.21.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,579 - root - INFO - ModulatedDeformConvPack backbone.layer3.22.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,583 - root - INFO - ModulatedDeformConvPack backbone.layer4.0.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,590 - root - INFO - ModulatedDeformConvPack backbone.layer4.1.conv2 is upgraded to version 2.\n",
      "2022-10-05 14:56:44,597 - root - INFO - ModulatedDeformConvPack backbone.layer4.2.conv2 is upgraded to version 2.\n"
     ]
    }
   ],
   "source": [
    "two_stage_model_1 = init_detector(two_stage_configs[0], two_stage_checkpoints[0], device='cuda:0')\n",
    "# two_stage_model_2 = init_detector(two_stage_configs[1], two_stage_checkpoints[1], device='cuda:0')\n",
    "# two_stage_model_3 = init_detector(two_stage_configs[2], two_stage_checkpoints[2], device='cuda:0')\n",
    "# two_stage_model_4 = init_detector(two_stage_configs[3], two_stage_checkpoints[3], device='cuda:0')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b6e675c-2aef-40b9-9bc1-b2ab7fec6b58",
   "metadata": {},
   "source": [
    "## Visualize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "88bc3117-0bc4-4dcb-b61e-4dbf3ea5538c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_pred_bboxes_size(pred_boxes, pred_labels, image):\n",
    "    image_shape = image.shape\n",
    "    for pred_label_num, pred_box in enumerate(pred_boxes):\n",
    "        # print(pred_box)\n",
    "        start_point = (int(pred_box[0]*image_shape[0]), int(pred_box[1]*image_shape[1]))\n",
    "        end_point =   (int(pred_box[2]*image_shape[0]), int(pred_box[3]*image_shape[1]))\n",
    "        class_id = pred_labels[pred_label_num]\n",
    "        image = cv2.rectangle(image, start_point, end_point,  color_dict[class_id], 10)\n",
    "        cv2.putText(image, class_dict_raw[class_id], start_point, \n",
    "                cv2.FONT_HERSHEY_SIMPLEX, 2, color_dict[class_id], 3, cv2.LINE_AA)\n",
    "    plt.imshow(image)\n",
    "    plt.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "76ea8b11-2bbf-4fa3-b142-38ee91962078",
   "metadata": {},
   "outputs": [],
   "source": [
    "def visualize_pred_bboxes(pred_boxes, pred_labels, image):\n",
    "    for pred_label_num, pred_box in enumerate(pred_boxes):\n",
    "        # print(pred_box)\n",
    "        start_point = (int(pred_box[0]), int(pred_box[1]))\n",
    "        end_point =   (int(pred_box[2]), int(pred_box[3]))\n",
    "        class_id = pred_labels[pred_label_num]\n",
    "        image = cv2.rectangle(image, start_point, end_point,  color_dict[class_id], 10)\n",
    "        cv2.putText(image, class_dict_raw[class_id], start_point, \n",
    "                cv2.FONT_HERSHEY_SIMPLEX, 2, color_dict[class_id], 3, cv2.LINE_AA)\n",
    "    plt.imshow(image)\n",
    "    plt.axis('off')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "46133044-7ba1-4e79-a32f-21dacf2358c2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_stage_convert2ensemble(model, image, IMAGE_SIZE, threshold = 0.2):\n",
    "    results = model(image.copy(), size = IMAGE_SIZE)\n",
    "    image_size = image.shape\n",
    "    extracted_results = results.xyxy[0]\n",
    "    pred_boxes = []\n",
    "    pred_labels = []\n",
    "    pred_scores = []\n",
    "    for pred_num in range(len(extracted_results)):\n",
    "        pred_score = extracted_results[pred_num][-2].item()\n",
    "        if pred_score >= threshold:\n",
    "            class_id = extracted_results[pred_num][-1].item()\n",
    "            temp_box = [extracted_results[pred_num][0].item()/image_size[1],\n",
    "                        extracted_results[pred_num][1].item()/image_size[0],\n",
    "                        extracted_results[pred_num][2].item()/image_size[1],\n",
    "                        extracted_results[pred_num][3].item()/image_size[0],\n",
    "                       ]\n",
    "            pred_score = extracted_results[pred_num][-2].item()\n",
    "            pred_boxes.append(temp_box)\n",
    "            pred_labels.append(int(class_id+1))\n",
    "            pred_scores.append(pred_score)\n",
    "    return pred_boxes, pred_labels, pred_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "29f1d48e-59bf-4e43-9de8-9b667f269930",
   "metadata": {},
   "outputs": [],
   "source": [
    "def two_stage_convert2ensemble(model, image, threshold = 0.4):\n",
    "    results = inference_detector(model, image)\n",
    "    image_size = image.shape\n",
    "    pred_boxes = []\n",
    "    pred_scores = []\n",
    "    pred_labels = []\n",
    "    for predicted_class in range(len(results)):\n",
    "        for preds in results[predicted_class]:\n",
    "            if preds[-1] >= threshold:\n",
    "                temp_box = preds[:4]\n",
    "                pred_boxes.append([temp_box[0]/image_size[1],\n",
    "                                   temp_box[1]/image_size[0],\n",
    "                                   temp_box[2]/image_size[1],\n",
    "                                   temp_box[3]/image_size[0]]\n",
    "                                   )\n",
    "                pred_score = preds[-1].astype(float)\n",
    "                pred_scores.append(pred_score)\n",
    "                pred_labels.append(int(predicted_class+1))\n",
    "    return pred_boxes, pred_labels, pred_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2f213267-01fe-42fc-a811-98849b934963",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ensemble_models(models, image, visualize = True):\n",
    "    image_size = image.shape\n",
    "    boxes_list_merges = []\n",
    "    labels_list_merges = []\n",
    "    scores_list_merges = []\n",
    "    for i, model in enumerate(models):\n",
    "        if model_types[i] == 1:\n",
    "            pred_boxes, pred_labels, pred_scores = one_stage_convert2ensemble(model, image, IMAGE_SIZES[i],  ONE_STAGE_THESHOLDS[i])\n",
    "            # print(ONE_STAGE_THESHOLDS[i])\n",
    "        elif model_types[i] == 2:\n",
    "            pred_boxes, pred_labels, pred_scores = two_stage_convert2ensemble(model, image, two_stage_model_threshold)\n",
    "            # print(pred_labels)\n",
    "        # Visualize each models\n",
    "#         print(\"Model: {}\".format(i))\n",
    "#         visualize_pred_bboxes_size(pred_boxes, pred_labels, image.copy())\n",
    "        # ensemble\n",
    "        boxes_list_merges.append(pred_boxes)\n",
    "        labels_list_merges.append(pred_labels)\n",
    "        scores_list_merges.append(pred_scores)\n",
    "    normalize_ensemble_boxes, ensemble_scores, normalize_ensemble_labels = weighted_boxes_fusion(boxes_list_merges, scores_list_merges, \n",
    "                                                      labels_list_merges, weights=weights, iou_thr=iou_thr, skip_box_thr=skip_box_thr)\n",
    "    ensemble_boxes = []\n",
    "    ensemble_labels = []\n",
    "    for i, predicted_box in enumerate(normalize_ensemble_boxes):\n",
    "        unnormalize_box = [predicted_box[0]*image_size[1],\n",
    "                         predicted_box[1]*image_size[0],\n",
    "                         predicted_box[2]*image_size[1],\n",
    "                         predicted_box[3]*image_size[0]]\n",
    "        ensemble_boxes.append(unnormalize_box)\n",
    "        ensemble_labels.append(int(normalize_ensemble_labels[i]))\n",
    "        \n",
    "        if visualize == True:\n",
    "            start_point = (int(unnormalize_box[0]), int(unnormalize_box[1]))\n",
    "            end_point =   (int(unnormalize_box[2]), int(unnormalize_box[3]))\n",
    "            image = cv2.rectangle(image, start_point, end_point,  color_dict[int(normalize_ensemble_labels[i])], 10)\n",
    "            cv2.putText(image, class_dict_raw[int(normalize_ensemble_labels[i])], start_point, \n",
    "                        cv2.FONT_HERSHEY_SIMPLEX, 2, color_dict[int(normalize_ensemble_labels[i])], 3, cv2.LINE_AA)\n",
    "    if visualize == True:\n",
    "        plt.imshow(image)\n",
    "        plt.show()\n",
    "        \n",
    "    return ensemble_boxes, ensemble_labels\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "90ae7d5c-a4fa-42e2-bd8e-39d0603a037e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class_dict_raw = {1:'D00',\n",
    "            2:'D10',\n",
    "            3:'D20',\n",
    "            4:'D40'}\n",
    "color_dict = {1:(255, 0, 0),\n",
    "            2:(255, 128, 0),\n",
    "            3:(255, 255, 0),\n",
    "            4:(128, 255, 0)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e50b5533-02eb-4da6-8c77-5bc3b0fafc10",
   "metadata": {},
   "outputs": [],
   "source": [
    "models = [one_stage_model_1,\n",
    "          one_stage_model_2,\n",
    "          one_stage_model_3,\n",
    "          one_stage_model_4,\n",
    "          one_stage_model_5,\n",
    "         two_stage_model_1,\n",
    "#          two_stage_model_2,\n",
    "         ]\n",
    "ONE_STAGE_THESHOLDS = [0.3,0.3,0.7,0.7,0.7]\n",
    "\n",
    "model_types = [1,1,1,1,1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "00b32c79-6caf-4cdd-a804-65501caa8b9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup confidence score\n",
    "one_stage_model_threshold = 0.6\n",
    "one_stage_model_1.conf = ONE_STAGE_THESHOLDS[0]\n",
    "one_stage_model_2.conf = ONE_STAGE_THESHOLDS[1]\n",
    "one_stage_model_3.conf = ONE_STAGE_THESHOLDS[2]\n",
    "one_stage_model_4.conf = ONE_STAGE_THESHOLDS[3]\n",
    "\n",
    "two_stage_model_threshold = 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5e841713-6354-476b-b064-7b44fb49ca63",
   "metadata": {},
   "outputs": [],
   "source": [
    "# WBF config\n",
    "weights = [2,2,1,1,1,1]\n",
    "\n",
    "iou_thr = 0.5\n",
    "skip_box_thr = 0.0001\n",
    "sigma = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f2d71850-9189-40d5-8316-8c6fca49a964",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8a09f11d-2b69-480f-bf50-2505245b5382",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                   | 0/264 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "India_009329.jpg\n",
      "GT\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PREDICTION and VISUALIZE\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                   | 0/264 [00:00<?, ?it/s]\n"
     ]
    }
   ],
   "source": [
    "country = 'India'\n",
    "IMAGE_DIR = \"/media/daitran/Data_SSD1/IEEE/data/{}/train/images\".format(country)\n",
    "json_path = '/media/daitran/Data_SSD1/IEEE/src/prepare_data/train_labels/{}/train/annotations/coco/test_balance.json'.format(country)\n",
    "json_data =get_json_data(json_path)\n",
    "for image_info in tqdm(json_data['images'][60:]):\n",
    "    print( image_info['file_name'])\n",
    "    image_id = image_info['id']\n",
    "    image_path = os.path.join(IMAGE_DIR, image_info['file_name'])\n",
    "    image = cv2.imread(image_path)\n",
    "    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "    # Load GT boxes and labels\n",
    "    gt_boxes = []\n",
    "    gt_labels = []\n",
    "    for annotation in json_data['annotations']:\n",
    "        if image_id == annotation['image_id']:\n",
    "            # print(annotation)\n",
    "            bbox = [annotation['bbox'][0],\n",
    "                    annotation['bbox'][1],\n",
    "                    annotation['bbox'][2]+annotation['bbox'][0],\n",
    "                    annotation['bbox'][3]+annotation['bbox'][1]]\n",
    "            class_id = annotation['category_id']\n",
    "            gt_boxes.append(bbox)\n",
    "            gt_labels.append(class_id)\n",
    "    # VISUALIZE\n",
    "    print(\"GT\")\n",
    "    visualize_pred_bboxes(gt_boxes, gt_labels, image.copy())\n",
    "    \n",
    "    print(\"PREDICTION and VISUALIZE\")\n",
    "    ensemble_boxes, ensemble_labels = ensemble_models(models, image, visualize = True)\n",
    "    \n",
    "    break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "992cfa02-3a47-46f1-9a7f-23e0778ace7d",
   "metadata": {},
   "source": [
    "## Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a904e5e4-d6b9-49b8-933a-e421c3806626",
   "metadata": {},
   "outputs": [],
   "source": [
    "def inference2submission(country = 'Norway'):\n",
    "    TEST_SET_DIR = '/media/daitran/Data_SSD1/IEEE/data/{}/test/images'.format(country)\n",
    "    test_image_file_names  = get_image_file_names(TEST_SET_DIR)\n",
    "    submission = pd.DataFrame(columns=['ImageId', 'PredictionString'])\n",
    "    for test_num, test_image_file_name in tqdm(enumerate(test_image_file_names)):\n",
    "        test_image_path = os.path.join(TEST_SET_DIR, test_image_file_name)\n",
    "        image = cv2.imread(test_image_path)\n",
    "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "        image_size = image.shape\n",
    "\n",
    "        ensemble_boxes, ensemble_labels = ensemble_models(models, image, visualize = False)\n",
    "        # visualize\n",
    "        # visualize_pred_bboxes(ensemble_boxes, ensemble_labels, image.copy())\n",
    "        # Submission\n",
    "        pred_str = ''\n",
    "        for pred_num, pred_box in enumerate(ensemble_boxes):\n",
    "            class_id = ensemble_labels[pred_num]\n",
    "            temp_box = pred_box\n",
    "            pred = '{} {} {} {} {} '.format(int(class_id),\n",
    "                                            int(temp_box[0]),\n",
    "                                            int(temp_box[1]),\n",
    "                                            int(temp_box[2]),\n",
    "                                            int(temp_box[3]))\n",
    "            pred_str = pred_str + pred\n",
    "        final_pred_str = pred_str[:-1] \n",
    "        submission.loc[test_num,'ImageId'] = test_image_file_name\n",
    "        submission.loc[test_num,'PredictionString'] = final_pred_str\n",
    "    # CONVERT TO TXT\n",
    "    data = submission\n",
    "    save_lines = []\n",
    "    for row_num in range(len(data)):\n",
    "        row = data.iloc[row_num]\n",
    "        if pd.isnull(row['PredictionString']):\n",
    "            temp_txt = '{},'.format(row['ImageId'])\n",
    "        else:\n",
    "            temp_txt = '{},{}'.format(row['ImageId'], row['PredictionString'])\n",
    "        save_lines.append(temp_txt)\n",
    "    with open('./results/{}_yolov5x.txt'.format(country), 'w') as f:\n",
    "        for line in save_lines:\n",
    "            f.write(line)\n",
    "            f.write('\\n')\n",
    "    return submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50700698-4548-4959-a07d-db10cad21537",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "130b5227-4ea4-4da4-9df9-c1232ac8de85",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████| 1959/1959 [00:00<00:00, 802093.08it/s]\n",
      "1959it [08:26,  3.87it/s]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "      <th>PredictionString</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>India_000004.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>India_000006.jpg</td>\n",
       "      <td>1 1 454 313 714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>India_000008.jpg</td>\n",
       "      <td>3 511 562 694 715</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>India_000009.jpg</td>\n",
       "      <td>1 279 455 344 510 3 262 473 679 662</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>India_000013.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1954</th>\n",
       "      <td>India_009857.jpg</td>\n",
       "      <td>3 426 445 565 595</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1955</th>\n",
       "      <td>India_009861.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1956</th>\n",
       "      <td>India_009862.jpg</td>\n",
       "      <td>4 371 316 417 352</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1957</th>\n",
       "      <td>India_009866.jpg</td>\n",
       "      <td>3 329 473 716 716</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1958</th>\n",
       "      <td>India_009870.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1959 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               ImageId                     PredictionString\n",
       "0     India_000004.jpg                                     \n",
       "1     India_000006.jpg                      1 1 454 313 714\n",
       "2     India_000008.jpg                    3 511 562 694 715\n",
       "3     India_000009.jpg  1 279 455 344 510 3 262 473 679 662\n",
       "4     India_000013.jpg                                     \n",
       "...                ...                                  ...\n",
       "1954  India_009857.jpg                    3 426 445 565 595\n",
       "1955  India_009861.jpg                                     \n",
       "1956  India_009862.jpg                    4 371 316 417 352\n",
       "1957  India_009866.jpg                    3 329 473 716 716\n",
       "1958  India_009870.jpg                                     \n",
       "\n",
       "[1959 rows x 2 columns]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inference2submission(country = 'India')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "c4a1b88b-5bdf-4f2f-ace6-88b737dee1a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████| 2627/2627 [00:00<00:00, 2556481.81it/s]\n",
      "2627it [11:02,  3.96it/s]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "      <th>PredictionString</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Japan_000007.jpg</td>\n",
       "      <td>2 88 312 311 340</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Japan_000016.jpg</td>\n",
       "      <td>1 12 384 149 551 1 75 516 141 573</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Japan_000021.jpg</td>\n",
       "      <td>1 265 411 392 597 2 205 324 272 337</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Japan_000039.jpg</td>\n",
       "      <td>4 425 436 479 468 4 397 380 435 401 3 4 396 43...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Japan_000047.jpg</td>\n",
       "      <td>3 409 426 599 599 3 113 419 335 599</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2622</th>\n",
       "      <td>Japan_013104.jpg</td>\n",
       "      <td>1 475 458 588 580 2 366 443 599 479 2 227 538 ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2623</th>\n",
       "      <td>Japan_013108.jpg</td>\n",
       "      <td>4 206 534 280 593 3 160 412 382 599</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2624</th>\n",
       "      <td>Japan_013118.jpg</td>\n",
       "      <td>3 160 405 263 480</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2625</th>\n",
       "      <td>Japan_013128.jpg</td>\n",
       "      <td>2 218 361 499 391 1 90 313 211 596 3 362 306 4...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2626</th>\n",
       "      <td>Japan_013130.jpg</td>\n",
       "      <td>1 291 329 313 410</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2627 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               ImageId                                   PredictionString\n",
       "0     Japan_000007.jpg                                   2 88 312 311 340\n",
       "1     Japan_000016.jpg                  1 12 384 149 551 1 75 516 141 573\n",
       "2     Japan_000021.jpg                1 265 411 392 597 2 205 324 272 337\n",
       "3     Japan_000039.jpg  4 425 436 479 468 4 397 380 435 401 3 4 396 43...\n",
       "4     Japan_000047.jpg                3 409 426 599 599 3 113 419 335 599\n",
       "...                ...                                                ...\n",
       "2622  Japan_013104.jpg  1 475 458 588 580 2 366 443 599 479 2 227 538 ...\n",
       "2623  Japan_013108.jpg                4 206 534 280 593 3 160 412 382 599\n",
       "2624  Japan_013118.jpg                                  3 160 405 263 480\n",
       "2625  Japan_013128.jpg  2 218 361 499 391 1 90 313 211 596 3 362 306 4...\n",
       "2626  Japan_013130.jpg                                  1 291 329 313 410\n",
       "\n",
       "[2627 rows x 2 columns]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inference2submission(country = 'Japan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "84db1a3d-54e9-4fdc-91ba-ff5365e0061e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████| 1200/1200 [00:00<00:00, 2402465.30it/s]\n",
      "1200it [05:07,  3.90it/s]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "      <th>PredictionString</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>United_States_004805.jpg</td>\n",
       "      <td>2 291 492 378 514 2 0 437 245 462</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>United_States_004806.jpg</td>\n",
       "      <td>2 473 583 638 627 3 74 382 398 585 2 388 535 5...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>United_States_004807.jpg</td>\n",
       "      <td>3 168 489 352 639 1 553 457 640 513</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>United_States_004808.jpg</td>\n",
       "      <td>1 364 476 404 592</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>United_States_004809.jpg</td>\n",
       "      <td>1 298 444 345 502 1 310 504 349 639 2 335 562 ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1195</th>\n",
       "      <td>United_States_006000.jpg</td>\n",
       "      <td>1 407 435 459 532 2 34 582 168 615 2 260 483 6...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1196</th>\n",
       "      <td>United_States_006001.jpg</td>\n",
       "      <td>2 219 446 610 492 1 61 402 266 620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1197</th>\n",
       "      <td>United_States_006002.jpg</td>\n",
       "      <td>2 221 464 344 505 1 45 429 79 500 3 106 391 17...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1198</th>\n",
       "      <td>United_States_006003.jpg</td>\n",
       "      <td>1 0 457 145 615 1 155 416 179 468</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1199</th>\n",
       "      <td>United_States_006004.jpg</td>\n",
       "      <td>1 417 414 639 534 3 0 416 111 622 1 240 408 29...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1200 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                       ImageId  \\\n",
       "0     United_States_004805.jpg   \n",
       "1     United_States_004806.jpg   \n",
       "2     United_States_004807.jpg   \n",
       "3     United_States_004808.jpg   \n",
       "4     United_States_004809.jpg   \n",
       "...                        ...   \n",
       "1195  United_States_006000.jpg   \n",
       "1196  United_States_006001.jpg   \n",
       "1197  United_States_006002.jpg   \n",
       "1198  United_States_006003.jpg   \n",
       "1199  United_States_006004.jpg   \n",
       "\n",
       "                                       PredictionString  \n",
       "0                     2 291 492 378 514 2 0 437 245 462  \n",
       "1     2 473 583 638 627 3 74 382 398 585 2 388 535 5...  \n",
       "2                   3 168 489 352 639 1 553 457 640 513  \n",
       "3                                     1 364 476 404 592  \n",
       "4     1 298 444 345 502 1 310 504 349 639 2 335 562 ...  \n",
       "...                                                 ...  \n",
       "1195  1 407 435 459 532 2 34 582 168 615 2 260 483 6...  \n",
       "1196                 2 219 446 610 492 1 61 402 266 620  \n",
       "1197  2 221 464 344 505 1 45 429 79 500 3 106 391 17...  \n",
       "1198                  1 0 457 145 615 1 155 416 179 468  \n",
       "1199  1 417 414 639 534 3 0 416 111 622 1 240 408 29...  \n",
       "\n",
       "[1200 rows x 2 columns]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inference2submission(country = 'United_States')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "28898ecc-ea3b-47cd-a876-04110b710556",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████| 709/709 [00:00<00:00, 2139396.79it/s]\n",
      "709it [02:55,  4.04it/s]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "      <th>PredictionString</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Czech_000003.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Czech_000004.jpg</td>\n",
       "      <td>1 59 389 240 512</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Czech_000005.jpg</td>\n",
       "      <td>1 99 416 126 493</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Czech_000008.jpg</td>\n",
       "      <td>2 57 467 193 495</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Czech_000016.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>704</th>\n",
       "      <td>Czech_003581.jpg</td>\n",
       "      <td>1 68 459 139 520 1 380 434 492 511 4 374 433 4...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>705</th>\n",
       "      <td>Czech_003582.jpg</td>\n",
       "      <td>1 1 437 143 511 1 212 392 252 434 1 244 459 28...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>706</th>\n",
       "      <td>Czech_003588.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>707</th>\n",
       "      <td>Czech_003590.jpg</td>\n",
       "      <td>3 313 398 459 525 3 0 412 242 516 3 140 415 24...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>708</th>\n",
       "      <td>Czech_003591.jpg</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>709 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "              ImageId                                   PredictionString\n",
       "0    Czech_000003.jpg                                                   \n",
       "1    Czech_000004.jpg                                   1 59 389 240 512\n",
       "2    Czech_000005.jpg                                   1 99 416 126 493\n",
       "3    Czech_000008.jpg                                   2 57 467 193 495\n",
       "4    Czech_000016.jpg                                                   \n",
       "..                ...                                                ...\n",
       "704  Czech_003581.jpg  1 68 459 139 520 1 380 434 492 511 4 374 433 4...\n",
       "705  Czech_003582.jpg  1 1 437 143 511 1 212 392 252 434 1 244 459 28...\n",
       "706  Czech_003588.jpg                                                   \n",
       "707  Czech_003590.jpg  3 313 398 459 525 3 0 412 242 516 3 140 415 24...\n",
       "708  Czech_003591.jpg                                                   \n",
       "\n",
       "[709 rows x 2 columns]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inference2submission(country = 'Czech')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "9c9c4855-b45e-43e5-923c-6bdb533bb348",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████| 500/500 [00:00<00:00, 1419872.71it/s]\n",
      "500it [02:00,  4.16it/s]\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "      <th>PredictionString</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>China_MotorBike_001977.jpg</td>\n",
       "      <td>2 13 270 500 393</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>China_MotorBike_001978.jpg</td>\n",
       "      <td>1 188 106 258 510 1 99 0 135 94 2 112 94 194 119</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>China_MotorBike_001979.jpg</td>\n",
       "      <td>1 146 66 197 100 1 136 103 201 271 1 196 287 2...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>China_MotorBike_001980.jpg</td>\n",
       "      <td>1 86 169 208 275 1 148 278 211 511 2 210 271 5...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>China_MotorBike_001981.jpg</td>\n",
       "      <td>1 287 193 427 509 1 28 136 200 509 1 366 124 5...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>495</th>\n",
       "      <td>China_MotorBike_002472.jpg</td>\n",
       "      <td>1 212 351 246 511 1 207 12 245 512</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>496</th>\n",
       "      <td>China_MotorBike_002473.jpg</td>\n",
       "      <td>1 340 6 511 121 3 109 122 340 377 1 0 227 106 313</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>497</th>\n",
       "      <td>China_MotorBike_002474.jpg</td>\n",
       "      <td>2 9 269 505 379</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>498</th>\n",
       "      <td>China_MotorBike_002475.jpg</td>\n",
       "      <td>3 2 309 494 511</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>499</th>\n",
       "      <td>China_MotorBike_002476.jpg</td>\n",
       "      <td>1 206 3 253 511</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>500 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                        ImageId  \\\n",
       "0    China_MotorBike_001977.jpg   \n",
       "1    China_MotorBike_001978.jpg   \n",
       "2    China_MotorBike_001979.jpg   \n",
       "3    China_MotorBike_001980.jpg   \n",
       "4    China_MotorBike_001981.jpg   \n",
       "..                          ...   \n",
       "495  China_MotorBike_002472.jpg   \n",
       "496  China_MotorBike_002473.jpg   \n",
       "497  China_MotorBike_002474.jpg   \n",
       "498  China_MotorBike_002475.jpg   \n",
       "499  China_MotorBike_002476.jpg   \n",
       "\n",
       "                                      PredictionString  \n",
       "0                                     2 13 270 500 393  \n",
       "1     1 188 106 258 510 1 99 0 135 94 2 112 94 194 119  \n",
       "2    1 146 66 197 100 1 136 103 201 271 1 196 287 2...  \n",
       "3    1 86 169 208 275 1 148 278 211 511 2 210 271 5...  \n",
       "4    1 287 193 427 509 1 28 136 200 509 1 366 124 5...  \n",
       "..                                                 ...  \n",
       "495                 1 212 351 246 511 1 207 12 245 512  \n",
       "496  1 340 6 511 121 3 109 122 340 377 1 0 227 106 313  \n",
       "497                                    2 9 269 505 379  \n",
       "498                                    3 2 309 494 511  \n",
       "499                                    1 206 3 253 511  \n",
       "\n",
       "[500 rows x 2 columns]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inference2submission(country = 'China_MotorBike')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "945f61a3-b70d-460f-8994-bbbe29ea009a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0d663de4-7315-434b-993c-4df1e4d7bb19",
   "metadata": {},
   "source": [
    "## Combine for all countries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8794c6f8-599a-489f-a53e-fa596235f264",
   "metadata": {},
   "outputs": [],
   "source": [
    "countries = ['India', 'Japan', 'United_States', 'Czech', 'China_MotorBike']\n",
    "combine_six_countries = []\n",
    "for country in countries:\n",
    "    result_path = '/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/yolov5_based/yolov5/results/{}_yolov5x.txt'.format(country)\n",
    "    # result = \n",
    "    with open(result_path) as f:\n",
    "        lines = f.readlines()\n",
    "    for line in lines:\n",
    "        combine_six_countries.append(line.strip())\n",
    "# Norway\n",
    "result_path = '/media/daitran/Data_SSD1/IEEE/github/CRDDC_2022_Code/mmdet_based/results/Norway_ensemble_update.txt'\n",
    "# result = \n",
    "with open(result_path) as f:\n",
    "    lines = f.readlines()\n",
    "for line in lines:\n",
    "    combine_six_countries.append(line.strip())\n",
    "with open('./results/overall_yolov5x_mmdet.txt', 'w') as f:\n",
    "    for line in combine_six_countries:\n",
    "        f.write(line)\n",
    "        f.write('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "090c809c-1017-42ff-831f-99482dcbe1d5",
   "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}