performance_eval_detection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pytorch version: 2.0.1\n"
     ]
    }
   ],
   "source": [
    "import sys, torch, os, json\n",
    "print(f\"pytorch version: {torch.__version__}\")\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "\n",
    "module_rootdir = '.'\n",
    "dataset_rootdir = '.'\n",
    "label_rootdir = module_rootdir\n",
    "sys.path.append(module_rootdir)\n",
    "\n",
    "trained_weights_path = './model_weights/gnn/1718175257362/graph_based_detector.pt'\n",
    "config_file_path = './configuration_radarscenes_gnn.yml'\n",
    "\n",
    "from modules.set_configurations.set_config_gnn import config\n",
    "from modules.data_utils.read_data import get_train_val_sequence_names, get_train_val_sequence_names_v2\n",
    "from modules.set_configurations.set_param_for_inference_gnn import set_parameters_for_inference\n",
    "from modules.data_utils.read_data import get_sequence_data\n",
    "from modules.data_utils.labels import compute_new_labels_to_id_dict\n",
    "from modules.data_utils.labels import compute_old_to_new_label_id_map\n",
    "from modules.performance.detection_accuracy import compute_gt_and_pred_objects, compute_gt_and_pred_associations\n",
    "\n",
    "save_model_performance_root_dir = './performance/object_classification'\n",
    "os.makedirs(save_model_performance_root_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train sequences\n",
      "['sequence_1', 'sequence_2', 'sequence_3', 'sequence_4', 'sequence_8', 'sequence_10', 'sequence_11', 'sequence_12', 'sequence_13', 'sequence_16', 'sequence_17', 'sequence_18', 'sequence_20', 'sequence_22', 'sequence_25', 'sequence_26', 'sequence_27', 'sequence_28', 'sequence_29', 'sequence_32', 'sequence_33', 'sequence_34', 'sequence_35', 'sequence_36', 'sequence_37', 'sequence_38', 'sequence_39', 'sequence_43', 'sequence_46', 'sequence_47', 'sequence_49', 'sequence_50', 'sequence_52', 'sequence_55', 'sequence_56', 'sequence_57', 'sequence_60', 'sequence_61', 'sequence_62', 'sequence_66', 'sequence_67', 'sequence_69', 'sequence_70', 'sequence_71', 'sequence_72', 'sequence_75', 'sequence_76', 'sequence_78', 'sequence_80', 'sequence_81', 'sequence_83', 'sequence_84', 'sequence_86', 'sequence_87', 'sequence_88', 'sequence_91', 'sequence_92', 'sequence_94', 'sequence_95', 'sequence_96', 'sequence_97', 'sequence_98', 'sequence_100', 'sequence_101', 'sequence_102', 'sequence_104', 'sequence_106', 'sequence_108', 'sequence_109', 'sequence_110', 'sequence_112', 'sequence_114', 'sequence_116', 'sequence_117', 'sequence_118', 'sequence_119', 'sequence_120', 'sequence_123', 'sequence_124', 'sequence_125', 'sequence_126', 'sequence_127', 'sequence_128', 'sequence_129', 'sequence_132', 'sequence_133', 'sequence_134', 'sequence_136', 'sequence_137', 'sequence_139', 'sequence_140', 'sequence_141', 'sequence_142', 'sequence_143', 'sequence_145', 'sequence_146', 'sequence_149', 'sequence_150', 'sequence_152', 'sequence_156', 'sequence_157', 'sequence_158']\n",
      "test sequences\n",
      "['sequence_82', 'sequence_7', 'sequence_9', 'sequence_90', 'sequence_15', 'sequence_21', 'sequence_23', 'sequence_103', 'sequence_105', 'sequence_30', 'sequence_113', 'sequence_115', 'sequence_40', 'sequence_41', 'sequence_44', 'sequence_45', 'sequence_121', 'sequence_51', 'sequence_54', 'sequence_131', 'sequence_59', 'sequence_151', 'sequence_64', 'sequence_65', 'sequence_144', 'sequence_74', 'sequence_154', 'sequence_77']\n",
      "validation sequences\n",
      "['sequence_5', 'sequence_6', 'sequence_14', 'sequence_19', 'sequence_24', 'sequence_31', 'sequence_42', 'sequence_48', 'sequence_53', 'sequence_58', 'sequence_63', 'sequence_68', 'sequence_73', 'sequence_79', 'sequence_85', 'sequence_89', 'sequence_93', 'sequence_99', 'sequence_107', 'sequence_111', 'sequence_122', 'sequence_130', 'sequence_135', 'sequence_138', 'sequence_147', 'sequence_148', 'sequence_153', 'sequence_155']\n"
     ]
    }
   ],
   "source": [
    "config_obj = config(config_file_path)\n",
    "# train_sequence_names, test_sequence_names = get_train_val_sequence_names(dataset_rootdir, config_obj.dataset_path)\n",
    "train_sequence_names, validation_sequence_names, test_sequence_names \\\n",
    "    = get_train_val_sequence_names_v2(dataset_rootdir, config_obj.dataset_path)\n",
    "\n",
    "print('train sequences')\n",
    "print(train_sequence_names)\n",
    "print('test sequences')\n",
    "print(test_sequence_names)\n",
    "print('validation sequences')\n",
    "print(validation_sequence_names)\n",
    "\n",
    "INVALID_CLS_IDX = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU is available. Good to go!\n"
     ]
    }
   ],
   "source": [
    "clustering_eps = 1.5\n",
    "\n",
    "param_obj = set_parameters_for_inference(module_rootdir, config_obj, trained_weights_path)\n",
    "device = param_obj['device']\n",
    "grid = param_obj['grid']\n",
    "detector = param_obj['detector']\n",
    "detector.set_param_for_proposal_extraction(clustering_eps, compute_adj_mat_from_links=False) \n",
    "\n",
    "labels_to_id_dict = compute_new_labels_to_id_dict()\n",
    "old_to_new_label_id_map = compute_old_to_new_label_id_map()\n",
    "\n",
    "cluster_size_threshold = 0\n",
    "\n",
    "pred_gt_association_eps_inv_iou = 1 - 0.3\n",
    "pred_gt_association_eps_l2_norm = 1.0\n",
    "pred_gt_association_eps = pred_gt_association_eps_inv_iou\n",
    "\n",
    "CLASS_NAMES = ['CAR', 'PEDESTRIAN', 'PEDESTRIAN_GROUP', 'TWO_WHEELER', 'LARGE_VEHICLE', 'NONE', 'FALSE']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_82 with 4196 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4196/4196 [01:02<00:00, 66.84it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_7 with 6205 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6205/6205 [03:56<00:00, 26.19it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_9 with 4748 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4748/4748 [04:42<00:00, 16.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_90 with 1489 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1489/1489 [01:12<00:00, 20.58it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_15 with 1061 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1061/1061 [00:44<00:00, 24.04it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_21 with 5801 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5801/5801 [01:30<00:00, 64.12it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_23 with 6812 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6812/6812 [02:08<00:00, 52.85it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_103 with 2044 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2044/2044 [00:36<00:00, 55.69it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_105 with 6469 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6469/6469 [37:57<00:00,  2.84it/s]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_30 with 4317 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4317/4317 [01:16<00:00, 56.68it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_113 with 10804 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 10804/10804 [17:53<00:00, 10.06it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_115 with 8416 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 8416/8416 [07:34<00:00, 18.53it/s] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_40 with 2992 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2992/2992 [01:27<00:00, 34.37it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_41 with 4617 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4617/4617 [02:56<00:00, 26.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_44 with 4515 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4515/4515 [01:51<00:00, 40.53it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_45 with 6989 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6989/6989 [04:58<00:00, 23.44it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_121 with 1215 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1215/1215 [01:16<00:00, 15.93it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_51 with 1879 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 1879/1879 [01:14<00:00, 25.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_54 with 966 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 966/966 [00:26<00:00, 35.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_131 with 2953 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2953/2953 [06:18<00:00,  7.80it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_59 with 2575 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2575/2575 [01:44<00:00, 24.62it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_151 with 3682 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 3682/3682 [00:56<00:00, 65.31it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_64 with 6754 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6754/6754 [04:45<00:00, 23.68it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_65 with 6694 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 6694/6694 [03:31<00:00, 31.66it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_144 with 7368 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7368/7368 [07:36<00:00, 16.12it/s]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_74 with 5607 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5607/5607 [01:50<00:00, 50.79it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_154 with 5632 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 5632/5632 [01:20<00:00, 69.94it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing sequence_77 with 4296 number of frames\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 4296/4296 [03:59<00:00, 17.97it/s]\n"
     ]
    }
   ],
   "source": [
    "all_sequence_names = test_sequence_names #+ train_sequence_names\n",
    "\n",
    "for sequence_name in all_sequence_names:\n",
    "\n",
    "    scene_metadata, radar_mount_data, radar_data_all_scenes, odometry_data_all_scenes \\\n",
    "            = get_sequence_data(dataset_rootdir, config_obj.dataset_path, sequence_name, config_obj.window_size)\n",
    "\n",
    "    print(f\"processing {sequence_name} with {len(scene_metadata)} number of frames\")\n",
    "\n",
    "    gt_count_matrix = np.zeros((config_obj.num_classes, ), dtype=np.uint64)\n",
    "    pred_count_matrix = np.zeros((config_obj.num_classes, ), dtype=np.uint64)\n",
    "    confusion_matrix = np.zeros((config_obj.num_classes, config_obj.num_classes), dtype=np.uint64)\n",
    "\n",
    "    for idx in tqdm(range(len(scene_metadata))):\n",
    "\n",
    "        gt_and_pred_objects = compute_gt_and_pred_objects(\n",
    "                idx,\n",
    "                scene_metadata,\n",
    "                radar_mount_data,\n",
    "                radar_data_all_scenes,\n",
    "                odometry_data_all_scenes,\n",
    "                labels_to_id_dict,\n",
    "                old_to_new_label_id_map,\n",
    "                grid, \n",
    "                config_obj, \n",
    "                device,\n",
    "                detector,\n",
    "                cluster_size_threshold,\n",
    "                detect_object_by_segmentation_output=True)\n",
    "        \n",
    "        gt_pred_associations = compute_gt_and_pred_associations(gt_and_pred_objects, pred_gt_association_eps)\n",
    "        obj_class_gt_associated = gt_pred_associations['obj_class_gt_associated']\n",
    "        obj_class_pred_associated = gt_pred_associations['obj_class_pred_associated']\n",
    "        obj_class_gt = gt_pred_associations['obj_class_gt']\n",
    "        obj_class_pred = gt_pred_associations['obj_class_pred']\n",
    "\n",
    "        if obj_class_gt.shape[0] != 0:\n",
    "                for i in range(obj_class_gt.shape[0]):\n",
    "                        gt_count_matrix[obj_class_gt[i]] += 1\n",
    "\n",
    "        if obj_class_pred.shape[0] != 0:\n",
    "                for i in range(obj_class_pred.shape[0]):\n",
    "                        pred_count_matrix[obj_class_pred[i]] += 1\n",
    "\n",
    "        if obj_class_gt_associated.shape[0] != 0:\n",
    "                for i in range(obj_class_gt_associated.shape[0]):\n",
    "                        confusion_matrix[obj_class_gt_associated[i], obj_class_pred_associated[i]] += 1\n",
    "                        \n",
    "    file_name = sequence_name + '.json'\n",
    "    file_name = os.path.join(save_model_performance_root_dir, file_name)\n",
    "\n",
    "    performance_data = {}\n",
    "    performance_data['class_names'] = CLASS_NAMES\n",
    "    performance_data['confusion_matrix'] = confusion_matrix.tolist()\n",
    "    performance_data['gt_count_matrix'] = gt_count_matrix.tolist()\n",
    "    performance_data['pred_count_matrix'] = pred_count_matrix.tolist()\n",
    "\n",
    "    with open(file_name, 'w') as json_file:\n",
    "        json.dump(performance_data, json_file, indent=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[86.66  0.63  0.97  0.86  2.05  8.82]\n",
      " [ 1.44 70.8  23.48  2.08  0.02  2.17]\n",
      " [ 1.03 14.27 83.78  0.36  0.07  0.49]\n",
      " [ 8.26  6.47  4.4  71.41  0.1   9.36]\n",
      " [13.97  0.21  1.3   0.06 75.8   8.65]\n",
      " [ 1.44  0.13  0.16  0.07  0.68 97.51]]\n",
      "precision:  [0.7  0.72 0.78 0.74 0.39 0.99]\n",
      "recall:  [0.86 0.62 0.79 0.7  0.74 0.72]\n"
     ]
    }
   ],
   "source": [
    "gt_count_matrix_sum = np.zeros((config_obj.num_classes, ), dtype=np.uint64)\n",
    "pred_count_matrix_sum = np.zeros((config_obj.num_classes, ), dtype=np.uint64)\n",
    "confusion_matrix_sum = np.zeros((config_obj.num_classes, config_obj.num_classes), dtype=np.uint64)\n",
    "INVALID_CLS_IDX = 5\n",
    "\n",
    "for sequence_name in test_sequence_names:\n",
    "\n",
    "    file_path = os.path.join(save_model_performance_root_dir, sequence_name + '.json')\n",
    "    with open(file_path, 'r') as file:\n",
    "        performance = json.load(file)\n",
    "\n",
    "    confusion_matrix_sum += np.array(performance['confusion_matrix'], dtype=np.uint64)\n",
    "    gt_count_matrix_sum += np.array(performance['gt_count_matrix'], dtype=np.uint64)\n",
    "    pred_count_matrix_sum += np.array(performance['pred_count_matrix'], dtype=np.uint64)\n",
    "\n",
    "gt_count_matrix_sum = np.delete(gt_count_matrix_sum, INVALID_CLS_IDX, axis=0)\n",
    "pred_count_matrix_sum = np.delete(pred_count_matrix_sum, INVALID_CLS_IDX, axis=0)\n",
    "confusion_matrix_sum = np.delete(confusion_matrix_sum, INVALID_CLS_IDX, axis=0)\n",
    "confusion_matrix_sum = np.delete(confusion_matrix_sum, INVALID_CLS_IDX, axis=1)\n",
    "\n",
    "# normalized confusion matrix\n",
    "normalized_confusion_matrix = confusion_matrix_sum / np.sum(confusion_matrix_sum, axis=-1, keepdims=True) * 100\n",
    "\n",
    "# precision & recall\n",
    "idx = np.arange(confusion_matrix_sum.shape[0])\n",
    "precision = confusion_matrix_sum[idx, idx] / pred_count_matrix_sum\n",
    "recall = confusion_matrix_sum[idx, idx] / gt_count_matrix_sum\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "CLASS_NAMES = ['Car', 'Pedestrian', 'Predestrian group', 'Two wheelers', 'Large Vehicles', 'None', 'False']\n",
    "CLASS_NAMES.pop(INVALID_CLS_IDX)\n",
    "hmap = sns.heatmap(data=normalized_confusion_matrix, annot=True, cmap='Greens')\n",
    "hmap.set_title('Confusion Matrix (Object Classification: Test Data)', size=16)\n",
    "hmap.set_xlabel('PREDICTION', size=12)\n",
    "hmap.set_ylabel('GROUND TRUTH', size=12)\n",
    "hmap.xaxis.set_ticklabels(CLASS_NAMES, rotation=90, size=11)\n",
    "hmap.yaxis.set_ticklabels(CLASS_NAMES, rotation=0, size=11)\n",
    "fig = hmap.get_figure()\n",
    "plt.show()\n",
    "\n",
    "np.set_printoptions(suppress=True, precision=2)\n",
    "print(normalized_confusion_matrix)\n",
    "print('precision: ', precision)\n",
    "print('recall: ', recall)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[92.6   0.28  0.19  0.34  1.11  5.48]\n",
      " [ 0.73 80.95 15.77  0.52  0.04  1.98]\n",
      " [ 0.48 10.47 88.31  0.3   0.06  0.37]\n",
      " [ 4.54  2.03  1.43 86.24  0.07  5.69]\n",
      " [16.62  0.07  0.13  0.07 79.78  3.33]\n",
      " [ 1.39  0.05  0.07  0.06  0.64 97.79]]\n",
      "precision:  [0.74 0.82 0.83 0.87 0.52 1.  ]\n",
      "recall:  [0.92 0.66 0.82 0.86 0.79 0.71]\n"
     ]
    }
   ],
   "source": [
    "gt_count_matrix_sum = np.zeros((config_obj.num_classes, ), dtype=np.uint64)\n",
    "pred_count_matrix_sum = np.zeros((config_obj.num_classes, ), dtype=np.uint64)\n",
    "confusion_matrix_sum = np.zeros((config_obj.num_classes, config_obj.num_classes), dtype=np.uint64)\n",
    "INVALID_CLS_IDX = 5\n",
    "\n",
    "for sequence_name in train_sequence_names:\n",
    "\n",
    "    file_path = os.path.join(save_model_performance_root_dir, sequence_name + '.json')\n",
    "    with open(file_path, 'r') as file:\n",
    "        performance = json.load(file)\n",
    "\n",
    "    confusion_matrix_sum += np.array(performance['confusion_matrix'], dtype=np.uint64)\n",
    "    gt_count_matrix_sum += np.array(performance['gt_count_matrix'], dtype=np.uint64)\n",
    "    pred_count_matrix_sum += np.array(performance['pred_count_matrix'], dtype=np.uint64)\n",
    "\n",
    "gt_count_matrix_sum = np.delete(gt_count_matrix_sum, INVALID_CLS_IDX, axis=0)\n",
    "pred_count_matrix_sum = np.delete(pred_count_matrix_sum, INVALID_CLS_IDX, axis=0)\n",
    "confusion_matrix_sum = np.delete(confusion_matrix_sum, INVALID_CLS_IDX, axis=0)\n",
    "confusion_matrix_sum = np.delete(confusion_matrix_sum, INVALID_CLS_IDX, axis=1)\n",
    "    \n",
    "# normalized confusion matrix\n",
    "normalized_confusion_matrix = confusion_matrix_sum / np.sum(confusion_matrix_sum, axis=-1, keepdims=True) * 100\n",
    "\n",
    "# precision & recall\n",
    "idx = np.arange(confusion_matrix_sum.shape[0])\n",
    "precision = confusion_matrix_sum[idx, idx] / pred_count_matrix_sum\n",
    "recall = confusion_matrix_sum[idx, idx] / gt_count_matrix_sum\n",
    "\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "CLASS_NAMES = ['Car', 'Pedestrian', 'Predestrian group', 'Two wheelers', 'Large Vehicles', 'None', 'False']\n",
    "CLASS_NAMES.pop(INVALID_CLS_IDX)\n",
    "hmap = sns.heatmap(data=normalized_confusion_matrix, annot=True, cmap='Greens')\n",
    "hmap.set_title('Confusion Matrix (Object Classification: Train Data)', size=16)\n",
    "hmap.set_xlabel('PREDICTION', size=12)\n",
    "hmap.set_ylabel('GROUND TRUTH', size=12)\n",
    "hmap.xaxis.set_ticklabels(CLASS_NAMES, rotation=90, size=11)\n",
    "hmap.yaxis.set_ticklabels(CLASS_NAMES, rotation=0, size=11)\n",
    "fig = hmap.get_figure()\n",
    "plt.show()\n",
    "\n",
    "np.set_printoptions(suppress=True, precision=2)\n",
    "print(normalized_confusion_matrix)\n",
    "print('precision: ', precision)\n",
    "print('recall: ', recall)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch2",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}