A28 Regression to Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-29 15:49:28.301206: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n",
      "2024-04-29 15:49:28.335654: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2024-04-29 15:49:28.335684: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2024-04-29 15:49:28.336856: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2024-04-29 15:49:28.343639: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n",
      "2024-04-29 15:49:29.007426: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "2024-04-29 15:49:30.086769: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 21729 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:68:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import layers, models\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\n",
    "import os\n",
    "\n",
    "from PIL import Image\n",
    "\n",
    "\n",
    "\n",
    "# Configure Keras to use GPU\n",
    "config = tf.compat.v1.ConfigProto()\n",
    "config.gpu_options.allow_growth = True\n",
    "sess = tf.compat.v1.Session(config=config)\n",
    "tf.compat.v1.keras.backend.set_session(sess)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "# import matplotlib.pyplot as plt\n",
    "# from scipy.ndimage import maximum_position, label\n",
    "# def counting_filter_max(arr, threshold=20, structure=np.ones((3,3))):\n",
    "#     \"\"\"\n",
    "#     Implements connected component analysis (CCA) on a single image to detect blobs,\n",
    "#     then finds the maximum position within each blob to assign the entry positions.\n",
    "    \n",
    "#     Args:\n",
    "#         arr: Numpy array representing an image, shape [H, W].\n",
    "#         threshold: Threshold to convert the image to binary by filtering out dark noise.\n",
    "#         structure: Structuring element for defining connectivity in the image.\n",
    "    \n",
    "#     Returns:\n",
    "#         Numpy array of the same shape as `arr` where 1 indicates the maximum position of a blob,\n",
    "#         and 0 elsewhere.\n",
    "#     \"\"\"\n",
    "#     # Apply threshold to convert the image to a binary image\n",
    "#     image_binary = arr > threshold\n",
    "\n",
    "#     # Label connected components in the binary image\n",
    "#     all_labels, num = label(image_binary, structure=structure)\n",
    "\n",
    "#     # Find the maximum position within each labeled component\n",
    "#     max_positions = maximum_position(arr, all_labels, range(1, num + 1))\n",
    "\n",
    "#     # Create an output array to mark maximum positions\n",
    "#     max_markers = np.zeros_like(arr)\n",
    "#     max_markers[tuple(zip(*max_positions))] = 1\n",
    "\n",
    "#     return max_markers\n",
    "\n",
    "# # Generate a sample image (2D array)\n",
    "# np.random.seed(0)\n",
    "# sample_image = np.random.randint(0, 50, size=(10, 10))\n",
    "# sample_image[3:5, 4:6] += 50  # Create a high intensity blob\n",
    "# sample_image[7:9, 7:9] += 45  # Create another high intensity blob\n",
    "\n",
    "# # Apply the counting_filter_max function\n",
    "# result = counting_filter_max(sample_image, threshold=20)\n",
    "\n",
    "# # Visualize the original image and the result\n",
    "# plt.figure(figsize=(12, 6))\n",
    "# plt.subplot(1, 2, 1)\n",
    "# plt.title(\"Original Image\")\n",
    "# plt.imshow(sample_image, cmap='gray')\n",
    "# plt.colorbar()\n",
    "\n",
    "# plt.subplot(1, 2, 2)\n",
    "# plt.title(\"Max Positions Marked\")\n",
    "# plt.imshow(result, cmap='gray')\n",
    "# plt.colorbar()\n",
    "\n",
    "# plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "# from scipy.ndimage import label\n",
    "\n",
    "# def create_binary_mask(dimensions, boxes):\n",
    "#     \"\"\"\n",
    "#     Create a binary mask from bounding boxes.\n",
    "#     \"\"\"\n",
    "#     mask = np.zeros(dimensions, dtype=np.uint8)\n",
    "#     for box in boxes:\n",
    "#         x_min, y_min, x_max, y_max = box\n",
    "#         mask[y_min:y_max, x_min:x_max] = 1\n",
    "#     return mask\n",
    "\n",
    "# def calculate_iou_components(pred_labels, gt_labels):\n",
    "#     \"\"\"\n",
    "#     Calculate IoU for each predicted component against each ground truth component.\n",
    "#     \"\"\"\n",
    "#     ious = []\n",
    "#     pred_objects = np.unique(pred_labels)[1:]  # Exclude background\n",
    "#     gt_objects = np.unique(gt_labels)[1:]  # Exclude background\n",
    "\n",
    "#     for pred_obj in pred_objects:\n",
    "#         pred_mask = pred_labels == pred_obj\n",
    "#         for gt_obj in gt_objects:\n",
    "#             gt_mask = gt_labels == gt_obj\n",
    "#             intersection = np.logical_and(pred_mask, gt_mask)\n",
    "#             union = np.logical_or(pred_mask, gt_mask)\n",
    "#             iou = np.sum(intersection) / np.sum(union)\n",
    "#             if iou > 0.5:  # Threshold to consider a match\n",
    "#                 ious.append((pred_obj, gt_obj, iou))\n",
    "#     return ious\n",
    "\n",
    "# def evaluate_image(predictions, ground_truths, dimensions):\n",
    "#     \"\"\"\n",
    "#     Evaluate a single image using precision, recall, and IoU.\n",
    "#     \"\"\"\n",
    "#     pred_mask = create_binary_mask(dimensions, predictions)\n",
    "#     gt_mask = create_binary_mask(dimensions, ground_truths)\n",
    "    \n",
    "#     pred_labels, num_pred = label(pred_mask)\n",
    "#     gt_labels, num_gt = label(gt_mask)\n",
    "    \n",
    "#     ious = calculate_iou_components(pred_labels, gt_labels)\n",
    "    \n",
    "#     true_positives = len(ious)\n",
    "#     predicted_positives = num_pred\n",
    "#     actual_positives = num_gt\n",
    "    \n",
    "#     precision = true_positives / predicted_positives if predicted_positives else 0\n",
    "#     recall = true_positives / actual_positives if actual_positives else 0\n",
    "    \n",
    "#     return {\n",
    "#         'Precision': precision,\n",
    "#         'Recall': recall,\n",
    "#         'IoU Matches': ious\n",
    "#     }\n",
    "# import numpy as np\n",
    "\n",
    "# def preprocess_boxes(boxes, image_shape):\n",
    "#     \"\"\"\n",
    "#     Normalize and convert bounding box coordinates to integer values, adjusting for small values.\n",
    "    \n",
    "#     Args:\n",
    "#         boxes: Array of bounding box coordinates.\n",
    "#         image_shape: Tuple indicating the dimensions of the images (height, width).\n",
    "    \n",
    "#     Returns:\n",
    "#         Processed boxes with integer coordinates.\n",
    "#     \"\"\"\n",
    "#     height, width = image_shape\n",
    "#     # Assuming boxes are normalized [x_min, y_min, x_max, y_max]\n",
    "#     scaled_boxes = np.copy(boxes)\n",
    "#     scaled_boxes[:, 0] *= width\n",
    "#     scaled_boxes[:, 2] *= width\n",
    "#     scaled_boxes[:, 1] *= height\n",
    "#     scaled_boxes[:, 3] *= height\n",
    "\n",
    "#     # Round to nearest integer and ensure minimum size of 1 for each dimension\n",
    "#     scaled_boxes = np.rint(scaled_boxes).astype(int)\n",
    "#     for box in scaled_boxes:\n",
    "#         if box[2] == box[0]:  # Ensure minimum width\n",
    "#             box[2] = box[0] + 1\n",
    "#         if box[3] == box[1]:  # Ensure minimum height\n",
    "#             box[3] = box[1] + 1\n",
    "\n",
    "#     return scaled_boxes\n",
    "\n",
    "# def filter_boxes(boxes):\n",
    "#     \"\"\"\n",
    "#     Remove zero-sized or invalid boxes from the array.\n",
    "    \n",
    "#     Args:\n",
    "#         boxes: Array of bounding box coordinates.\n",
    "    \n",
    "#     Returns:\n",
    "#         Filtered array of bounding boxes.\n",
    "#     \"\"\"\n",
    "#     filtered_boxes = [box for box in boxes if (box[2] > box[0] and box[3] > box[1])]\n",
    "#     return np.array(filtered_boxes)\n",
    "\n",
    "# # Mock dimensions of your images, e.g., 100x100 pixels\n",
    "# image_dimensions = (64, 64)\n",
    "\n",
    "# # Example usage\n",
    "# predictions_raw = np.array([[2.9063843e+01, 5.6825363e+01, 3.0376661e+01, 5.7323868e+01],\n",
    "#        [6.1131519e-01, 6.1410499e-01, 6.3220149e-01, 6.1376023e-01],\n",
    "#        [3.8116515e-01, 5.8919060e-01, 4.2811164e-01, 6.5443587e-01],\n",
    "#          [5.5959210e-04, 5.3034216e-04, 6.7056349e-04, 9.3700440e-04],\n",
    "#          [5.9041078e-04, 6.1910786e-04, 8.5616822e-04, 3.2623659e-04],\n",
    "#          [5.2420807e-04, 9.7561674e-04, 3.4557586e-04, 1.4522944e-03],\n",
    "#           [5.5959210e-04, 5.3034216e-04, 6.7056349e-04, 9.3700440e-04],\n",
    "#          [5.9041078e-04, 6.1910786e-04, 8.5616822e-04, 3.2623659e-04],\n",
    "#          [5.2420807e-04, 9.7561674e-04, 3.4557586e-04, 1.4522944e-03],\n",
    "#           [5.5959210e-04, 5.3034216e-04, 6.7056349e-04, 9.3700440e-04],\n",
    "#          [5.9041078e-04, 6.1910786e-04, 8.5616822e-04, 3.2623659e-04],\n",
    "#          [5.2420807e-04, 9.7561674e-04, 3.4557586e-04, 1.4522944e-03],# Your prediction array here\n",
    "#        [5.5959210e-04, 5.3034216e-04, 6.7056349e-04, 9.3700440e-04],\n",
    "#        [5.9041078e-04, 6.1910786e-04, 8.5616822e-04, 3.2623659e-04],\n",
    "#        [5.2420807e-04, 9.7561674e-04, 3.4557586e-04, 1.4522944e-03]])  # Your prediction array here\n",
    "# ground_truths_raw = np.array([[29., 57., 30., 57.],\n",
    "#        [ 0.,  0.,  0.,  0.],\n",
    "#        [ 0.,  0.,  0.,  0.],\n",
    "#          [ 0.,  0.,  0.,  0.],\n",
    "#          [ 0.,  0.,  0.,  0.],\n",
    "#          [ 0.,  0.,  0.,  0.],\n",
    "#           [ 0.,  0.,  0.,  0.],\n",
    "#          [ 0.,  0.,  0.,  0.],\n",
    "#          [ 0.,  0.,  0.,  0.],\n",
    "#           [ 0.,  0.,  0.,  0.],\n",
    "#          [ 0.,  0.,  0.,  0.],\n",
    "#          [ 0.,  0.,  0.,  0.],\n",
    "#        [ 0.,  0.,  0.,  0.],\n",
    "#        [ 0.,  0.,  0.,  0.],\n",
    "#        [ 0.,  0.,  0.,  0.]])  # Your ground truth array here\n",
    "\n",
    "# # Preprocess and filter the boxes\n",
    "# predictions = preprocess_boxes(predictions_raw, image_dimensions)\n",
    "# predictions = filter_boxes(predictions)\n",
    "\n",
    "# ground_truths = preprocess_boxes(ground_truths_raw, image_dimensions)\n",
    "# ground_truths = filter_boxes(ground_truths)\n",
    "\n",
    "# # Now use predictions and ground_truths with the evaluate_image function\n",
    "# result = evaluate_image(predictions, ground_truths, image_dimensions)\n",
    "# print(result)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "with h5py.File('TrainingData5zeroes.h5', 'r') as hdf:\n",
    "    ls = list(hdf.keys())\n",
    "    images = hdf.get('images')[7000:]\n",
    "    boxes = hdf.get('boxes')[7000:]\n",
    "    images = np.array(images)\n",
    "    boxes = np.array(boxes)\n",
    "\n",
    "\n",
    "image_normalized = (images + 1e-9) / 9.26\n",
    "normalized_boxes = boxes / [1, 64, 64, 64, 64]\n",
    "\n",
    "images_np = image_normalized\n",
    "\n",
    "probabilities = np.array(normalized_boxes[:, :, :-4])\n",
    "probabilities = tf.expand_dims(probabilities, axis=1)\n",
    "boxes_np = np.array(normalized_boxes[:, :, 1:])\n",
    "boxes_np = tf.expand_dims(boxes_np, axis=1)\n",
    "batch_size = 128\n",
    "dataset = tf.data.Dataset.from_tensor_slices((images_np, {'x_prob_reshape': probabilities, 'x_boxes_reshape': boxes_np}))\n",
    "dataset = dataset.shuffle(buffer_size=10000).batch(batch_size)\n",
    "# total_items = len(images_np)\n",
    "# train_size = int(total_items * 0.9)\n",
    "# test_size = total_items - train_size \n",
    "\n",
    "#     # Splitting the dataset\n",
    "# train_dataset = dataset.take(train_size)\n",
    "# test_dataset = dataset.skip(train_size)\n",
    "\n",
    "\n",
    "# train_dataset = train_dataset.shuffle(buffer_size=train_size,reshuffle_each_iteration=True)\n",
    "# train_dataset = train_dataset.batch(batch_size)\n",
    "# test_dataset = test_dataset.batch(batch_size) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadmodel = tf.keras.models.load_model(\"/home/m3-learning/Documents/Research Data/Derrick's Object Detection/Models/M11overfittedmodel4variant.keras\")\n",
    "# loadmodel = tf.keras.models.load_model(\"/home/m3-learning/Documents/Research Data/Derrick's Object Detection/Models/Sweep Weights/Train and Val/northern-sweep-1.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "\n",
    "# # Provided data\n",
    "# predictions_raw = np.array([\n",
    "#     [39.8903408, 24.773323, 39.454777, 25.82823],\n",
    "#     [0.40461713, 0.2488891, 0.44437495, 0.2451111],\n",
    "#     [0.4801518, 0.56913036, 0.52614892, 0.60166949],\n",
    "#     [0.00044191495, 0.0005460676, 0.00068218674, 0.00090827933],\n",
    "#     [0.00040864121, 0.00038058122, 0.00060208299, 0.00024521281],\n",
    "#     [0.00052764977, 0.00058524718, 0.0002075122, 0.0010586288]\n",
    "# ])\n",
    "\n",
    "# ground_truth_raw = np.array([\n",
    "#     [39, 24, 39, 25],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0]\n",
    "# ])\n",
    "\n",
    "# # Thresholds\n",
    "# prediction_thresholds = np.where(np.max(predictions_raw, axis=0) > 1, 30, 0.5)  # Large values get higher threshold\n",
    "# difference_thresholds = np.where(np.max(ground_truth_raw, axis=0) > 1, 1, 0.1)  # Large values get higher threshold\n",
    "\n",
    "# # Normalized predictions (binary classification)\n",
    "# predicted_classes = np.where(predictions_raw > prediction_thresholds, 1, 0)\n",
    "\n",
    "# # Absolute difference\n",
    "# abs_diff = np.abs(predictions_raw - ground_truth_raw)\n",
    "\n",
    "# # Applying difference threshold\n",
    "# is_close_enough = abs_diff <= difference_thresholds\n",
    "\n",
    "# # Classifying true positives, false positives, true negatives, false negatives\n",
    "# TP = (predicted_classes == 1) & is_close_enough\n",
    "# FP = (predicted_classes == 1) & ~is_close_enough\n",
    "# TN = (predicted_classes == 0) & is_close_enough\n",
    "# FN = (predicted_classes == 0) & ~is_close_enough\n",
    "\n",
    "# # Counting the classifications\n",
    "# TP_count = np.sum(TP)\n",
    "# FP_count = np.sum(FP)\n",
    "# TN_count = np.sum(TN)\n",
    "# FN_count = np.sum(FN)\n",
    "\n",
    "# TP_count, FP_count, TN_count, FN_count\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 260ms/step\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# dataset = tf.data.Dataset.from_tensor_slices((images_np,{'x_prob_reshape':probabilities,'x_boxes_reshape':boxes_np}))\n",
    "# dataset = dataset.batch(10)\n",
    "# # test_dataset = dataset.skip(train_size)\n",
    "# # # test_dataset = test_dataset.shuffle(buffer_size=10000,reshuffle_each_iteration=True)\n",
    "# # test_dataset = test_dataset.batch(test_size)\n",
    "# # train_dataset = dataset.take(train_size)\n",
    "# # # train_dataset = train_dataset.shuffle(buffer_size=10000,reshuffle_each_iteration=True)\n",
    "# # train_dataset = train_dataset.batch(train_size)\n",
    "# inputs,targets = next(iter(dataset))\n",
    "# output =loadmodel.predict(inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "# import tensorflow as tf\n",
    "\n",
    "# # Load the trained model\n",
    "# # model = tf.keras.models.load_model('path_to_your_saved_model')\n",
    "\n",
    "# # Assuming 'images_np', 'probabilities', and 'boxes_np' are your numpy arrays ready to be used\n",
    "# dataset = tf.data.Dataset.from_tensor_slices((images_np, {'x_prob_reshape': probabilities, 'x_boxes_reshape': boxes_np}))\n",
    "# dataset = dataset.batch(1000)  # Adjust the batch size according to your needs\n",
    "# inputs, targets = next(iter(dataset))\n",
    "\n",
    "# # Predict using the loaded model\n",
    "# output = loadmodel.predict(inputs)\n",
    "\n",
    "# # Define thresholds\n",
    "# prediction_thresholds = np.array([0.5] * output[0].shape[1])  # Adjust this according to your output dimensions and scale\n",
    "# difference_thresholds = np.array([0.1] * output[1].shape[1])  # Adjust this according to what you consider a close enough prediction\n",
    "\n",
    "# # Evaluate predictions function (as previously defined)\n",
    "# def evaluate_predictions(y_true, y_pred, pred_thresh, diff_thresh):\n",
    "#     predicted_classes = (y_pred > pred_thresh).astype(int)\n",
    "#     abs_diff = np.abs(y_pred - y_true)\n",
    "#     is_close_enough = abs_diff <= diff_thresh\n",
    "\n",
    "#     TP = np.logical_and(predicted_classes == 1, is_close_enough)\n",
    "#     FP = np.logical_and(predicted_classes == 1, np.logical_not(is_close_enough))\n",
    "#     TN = np.logical_and(predicted_classes == 0, is_close_enough)\n",
    "#     FN = np.logical_and(predicted_classes == 0, np.logical_not(is_close_enough))\n",
    "\n",
    "#     return np.sum(TP), np.sum(FP), np.sum(TN), np.sum(FN)\n",
    "\n",
    "# # Assuming 'targets' dictionary contains arrays that match keys with 'output' dictionary keys\n",
    "# total_TP = total_FP = total_TN = total_FN = 0\n",
    "\n",
    "# TP, FP, TN, FN = evaluate_predictions(boxes_np.numpy(), output[1], prediction_thresholds, difference_thresholds)\n",
    "# total_TP += TP\n",
    "# total_FP += FP\n",
    "# total_TN += TN\n",
    "# total_FN += FN\n",
    "\n",
    "# # Calculate precision and recall\n",
    "# precision = total_TP / (total_TP + total_FP) if (total_TP + total_FP) > 0 else 0\n",
    "# recall = total_TP / (total_TP + total_FN) if (total_TP + total_FN) > 0 else 0\n",
    "\n",
    "# print(f'Precision: {precision}, Recall: {recall}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conversion From Regression to Classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10/10 [==============================] - 0s 8ms/step\n",
      "Precision: 0.8820072711959346, Recall: 0.5789277967271784, F1 Score: 0.6990297343422884\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "# Assuming you have loaded the model and the dataset\n",
    "dataset = tf.data.Dataset.from_tensor_slices((images_np, {'x_prob_reshape': probabilities, 'x_boxes_reshape': boxes_np}))\n",
    "dataset = dataset.batch(301)  # Adjust the batch size according to your needs\n",
    "inputs, targets = next(iter(dataset))\n",
    "\n",
    "# Predict using the loaded model\n",
    "output = loadmodel.predict(inputs)\n",
    "\n",
    "# Define thresholds\n",
    "# prediction_thresholds = np.array([0.4] * output[1].shape[1])  # Adjust this according to your output dimensions and scale\n",
    "# difference_thresholds = np.array([0.1] * output[1].shape[1])  # Adjust this according to what you consider a close enough prediction\n",
    "prediction_thresholds = np.array([0.5, 0.5, 0.5, 0.5])\n",
    "difference_thresholds = np.array([0.1, 0.1, 0.1, 0.1])\n",
    "\n",
    "# # Evaluate predictions function (as previously defined)\n",
    "# def evaluate_predictions(y_true, y_pred, pred_thresh, diff_thresh):\n",
    "#     predicted_classes = (y_pred > pred_thresh).astype(int)\n",
    "#     abs_diff = np.abs(y_pred - y_true)\n",
    "#     is_close_enough = abs_diff <= diff_thresh\n",
    "\n",
    "#     TP = np.logical_and(predicted_classes == 1, is_close_enough)\n",
    "#     FP = np.logical_and(predicted_classes == 1, np.logical_not(is_close_enough))\n",
    "#     TN = np.logical_and(predicted_classes == 0, is_close_enough)\n",
    "#     FN = np.logical_and(predicted_classes == 0, np.logical_not(is_close_enough))\n",
    "\n",
    "#     return np.sum(TP), np.sum(FP), np.sum(TN), np.sum(FN)\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "def evaluate_predictions(y_true, y_pred, pred_thresh, diff_thresh):\n",
    "    predicted_classes = (y_pred > pred_thresh).astype(int)\n",
    "    abs_diff = np.abs(y_pred - y_true)\n",
    "    is_close_enough = abs_diff <= diff_thresh\n",
    "    \n",
    "    # True Positive: All coordinates must be close enough in a positively predicted sample\n",
    "    TP = (predicted_classes == 1) & np.all(is_close_enough, axis=1)\n",
    "    \n",
    "    # False Positive: Any coordinate not close enough in a positively predicted sample\n",
    "    FP = (predicted_classes == 1) & ~np.all(is_close_enough, axis=1)\n",
    "    \n",
    "    # True Negative: Predicted as negative (no need to check closeness)\n",
    "    TN = (predicted_classes == 0)\n",
    "    \n",
    "    # False Negative: Predicted as negative but should have been positive (based on prediction threshold alone)\n",
    "    FN = (predicted_classes == 0) & (y_true > pred_thresh).any(axis=1)\n",
    "    \n",
    "    return np.sum(TP), np.sum(FP), np.sum(TN), np.sum(FN)\n",
    "\n",
    "\n",
    "# Assuming 'targets' dictionary contains arrays that match keys with 'output' dictionary keys\n",
    "total_TP = total_FP = total_TN = total_FN = 0\n",
    "\n",
    "TP, FP, TN, FN = evaluate_predictions(targets['x_boxes_reshape'].numpy(), output[1], prediction_thresholds, difference_thresholds)\n",
    "total_TP += TP\n",
    "total_FP += FP\n",
    "total_TN += TN\n",
    "total_FN += FN\n",
    "\n",
    "# Calculate precision and recall\n",
    "precision = total_TP / (total_TP + total_FP) if (total_TP + total_FP) > 0 else 0\n",
    "recall = total_TP / (total_TP + total_FN) if (total_TP + total_FN) > 0 else 0\n",
    "\n",
    "# Calculate F1 score\n",
    "if (precision + recall) > 0:\n",
    "    f1_score = 2 * (precision * recall) / (precision + recall)\n",
    "else:\n",
    "    f1_score = 0\n",
    "\n",
    "print(f'Precision: {precision}, Recall: {recall}, F1 Score: {f1_score}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[[5.6570011e+01, 4.6470253e+01, 5.7031590e+01, 4.7806549e+01],\n",
       "         [2.8592041e+01, 5.9081009e+01, 2.9590895e+01, 5.9466404e+01],\n",
       "         [2.8545412e+01, 1.3803929e+01, 3.0624582e+01, 1.4750621e+01],\n",
       "         ...,\n",
       "         [2.1487900e-05, 2.0288535e-05, 6.7233683e-05, 5.6221626e-05],\n",
       "         [2.9877892e-05, 1.9206125e-05, 4.9760987e-05, 1.4272087e-05],\n",
       "         [2.0359243e-05, 2.2661616e-05, 1.9187488e-05, 4.3200002e-05]]],\n",
       "       dtype=float32),\n",
       " <tf.Tensor: shape=(1, 280, 4), dtype=float64, numpy=\n",
       " array([[[58., 48., 58., 49.],\n",
       "         [36., 60., 37., 61.],\n",
       "         [22., 11., 23., 11.],\n",
       "         ...,\n",
       "         [ 0.,  0.,  0.,  0.],\n",
       "         [ 0.,  0.,  0.,  0.],\n",
       "         [ 0.,  0.,  0.,  0.]]])>)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output[1][8]*64,targets['x_boxes_reshape'][8]*64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean IoU: 0.06961929567127564, Mean MAE: 0.39206414480663165\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# def compute_iou(box1, box2):\n",
    "#     y_top = max(box1[1], box2[1])\n",
    "#     x_left = max(box1[0], box2[0])\n",
    "#     y_bottom = min(box1[3], box2[3])\n",
    "#     x_right = min(box1[2], box2[2])\n",
    "\n",
    "#     if x_right < x_left or y_bottom < y_top:\n",
    "#         return 0.0\n",
    "\n",
    "#     intersection_area = (x_right - x_left) * (y_bottom - y_top)\n",
    "#     box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])\n",
    "#     box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])\n",
    "#     union_area = box1_area + box2_area - intersection_area\n",
    "#     iou = intersection_area / union_area\n",
    "#     return iou\n",
    "\n",
    "def compute_iou(box1, box2):\n",
    "    \"\"\"\n",
    "    Compute the Intersection over Union (IoU) of two bounding boxes.\n",
    "\n",
    "    Parameters:\n",
    "    - box1, box2: (xmin, ymin, xmax, ymax)\n",
    "\n",
    "    Returns:\n",
    "    - iou: Intersection over Union (float)\n",
    "    \"\"\"\n",
    "    # Determine the coordinates of the intersection rectangle\n",
    "    x_left = max(box1[0], box2[0])\n",
    "    y_top = max(box1[1], box2[1])\n",
    "    x_right = min(box1[2], box2[2])\n",
    "    y_bottom = min(box1[3], box2[3])\n",
    "\n",
    "    if x_right < x_left or y_bottom < y_top:\n",
    "        return 0.0\n",
    "\n",
    "    # Calculate intersection area\n",
    "    intersection_area = (x_right - x_left) * (y_bottom - y_top)\n",
    "\n",
    "    # Calculate the union area\n",
    "    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])\n",
    "    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])\n",
    "    union_area = box1_area + box2_area - intersection_area\n",
    "\n",
    "    # Compute the IoU\n",
    "    iou = intersection_area / union_area\n",
    "    return iou\n",
    "\n",
    "\n",
    "def compute_mae(box1, box2):\n",
    "    return np.mean(np.abs(np.array(box1) - np.array(box2)))\n",
    "\n",
    "iou_scores = []\n",
    "mae_scores = []\n",
    "\n",
    "# Iterate through each batch item\n",
    "for batch_index in range(targets['x_boxes_reshape'].shape[0]):\n",
    "    for box_index in range(targets['x_boxes_reshape'].shape[2]):  # Assuming 280 boxes per image\n",
    "        true_box = targets['x_boxes_reshape'][batch_index, 0, box_index]*64\n",
    "        pred_box = output[1][batch_index, 0, box_index]*64\n",
    "        \n",
    "        # Compute IoU and MAE only for boxes that are not all zeros\n",
    "        if not np.all(true_box == 0) and not np.all(pred_box == 0):\n",
    "            iou_score = compute_iou(true_box, pred_box)\n",
    "            mae_score = compute_mae(true_box, pred_box)\n",
    "            iou_scores.append(iou_score)\n",
    "            mae_scores.append(mae_score)\n",
    "\n",
    "# Continue with your existing summary statistics and visualization code\n",
    "mean_iou = np.mean(iou_scores)\n",
    "mean_mae = np.mean(mae_scores)\n",
    "print(f\"Mean IoU: {mean_iou}, Mean MAE: {mean_mae}\")\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Histogram of IoU Scores\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.hist(iou_scores, bins=50, color='blue', alpha=0.7)\n",
    "plt.title('Histogram of IoU Scores')\n",
    "plt.xlabel('IoU Score')\n",
    "plt.ylabel('Frequency')\n",
    "plt.grid(True)\n",
    "plt.show()\n",
    "\n",
    "# Scatter Plot of MAE\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.scatter(range(len(mae_scores)), mae_scores, color='red')\n",
    "plt.title('Scatter Plot of Mean Absolute Errors')\n",
    "plt.xlabel('Index')\n",
    "plt.ylabel('MAE')\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'result is not a file in the archive'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 136\u001b[0m\n\u001b[1;32m    133\u001b[0m     print_results(results)\n\u001b[1;32m    135\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;18m__name__\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m__main__\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m--> 136\u001b[0m     \u001b[43mmain\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[10], line 132\u001b[0m, in \u001b[0;36mmain\u001b[0;34m()\u001b[0m\n\u001b[1;32m    130\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmain\u001b[39m():\n\u001b[1;32m    131\u001b[0m     file_path \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m/home/m3-learning/Documents/myML/ValidationData-20231107T163458Z-001/ValidationData/Stack007.npz\u001b[39m\u001b[38;5;124m'\u001b[39m  \u001b[38;5;66;03m# Update this to your actual file path\u001b[39;00m\n\u001b[0;32m--> 132\u001b[0m     results \u001b[38;5;241m=\u001b[39m \u001b[43mprocess_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    133\u001b[0m     print_results(results)\n",
      "Cell \u001b[0;32mIn[10], line 109\u001b[0m, in \u001b[0;36mprocess_data\u001b[0;34m(file_path)\u001b[0m\n\u001b[1;32m    105\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    106\u001b[0m \u001b[38;5;124;03mProcess the loaded data to calculate average metrics.\u001b[39;00m\n\u001b[1;32m    107\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    108\u001b[0m \u001b[38;5;66;03m# Load results and metrics from the file\u001b[39;00m\n\u001b[0;32m--> 109\u001b[0m result, mae, dce, recall, precision, deviations, dce_corrected \u001b[38;5;241m=\u001b[39m \u001b[43mload_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile_path\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    111\u001b[0m \u001b[38;5;66;03m# Calculate average of each metric\u001b[39;00m\n\u001b[1;32m    112\u001b[0m metrics \u001b[38;5;241m=\u001b[39m {\n\u001b[1;32m    113\u001b[0m     \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mAverage MAE\u001b[39m\u001b[38;5;124m'\u001b[39m: np\u001b[38;5;241m.\u001b[39mmean(mae),\n\u001b[1;32m    114\u001b[0m     \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mAverage DCE\u001b[39m\u001b[38;5;124m'\u001b[39m: np\u001b[38;5;241m.\u001b[39mmean(dce),\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    117\u001b[0m     \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mAverage Corrected DCE\u001b[39m\u001b[38;5;124m'\u001b[39m: np\u001b[38;5;241m.\u001b[39mmean(dce_corrected)\n\u001b[1;32m    118\u001b[0m }\n",
      "Cell \u001b[0;32mIn[10], line 12\u001b[0m, in \u001b[0;36mload_data\u001b[0;34m(file_path)\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;124;03mLoad data from an NPZ file.\u001b[39;00m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m     11\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m np\u001b[38;5;241m.\u001b[39mload(file_path, allow_pickle\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m data:\n\u001b[0;32m---> 12\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mresult\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m     13\u001b[0m     mae \u001b[38;5;241m=\u001b[39m data[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmae\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m     14\u001b[0m     dce \u001b[38;5;241m=\u001b[39m data[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdce\u001b[39m\u001b[38;5;124m'\u001b[39m]\n",
      "File \u001b[0;32m~/.local/lib/python3.10/site-packages/numpy/lib/npyio.py:260\u001b[0m, in \u001b[0;36mNpzFile.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m    258\u001b[0m         \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mzip\u001b[38;5;241m.\u001b[39mread(key)\n\u001b[1;32m    259\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 260\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m is not a file in the archive\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m key)\n",
      "\u001b[0;31mKeyError\u001b[0m: 'result is not a file in the archive'"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# def load_data(file_path):\n",
    "#     data = np.load(file_path)\n",
    "#     return data['result'], data['mae'], data['dce'], data['recall'], data['precision'], data['deviations'], data['dce_corrected']\n",
    "\n",
    "def load_data(file_path):\n",
    "    \"\"\"\n",
    "    Load data from an NPZ file.\n",
    "    \"\"\"\n",
    "    with np.load(file_path, allow_pickle=True) as data:\n",
    "        result = data['result']\n",
    "        mae = data['mae']\n",
    "        dce = data['dce']\n",
    "        recall = data['recall']\n",
    "        precision = data['precision']\n",
    "        deviations = data['deviations']\n",
    "        dce_corrected = data['dce_corrected']\n",
    "    return result, mae, dce, recall, precision, deviations, dce_corrected\n",
    "\n",
    "# Metric Calculation Functions\n",
    "def calculate_mae(filtered, ground_truth):\n",
    "    return np.mean(np.abs(filtered - ground_truth))\n",
    "\n",
    "def calculate_precision(tp, fp):\n",
    "    return tp / (tp + fp) if (tp + fp) > 0 else 0\n",
    "\n",
    "def calculate_recall(tp, fn):\n",
    "    return tp / (tp + fn) if (tp + fn) > 0 else 0\n",
    "\n",
    "def calculate_dce(detected_count, actual_count):\n",
    "    return detected_count / actual_count if actual_count > 0 else 0\n",
    "\n",
    "def calculate_corrected_dce(deviations, actual_count):\n",
    "    valid_detections = len([d for d in deviations if d <= 6])  # Example threshold\n",
    "    return valid_detections / actual_count if actual_count > 0 else 0\n",
    "\n",
    "# Process data and calculate metrics\n",
    "# def process_data(file_path):\n",
    "#     predictions, ground_truth = load_data(file_path)\n",
    "#     metrics = {'mae': [], 'precision': [], 'recall': [], 'dce': [], 'corrected_dce': []}\n",
    "    \n",
    "#     for i in range(predictions.shape[0]):\n",
    "#         filtered = predictions[i]\n",
    "#         truth = ground_truth[i]\n",
    "\n",
    "#         tp = np.sum((filtered > 0) & (truth > 0))\n",
    "#         fp = np.sum((filtered > 0) & (truth == 0))\n",
    "#         fn = np.sum((filtered == 0) & (truth > 0))\n",
    "#         detected_count = np.sum(filtered > 0)\n",
    "#         actual_count = np.sum(truth > 0)\n",
    "\n",
    "#         mae = calculate_mae(filtered, truth)\n",
    "#         precision = calculate_precision(tp, fp)\n",
    "#         recall = calculate_recall(tp, fn)\n",
    "#         dce = calculate_dce(detected_count, actual_count)\n",
    "#         deviations = np.random.uniform(0, 10, size=tp)  # Example deviations, replace with actual\n",
    "#         corrected_dce = calculate_corrected_dce(deviations, actual_count)\n",
    "\n",
    "#         metrics['mae'].append(mae)\n",
    "#         metrics['precision'].append(precision)\n",
    "#         metrics['recall'].append(recall)\n",
    "#         metrics['dce'].append(dce)\n",
    "#         metrics['corrected_dce'].append(corrected_dce)\n",
    "\n",
    "#     # Calculate average metrics\n",
    "#     for key in metrics:\n",
    "#         metrics[key] = np.mean(metrics[key])\n",
    "\n",
    "#     return metrics\n",
    "\n",
    "# # Example usage\n",
    "# file_path = '/home/m3-learning/Documents/myML/ValidationResults/Stack001_result.npz'\n",
    "# results = process_data(file_path)\n",
    "# print(results)\n",
    "\n",
    "# def process_data(file_path):\n",
    "#     # Load data\n",
    "#     result, mae, dce, recall, precision, deviations, dce_corrected = load_data(file_path)\n",
    "\n",
    "#     # Convert to numpy arrays if they are not already\n",
    "#     mae = np.array(mae)\n",
    "#     dce = np.array(dce)\n",
    "#     recall = np.array(recall)\n",
    "#     precision = np.array(precision)\n",
    "#     dce_corrected = np.array(dce_corrected)\n",
    "\n",
    "#     # Calculate average metrics\n",
    "#     metrics = {\n",
    "#         'Average MAE': np.mean(mae),\n",
    "#         'Average DCE': np.mean(dce),\n",
    "#         'Average Recall': np.mean(recall),\n",
    "#         'Average Precision': np.mean(precision),\n",
    "#         'Average Corrected DCE': np.mean(dce_corrected)\n",
    "#     }\n",
    "\n",
    "#     return metrics\n",
    "\n",
    "# Example usage\n",
    "# file_path = '/home/m3-learning/Documents/myML/ValidationResults/Stack001_result.npz'\n",
    "# results = process_data(file_path)\n",
    "# print(\"Aggregated Metrics:\", results)\n",
    "\n",
    "# def process_data(file_path):\n",
    "#     \"\"\"\n",
    "#     Process the loaded data to calculate average metrics.\n",
    "#     \"\"\"\n",
    "#     # Load results and metrics from the file\n",
    "#     result, mae, dce, recall, precision, deviations, dce_corrected = load_data(file_path)\n",
    "\n",
    "#     # Calculate average of each metric\n",
    "#     metrics = {\n",
    "#         'Average MAE': np.mean(mae),\n",
    "#         'Average DCE': np.mean(dce),\n",
    "#         'Average Recall': np.mean(recall),\n",
    "#         'Average Precision': np.mean(precision),\n",
    "#         'Average Corrected DCE': np.mean(dce_corrected)\n",
    "#     }\n",
    "\n",
    "#     return metrics\n",
    "\n",
    "# def print_results(metrics):\n",
    "#     \"\"\"\n",
    "#     Print the calculated average metrics.\n",
    "#     \"\"\"\n",
    "#     for metric_name, average_value in metrics.items():\n",
    "#         print(f\"{metric_name}: {average_value:.4f}\")\n",
    "\n",
    "# # Main function to run the script\n",
    "# def main():\n",
    "#     file_path = '/home/m3-learning/Documents/myML/ValidationData-20231107T163458Z-001/ValidationData/Stack007.npz'  # Update this to your actual file path\n",
    "#     results = process_data(file_path)\n",
    "#     print_results(results)\n",
    "\n",
    "# if __name__ == \"__main__\":\n",
    "#     main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def compute_iou(box1, box2):\n",
    "#     \"\"\"\n",
    "#     Compute the Intersection over Union (IoU) of two bounding boxes.\n",
    "\n",
    "#     Parameters:\n",
    "#     - box1, box2: (ymin, xmin, ymax, xmax)\n",
    "\n",
    "#     Returns:\n",
    "#     - iou: Intersection over Union (float)\n",
    "#     \"\"\"\n",
    "#     # Determine the coordinates of the intersection rectangle\n",
    "#     y_top = max(box1[0], box2[0])\n",
    "#     x_left = max(box1[1], box2[1])\n",
    "#     y_bottom = min(box1[2], box2[2])\n",
    "#     x_right = min(box1[3], box2[3])\n",
    "\n",
    "#     if x_right < x_left or y_bottom < y_top:\n",
    "#         return 0.0\n",
    "\n",
    "#     # Calculate intersection area\n",
    "#     intersection_area = (x_right - x_left) * (y_bottom - y_top)\n",
    "\n",
    "#     # Calculate the union area\n",
    "#     box1_area = (box1[3] - box1[1]) * (box1[2] - box1[0])\n",
    "#     box2_area = (box2[3] - box2[1]) * (box2[2] - box2[0])\n",
    "#     union_area = box1_area + box2_area - intersection_area\n",
    "\n",
    "#     # Compute the IoU\n",
    "#     iou = intersection_area / union_area\n",
    "#     return iou\n",
    "\n",
    "# import numpy as np\n",
    "\n",
    "# # Convert TensorFlow tensors to numpy arrays if they are not already\n",
    "# true_boxes = targets['x_boxes_reshape'].numpy() if isinstance(targets['x_boxes_reshape'], tf.Tensor) else targets['x_boxes_reshape']\n",
    "# predicted_boxes = output[1].numpy() if isinstance(output[1], tf.Tensor) else output[1]\n",
    "\n",
    "# iou_scores = []\n",
    "# mae_scores = []\n",
    "\n",
    "# for true_box, pred_box in zip(true_boxes, predicted_boxes):\n",
    "#     iou_score = compute_iou(true_box, pred_box)\n",
    "#     mae_score = compute_mae(true_box, pred_box)\n",
    "#     iou_scores.append(iou_score)\n",
    "#     mae_scores.append(mae_score)\n",
    "\n",
    "# # Calculate binary classification based on IoU threshold\n",
    "# good_predictions = [iou >= iou_threshold for iou in iou_scores]\n",
    "\n",
    "# # Calculate model performance based on IoU threshold\n",
    "# TP = sum(good_predictions)\n",
    "# FP = len(good_predictions) - TP  # In this context, all non-TP are treated as FP, which is simplistic\n",
    "\n",
    "# precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n",
    "# recall = TP / len(good_predictions) if len(good_predictions) > 0 else 0\n",
    "# f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n",
    "# mean_mae = np.mean(mae_scores)\n",
    "\n",
    "# print(f\"Precision: {precision}, Recall: {recall}, F1 Score: {f1_score}, Mean MAE: {mean_mae}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "# import tensorflow as tf\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "# # Assuming 'model' is your trained model and 'dataset' is prepared\n",
    "# for inputs, true_labels in dataset.take(1):  # Adjust this as necessary to process more of your data\n",
    "#     predictions = loadmodel.predict(inputs)\n",
    "\n",
    "#     # Convert predictions to a numpy array if it's not already one\n",
    "#     if isinstance(predictions, list):\n",
    "#         # Assuming you want to work with the first set of predictions if there are multiple outputs\n",
    "#         predictions = predictions[1]\n",
    "\n",
    "#     # Convert to numpy array if necessary\n",
    "#     predictions = np.array(predictions)\n",
    "\n",
    "#     # Apply threshold to classify as binary labels\n",
    "#     predicted_labels = (predictions > 0.5).astype(int)  # Assuming binary classification\n",
    "\n",
    "# # Calculate the confusion matrix\n",
    "# conf_matrix = tf.math.confusion_matrix(\n",
    "#     np.ravel(true_labels['x_boxes_reshape']),  # Ensure true_labels are also a numpy array\n",
    "#     np.ravel(predicted_labels[1]),  # Flatten the predicted labels\n",
    "#     num_classes=2  # Adjust this based on the number of classes in your model\n",
    "# )\n",
    "\n",
    "# # Convert to numpy array (optional, for easier manipulation)\n",
    "# conf_matrix = conf_matrix.numpy()\n",
    "\n",
    "# # Function to plot the confusion matrix\n",
    "# def plot_confusion_matrix(cm, class_names):\n",
    "#     \"\"\"\n",
    "#     Returns a matplotlib figure containing the plotted confusion matrix.\n",
    "    \n",
    "#     Args:\n",
    "#       cm (array, shape = [n, n]): a confusion matrix of integer classes\n",
    "#       class_names (array, shape = [n]): String names of the integer classes\n",
    "#     \"\"\"\n",
    "#     figure = plt.figure(figsize=(8, 8))\n",
    "#     plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
    "#     plt.title(\"Confusion Matrix\")\n",
    "#     plt.colorbar()\n",
    "#     tick_marks = np.arange(len(class_names))\n",
    "#     plt.xticks(tick_marks, class_names, rotation=45)\n",
    "#     plt.yticks(tick_marks, class_names)\n",
    "\n",
    "#     # Normalize the confusion matrix.\n",
    "#     cm = np.around(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], decimals=2)\n",
    "\n",
    "#     # Use white text if squares are dark; black text if squares are light.\n",
    "#     threshold = cm.max() / 2.\n",
    "#     for i, j in np.ndindex(cm.shape):\n",
    "#         color = \"white\" if cm[i, j] > threshold else \"black\"\n",
    "#         plt.text(j, i, cm[i, j], horizontalalignment=\"center\", color=color)\n",
    "\n",
    "#     plt.tight_layout()\n",
    "#     plt.ylabel('True label')\n",
    "#     plt.xlabel('Predicted label')\n",
    "#     return figure\n",
    "\n",
    "# # Assuming class names are 'Negative' and 'Positive' for a binary classification\n",
    "# class_names = ['Negative', 'Positive']\n",
    "# plot_confusion_matrix(conf_matrix, class_names)\n",
    "# plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "# import tensorflow as tf\n",
    "\n",
    "\n",
    "# import numpy as np\n",
    "# from scipy.ndimage import label\n",
    "\n",
    "# def create_binary_mask(dimensions, boxes):\n",
    "#     \"\"\"\n",
    "#     Create a binary mask from bounding boxes.\n",
    "#     \"\"\"\n",
    "#     mask = np.zeros(dimensions, dtype=np.uint8)\n",
    "#     for box in boxes:\n",
    "#         x_min, y_min, x_max, y_max = box\n",
    "#         mask[y_min:y_max, x_min:x_max] = 1\n",
    "#     return mask\n",
    "\n",
    "# def calculate_iou_components(pred_labels, gt_labels):\n",
    "#     \"\"\"\n",
    "#     Calculate IoU for each predicted component against each ground truth component.\n",
    "#     \"\"\"\n",
    "#     ious = []\n",
    "#     pred_objects = np.unique(pred_labels)[1:]  # Exclude background\n",
    "#     gt_objects = np.unique(gt_labels)[1:]  # Exclude background\n",
    "\n",
    "#     for pred_obj in pred_objects:\n",
    "#         pred_mask = pred_labels == pred_obj\n",
    "#         for gt_obj in gt_objects:\n",
    "#             gt_mask = gt_labels == gt_obj\n",
    "#             intersection = np.logical_and(pred_mask, gt_mask)\n",
    "#             union = np.logical_or(pred_mask, gt_mask)\n",
    "#             iou = np.sum(intersection) / np.sum(union)\n",
    "#             if iou > 0.5:  # Threshold to consider a match\n",
    "#                 ious.append((pred_obj, gt_obj, iou))\n",
    "#     return ious\n",
    "\n",
    "# def evaluate_image(predictions, ground_truths, dimensions):\n",
    "#     \"\"\"\n",
    "#     Evaluate a single image using precision, recall, and IoU.\n",
    "#     \"\"\"\n",
    "#     pred_mask = create_binary_mask(dimensions, predictions)\n",
    "#     gt_mask = create_binary_mask(dimensions, ground_truths)\n",
    "    \n",
    "#     pred_labels, num_pred = label(pred_mask)\n",
    "#     gt_labels, num_gt = label(gt_mask)\n",
    "    \n",
    "#     ious = calculate_iou_components(pred_labels, gt_labels)\n",
    "    \n",
    "#     true_positives = len(ious)\n",
    "#     predicted_positives = num_pred\n",
    "#     actual_positives = num_gt\n",
    "    \n",
    "#     precision = true_positives / predicted_positives if predicted_positives else 0\n",
    "#     recall = true_positives / actual_positives if actual_positives else 0\n",
    "    \n",
    "#     return {\n",
    "#         'Precision': precision,\n",
    "#         'Recall': recall,\n",
    "#         'IoU Matches': ious\n",
    "#     }\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "    \n",
    "# import numpy as np\n",
    "\n",
    "\n",
    "\n",
    "# def filter_boxes(boxes):\n",
    "#     \"\"\"\n",
    "#     Remove zero-sized or invalid boxes from the array.\n",
    "    \n",
    "#     Args:\n",
    "#         boxes: Array of bounding box coordinates.\n",
    "    \n",
    "#     Returns:\n",
    "#         Filtered array of bounding boxes.\n",
    "#     \"\"\"\n",
    "#     filtered_boxes = [box for box in boxes if (box[2] > box[0] and box[3] > box[1])]\n",
    "#     return np.array(filtered_boxes)\n",
    "\n",
    "\n",
    "\n",
    "# # def preprocess_and_evaluate(dataset, model, image_dimensions):\n",
    "# #     \"\"\"\n",
    "# #     Process and evaluate the dataset using the provided deep learning model.\n",
    "    \n",
    "# #     Args:\n",
    "# #         dataset: A tf.data.Dataset object.\n",
    "# #         model: A trained model that outputs predictions.\n",
    "# #         image_dimensions: Dimensions of the images in the dataset (height, width).\n",
    "    \n",
    "# #     Returns:\n",
    "# #         A list of evaluation results for each image in the dataset.\n",
    "# #     \"\"\"\n",
    "# #     results = []\n",
    "# #     for inputs, targets in dataset:\n",
    "# #         # Predict using the trained model\n",
    "# #         dataset = tf.data.Dataset.from_tensor_slices((images_np,{'x_prob_reshape':probabilities,'x_boxes_reshape':boxes_np}))\n",
    "# #         dataset = dataset.batch(10000)\n",
    "# #         inputs,targets = next(iter(dataset))\n",
    "        \n",
    "# #         predictions = model.predict(inputs)\n",
    "        \n",
    "# #         # Assuming predictions are already decoded to bounding boxes\n",
    "# #         # If not, you will need to convert the raw model outputs to bounding boxes\n",
    "# #         predicted_boxes = predictions[1]\n",
    "\n",
    "# #         # Ground truth boxes\n",
    "# #         ground_truth_boxes = targets['x_boxes_reshape'].numpy()\n",
    "\n",
    "# #         # Preprocess predicted and ground truth boxes\n",
    "# #         predictions_processed = preprocess_boxes(predicted_boxes, image_dimensions)\n",
    "# #         ground_truths_processed = preprocess_boxes(ground_truth_boxes, image_dimensions)\n",
    "\n",
    "# #         # Filter out invalid boxes\n",
    "# #         predictions_filtered = filter_boxes(predictions_processed)\n",
    "# #         ground_truths_filtered = filter_boxes(ground_truths_processed)\n",
    "\n",
    "# #         # Evaluate\n",
    "# #         result = evaluate_image(predictions_filtered, ground_truths_filtered, image_dimensions)\n",
    "# #         results.append(result)\n",
    "\n",
    "# #     return results\n",
    "\n",
    "# # # Usage Example\n",
    "# # # Define image dimensions based on your dataset specifics\n",
    "# # image_dimensions = (64, 64)  # Update with your actual image dimensions\n",
    "# # results = preprocess_and_evaluate(dataset, loadmodel, image_dimensions)\n",
    "\n",
    "# # for result in results:\n",
    "# #     print(result)\n",
    "# # import numpy as np\n",
    "# # import tensorflow as tf\n",
    "\n",
    "# def preprocess_boxes(boxes, image_dimensions):\n",
    "#     \"\"\"\n",
    "#     Normalize and convert bounding box coordinates to integer values, adjusting for small values.\n",
    "#     \"\"\"\n",
    "#     print(\"Preprocessing boxes with initial shape:\", boxes.shape)\n",
    "#     height, width = image_dimensions\n",
    "#     scaled_boxes = np.copy(boxes)\n",
    "#     scaled_boxes[:, 0] *= width\n",
    "#     scaled_boxes[:, 1] *= height\n",
    "#     scaled_boxes[:, 2] *= width\n",
    "#     scaled_boxes[:, 3] *= height\n",
    "\n",
    "#     scaled_boxes = np.rint(scaled_boxes).astype(int)\n",
    "#     for box in scaled_boxes:\n",
    "#         if box[2] == box[0]:  # Ensure minimum width\n",
    "#             box[2] = box[0] + 1\n",
    "#         if box[3] == box[1]:  # Ensure minimum height\n",
    "#             box[3] = box[1] + 1\n",
    "#     return scaled_boxes\n",
    "\n",
    "# # def preprocess_and_evaluate(dataset, model, image_dimensions):\n",
    "# #     \"\"\"\n",
    "# #     Process and evaluate the dataset using the provided deep learning model.\n",
    "# #     \"\"\"\n",
    "# #     results = []\n",
    "# #     for inputs, targets in dataset:\n",
    "# #         predictions = model.predict(inputs)\n",
    "        \n",
    "# #         # Debugging output\n",
    "# #         print(\"Predictions shape:\", predictions[1].shape)\n",
    "# #         print(\"Ground truth shape:\", targets['x_boxes_reshape'].numpy().shape)\n",
    "\n",
    "# #         predicted_boxes = predictions[1]\n",
    "# #         ground_truth_boxes = targets['x_boxes_reshape'].numpy()\n",
    "\n",
    "# #         # Ensure boxes are correctly shaped\n",
    "# #         if predicted_boxes.ndim < 2 or predicted_boxes.shape[1] != 4:\n",
    "# #             raise ValueError(\"Predicted boxes are not in the expected format. Expected shape (n, 4).\")\n",
    "\n",
    "# #         predictions_processed = preprocess_boxes(predicted_boxes, image_dimensions)\n",
    "# #         ground_truths_processed = preprocess_boxes(ground_truth_boxes, image_dimensions)\n",
    "\n",
    "# #         predictions_filtered = filter_boxes(predictions_processed)\n",
    "# #         ground_truths_filtered = filter_boxes(ground_truths_processed)\n",
    "\n",
    "# #         result = evaluate_image(predictions_filtered, ground_truths_filtered, image_dimensions)\n",
    "# #         results.append(result)\n",
    "\n",
    "# #     return results\n",
    "\n",
    "# # # Example usage\n",
    "# # image_dimensions = (64, 64)  # Update with your actual image dimensions\n",
    "# # results = preprocess_and_evaluate(dataset, loadmodel, image_dimensions)\n",
    "\n",
    "# # for result in results:\n",
    "# #     print(result)\n",
    "# import numpy as np\n",
    "# import tensorflow as tf\n",
    "\n",
    "# def preprocess_and_evaluate(dataset, model, image_dimensions):\n",
    "#     \"\"\"\n",
    "#     Process and evaluate the dataset using the provided deep learning model.\n",
    "#     \"\"\"\n",
    "#     results = []\n",
    "#     for inputs, targets in dataset:\n",
    "#         predictions = model.predict(inputs)\n",
    "        \n",
    "#         # Debugging output to understand the structure of predictions\n",
    "#         print(\"Predictions type:\", type(predictions))\n",
    "#         print(\"Predictions content:\", predictions)\n",
    "\n",
    "#         # Example assumes predictions to be a list or a similar structure\n",
    "#         # Adjust the index according to your model's output structure\n",
    "#         predicted_boxes = predictions[1] if isinstance(predictions, list) else predictions\n",
    "\n",
    "#         ground_truth_boxes = targets['x_boxes_reshape'].numpy()\n",
    "\n",
    "#         # More debugging output\n",
    "#         print(\"Predicted Boxes Shape:\", predicted_boxes.shape)\n",
    "#         print(\"Ground Truth Boxes Shape:\", ground_truth_boxes.shape)\n",
    "\n",
    "#         # Check the dimensions and format\n",
    "#         if predicted_boxes.ndim < 2 or predicted_boxes.shape[1] != 4:\n",
    "#             raise ValueError(\"Predicted boxes are not in the expected format. Expected shape (n, 4).\")\n",
    "\n",
    "#         predictions_processed = preprocess_boxes(predicted_boxes, image_dimensions)\n",
    "#         ground_truths_processed = preprocess_boxes(ground_truth_boxes, image_dimensions)\n",
    "\n",
    "#         predictions_filtered = filter_boxes(predictions_processed)\n",
    "#         ground_truths_filtered = filter_boxes(ground_truths_processed)\n",
    "\n",
    "#         result = evaluate_image(predictions_filtered, ground_truths_filtered, image_dimensions)\n",
    "#         results.append(result)\n",
    "\n",
    "#     return results\n",
    "\n",
    "# # Example usage\n",
    "# image_dimensions = (64, 64)  # Update with your actual image dimensions\n",
    "# results = preprocess_and_evaluate(dataset, loadmodel, image_dimensions)\n",
    "\n",
    "# for result in results:\n",
    "#     print(result)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision: 0\n",
      "Recall: 0\n",
      "F1-Score: 0\n"
     ]
    }
   ],
   "source": [
    "# def correct_bboxes(bboxes):\n",
    "#     \"\"\"Ensure the bounding boxes are in the format [x_min, y_min, x_max, y_max] and have meaningful size.\"\"\"\n",
    "#     corrected = []\n",
    "#     for bbox in bboxes:\n",
    "#         sorted_x = sorted([bbox[0], bbox[2]])\n",
    "#         sorted_y = sorted([bbox[1], bbox[3]])\n",
    "#         x_min, x_max = sorted_x[0], sorted_x[1]\n",
    "#         y_min, y_max = sorted_y[0], sorted_y[1]\n",
    "#         # Check if all coordinates are >= 1 and dimensions are valid\n",
    "#         if x_max > x_min + 1 and y_max > y_min + 1:\n",
    "#             corrected.append([x_min, y_min, x_max, y_max])\n",
    "#     return np.array(corrected)\n",
    "\n",
    "\n",
    "\n",
    "# import numpy as np\n",
    "\n",
    "# # Prediction and ground truth bounding boxes provided\n",
    "# predictions_raw = np.array([\n",
    "#     [39.8903408, 24.773323, 39.454777, 25.82823],\n",
    "#     [0.40461713, 0.2488891, 0.44437495, 0.2451111],\n",
    "#     [0.4801518, 0.56913036, 0.52614892, 0.60166949],\n",
    "#     [0.00044191495, 0.0005460676, 0.00068218674, 0.00090827933],\n",
    "#     [0.00040864121, 0.00038058122, 0.00060208299, 0.00024521281],\n",
    "#     [0.00052764977, 0.00058524718, 0.0002075122, 0.0010586288]\n",
    "# ])\n",
    "\n",
    "# ground_truth_raw = np.array([\n",
    "#     [39, 24, 39, 25],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0]\n",
    "# ])\n",
    "\n",
    "# def bbox_iou(box1, box2):\n",
    "#     \"\"\"Calculate the Intersection over Union (IoU) of two bounding boxes.\"\"\"\n",
    "#     x1, y1, x2, y2 = box1\n",
    "#     x1_p, y1_p, x2_p, y2_p = box2\n",
    "#     xi1, yi1 = max(x1, x1_p), max(y1, y1_p)\n",
    "#     xi2, yi2 = min(x2, x2_p), min(y2, y2_p)\n",
    "#     inter_area = max(xi2 - xi1, 0) * max(yi2 - yi1, 0)\n",
    "#     box1_area = (x2 - x1) * (y2 - y1)\n",
    "#     box2_area = (x2_p - x1_p) * (y2_p - y1_p)\n",
    "#     union_area = box1_area + box2_area - inter_area\n",
    "#     return inter_area / union_area if union_area != 0 else 0\n",
    "\n",
    "# def evaluate_metrics(gt_boxes, pred_boxes, iou_threshold=0.5):\n",
    "#     \"\"\"Evaluate detection metrics based on the IoU threshold.\"\"\"\n",
    "#     TP = 0\n",
    "#     FP = 0\n",
    "#     FN = 0\n",
    "#     matched = []\n",
    "#     for pred_box in pred_boxes:\n",
    "#         match_found = False\n",
    "#         for gt_box in gt_boxes:\n",
    "#             if bbox_iou(pred_box, gt_box) >= iou_threshold:\n",
    "#                 if gt_box not in matched:\n",
    "#                     TP += 1\n",
    "#                     matched.append(gt_box)\n",
    "#                     match_found = True\n",
    "#                     break\n",
    "#         if not match_found:\n",
    "#             FP += 1\n",
    "#     FN = len(gt_boxes) - len(matched)\n",
    "#     precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n",
    "#     recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n",
    "#     f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n",
    "#     return precision, recall, f1_score\n",
    "\n",
    "# # Apply corrections\n",
    "# predictions = correct_bboxes(predictions_raw)\n",
    "# ground_truth = correct_bboxes(ground_truth_raw)\n",
    "\n",
    "# # Calculate metrics\n",
    "# precision, recall, f1_score = evaluate_metrics(ground_truth, predictions)\n",
    "# print(\"Precision:\", precision)\n",
    "# print(\"Recall:\", recall)\n",
    "# print(\"F1-Score:\", f1_score)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of Prediction Masks: 1\n",
      "Number of Ground Truth Masks: 1\n"
     ]
    }
   ],
   "source": [
    "# import numpy as np\n",
    "\n",
    "# def prepare_bboxes(bboxes):\n",
    "#     \"\"\"Prepare bounding boxes by setting values less than 1 to zero.\"\"\"\n",
    "#     # Applying the threshold by setting values less than 1 to zero\n",
    "#     bboxes[bboxes < 1] = 0\n",
    "#     # Return only those boxes where no coordinate is zero\n",
    "#     return bboxes[np.all(bboxes[:, [0, 2]] > 0, axis=1) & np.all(bboxes[:, [1, 3]] > 0, axis=1)]\n",
    "\n",
    "# def create_binary_mask(bbox, shape):\n",
    "#     \"\"\"Create a binary mask from a bounding box.\"\"\"\n",
    "#     mask = np.zeros(shape, dtype=np.uint8)\n",
    "#     if np.any(bbox > 0):  # Check if any value in bbox is greater than 0\n",
    "#         x_min, y_min, x_max, y_max = map(int, bbox)\n",
    "#         mask[y_min:y_max, x_min:x_max] = 1\n",
    "#     return mask\n",
    "\n",
    "# # Image dimensions (assuming 64x64 based on previous context)\n",
    "# image_shape = (64, 64)\n",
    "\n",
    "# # Example bounding boxes\n",
    "# predictions_raw = np.array([\n",
    "#     [39.8903408, 24.773323, 39.454777, 25.82823],\n",
    "#     [0.40461713, 0.2488891, 0.44437495, 0.2451111],\n",
    "#     [0.4801518, 0.56913036, 0.52614892, 0.60166949],\n",
    "#     [0.00044191495, 0.0005460676, 0.00068218674, 0.00090827933],\n",
    "#     [0.00040864121, 0.00038058122, 0.00060208299, 0.00024521281],\n",
    "#     [0.00052764977, 0.00058524718, 0.0002075122, 0.0010586288]\n",
    "# ])\n",
    "\n",
    "# ground_truth_raw = np.array([\n",
    "#     [39, 24, 39, 25],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0]\n",
    "# ])\n",
    "\n",
    "# # Filter and prepare bounding boxes\n",
    "# filtered_predictions = prepare_bboxes(predictions_raw)\n",
    "# filtered_ground_truth = prepare_bboxes(ground_truth_raw)\n",
    "\n",
    "# # Create binary masks\n",
    "# pred_masks = np.array([create_binary_mask(bbox, image_shape) for bbox in filtered_predictions])\n",
    "# gt_masks = np.array([create_binary_mask(bbox, image_shape) for bbox in filtered_ground_truth])\n",
    "\n",
    "# # Display number of masks created\n",
    "# print(\"Number of Prediction Masks:\", len(pred_masks))\n",
    "# print(\"Number of Ground Truth Masks:\", len(gt_masks))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "\n",
    "# def prepare_bboxes(bboxes):\n",
    "#     \"\"\"Prepare bounding boxes by setting values less than 1 to zero.\"\"\"\n",
    "#     # Applying the threshold by setting values less than 1 to zero\n",
    "#     bboxes[bboxes < 1] = 0\n",
    "#     # Return only those boxes where no coordinate is zero\n",
    "#     return bboxes[np.all(bboxes[:, [0, 2]] > 0, axis=1) & np.all(bboxes[:, [1, 3]] > 0, axis=1)]\n",
    "\n",
    "\n",
    "# # Image dimensions (assuming 64x64 based on previous context)\n",
    "# image_shape = (64, 64)\n",
    "\n",
    "# # Example bounding boxes\n",
    "# predictions_raw = np.array([\n",
    "#     [39.8903408, 24.773323, 39.454777, 25.82823],\n",
    "#     [0.40461713, 0.2488891, 0.44437495, 0.2451111],\n",
    "#     [0.4801518, 0.56913036, 0.52614892, 0.60166949],\n",
    "#     [0.00044191495, 0.0005460676, 0.00068218674, 0.00090827933],\n",
    "#     [0.00040864121, 0.00038058122, 0.00060208299, 0.00024521281],\n",
    "#     [0.00052764977, 0.00058524718, 0.0002075122, 0.0010586288]\n",
    "# ])\n",
    "\n",
    "# ground_truth_raw = np.array([\n",
    "#     [39, 24, 39, 25],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0],\n",
    "#     [0, 0, 0, 0]\n",
    "# ])\n",
    "\n",
    "# # Filter and prepare bounding boxes\n",
    "# filtered_predictions = prepare_bboxes(predictions_raw)\n",
    "# filtered_ground_truth = prepare_bboxes(ground_truth_raw)\n",
    "\n",
    "# import numpy as np\n",
    "\n",
    "# # Corrected bounding box values\n",
    "# ground_truth = np.array([[38, 24, 40, 25]])\n",
    "# predictions = np.array([[int(39.8903408), int(24.773323), int(39.454777)+1, int(25.82823)+1]])  # Added +1 to ensure non-zero area\n",
    "\n",
    "# # Function to create binary masks\n",
    "# def create_binary_mask(bbox, shape):\n",
    "#     mask = np.zeros(shape, dtype=np.uint8)\n",
    "#     mask[bbox[1]:bbox[3], bbox[0]:bbox[2]] = 1\n",
    "#     return mask\n",
    "\n",
    "# # Assuming 64x64 image size\n",
    "# image_shape = (64, 64)\n",
    "\n",
    "# # Create binary masks\n",
    "# gt_mask = create_binary_mask(ground_truth[0], image_shape)\n",
    "# pred_mask = create_binary_mask(predictions[0], image_shape)\n",
    "\n",
    "\n",
    "# import numpy as np\n",
    "\n",
    "# def calculate_metrics(gt_mask, pred_mask):\n",
    "#     \"\"\"Calculate precision, recall, and F1-score based on binary masks.\"\"\"\n",
    "#     TP = np.sum((gt_mask == 1) & (pred_mask == 1))\n",
    "#     FP = np.sum((gt_mask == 0) & (pred_mask == 1))\n",
    "#     FN = np.sum((gt_mask == 1) & (pred_mask == 0))\n",
    "\n",
    "#     precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n",
    "#     recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n",
    "#     f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n",
    "\n",
    "#     return precision, recall, f1_score\n",
    "\n",
    "# # Calculate metrics for each mask pair\n",
    "# if len(pred_masks) == len(gt_masks):\n",
    "#     metrics = [calculate_metrics(gt, pred) for gt, pred in zip(gt_masks, pred_masks)]\n",
    "#     # Calculate average metrics if necessary or just list them\n",
    "#     average_precision = np.mean([m[0] for m in metrics])\n",
    "#     average_recall = np.mean([m[1] for m in metrics])\n",
    "#     average_f1_score = np.mean([m[2] for m in metrics])\n",
    "#     print(\"Average Precision:\", average_precision)\n",
    "#     print(\"Average Recall:\", average_recall)\n",
    "#     print(\"Average F1-Score:\", average_f1_score)\n",
    "#     # Optionally print individual mask metrics\n",
    "#     for idx, (prec, rec, f1) in enumerate(metrics):\n",
    "#         print(f\"Mask {idx + 1} - Precision: {prec}, Recall: {rec}, F1-Score: {f1}\")\n",
    "# else:\n",
    "#     print(\"Mismatch in number of prediction and ground truth masks.\")\n",
    "# # Calculate metrics\n",
    "# precision, recall, f1_score = calculate_metrics(gt_mask, pred_mask)\n",
    "\n",
    "# # Visualization function goes here (as defined in previous responses)\n",
    "\n",
    "# # Display metrics and visualize\n",
    "# print(\"Precision:\", precision)\n",
    "# print(\"Recall:\", recall)\n",
    "# print(\"F1-Score:\", f1_score)\n",
    "# # Call the visualization function (provided in previous responses) here\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[39, 24, 39, 25]]),\n",
       " array([[39.8903408, 24.773323 , 39.454777 , 25.82823  ]]))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filtered_ground_truth,filtered_predictions\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average Precision: 0.0\n",
      "Average Recall: 0.0\n",
      "Average F1-Score: 0.0\n",
      "Mask 1 - Precision: 0, Recall: 0, F1-Score: 0\n"
     ]
    }
   ],
   "source": [
    "# import numpy as np\n",
    "\n",
    "# def calculate_metrics(gt_mask, pred_mask):\n",
    "#     \"\"\"Calculate precision, recall, and F1-score based on binary masks.\"\"\"\n",
    "#     TP = np.sum((gt_mask == 1) & (pred_mask == 1))\n",
    "#     FP = np.sum((gt_mask == 0) & (pred_mask == 1))\n",
    "#     FN = np.sum((gt_mask == 1) & (pred_mask == 0))\n",
    "\n",
    "#     precision = TP / (TP + FP) if (TP + FP) > 0 else 0\n",
    "#     recall = TP / (TP + FN) if (TP + FN) > 0 else 0\n",
    "#     f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0\n",
    "\n",
    "#     return precision, recall, f1_score\n",
    "\n",
    "# # Calculate metrics for each mask pair\n",
    "# if len(pred_masks) == len(gt_masks):\n",
    "#     metrics = [calculate_metrics(gt, pred) for gt, pred in zip(gt_masks, pred_masks)]\n",
    "#     # Calculate average metrics if necessary or just list them\n",
    "#     average_precision = np.mean([m[0] for m in metrics])\n",
    "#     average_recall = np.mean([m[1] for m in metrics])\n",
    "#     average_f1_score = np.mean([m[2] for m in metrics])\n",
    "#     print(\"Average Precision:\", average_precision)\n",
    "#     print(\"Average Recall:\", average_recall)\n",
    "#     print(\"Average F1-Score:\", average_f1_score)\n",
    "#     # Optionally print individual mask metrics\n",
    "#     for idx, (prec, rec, f1) in enumerate(metrics):\n",
    "#         print(f\"Mask {idx + 1} - Precision: {prec}, Recall: {rec}, F1-Score: {f1}\")\n",
    "# else:\n",
    "#     print(\"Mismatch in number of prediction and ground truth masks.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import numpy as np\n",
    "# import matplotlib.pyplot as plt\n",
    "\n",
    "# def plot_masks_with_metrics(gt_masks, pred_masks, metrics):\n",
    "#     \"\"\"Plot each pair of ground truth and prediction masks with calculated metrics.\"\"\"\n",
    "#     num_masks = len(gt_masks)\n",
    "#     if num_masks == 1:\n",
    "#         fig, axes = plt.subplots(nrows=num_masks, ncols=3, figsize=(15, 5))\n",
    "#         axes = np.array([axes])  # Convert to 2D array-like for consistent indexing\n",
    "#     else:\n",
    "#         fig, axes = plt.subplots(nrows=num_masks, ncols=3, figsize=(15, 5 * num_masks))\n",
    "\n",
    "#     for i in range(num_masks):\n",
    "#         gt_mask = gt_masks[i]\n",
    "#         pred_mask = pred_masks[i]\n",
    "#         precision, recall, f1_score = metrics[i]\n",
    "\n",
    "#         # True Positive (Intersection)\n",
    "#         tp_mask = np.logical_and(gt_mask == 1, pred_mask == 1)\n",
    "#         # False Positive\n",
    "#         fp_mask = np.logical_and(gt_mask == 0, pred_mask == 1)\n",
    "#         # False Negative\n",
    "#         fn_mask = np.logical_and(gt_mask == 1, pred_mask == 0)\n",
    "\n",
    "#         # Plotting ground truth mask\n",
    "#         axes[i][0].imshow(gt_mask, cmap='gray')\n",
    "#         axes[i][0].set_title('Ground Truth Mask')\n",
    "#         axes[i][0].axis('off')\n",
    "\n",
    "#         # Plotting prediction mask\n",
    "#         axes[i][1].imshow(pred_mask, cmap='gray')\n",
    "#         axes[i][1].set_title('Prediction Mask')\n",
    "#         axes[i][1].axis('off')\n",
    "\n",
    "#         # Plotting combined mask with TP, FP, FN\n",
    "#         axes[i][2].imshow(gt_mask, cmap='gray', alpha=0.5)  # Ground truth in gray\n",
    "#         axes[i][2].imshow(pred_mask, cmap='hot', alpha=0.5)  # Prediction in hot color map\n",
    "#         # Highlight TP, FP, FN\n",
    "#         axes[i][2].imshow(tp_mask, cmap='Greens', alpha=0.5)  # True Positives in green\n",
    "#         axes[i][2].imshow(fp_mask, cmap='Blues', alpha=0.5)  # False Positives in blue\n",
    "#         axes[i][2].imshow(fn_mask, cmap='Reds', alpha=0.5)  # False Negatives in red\n",
    "#         axes[i][2].set_title(f'Combined\\nPrecision: {precision:.2f}, Recall: {recall:.2f}, F1-Score: {f1_score:.2f}')\n",
    "#         axes[i][2].axis('off')\n",
    "\n",
    "#     plt.tight_layout()\n",
    "#     plt.show()\n",
    "\n",
    "# # Example call (assuming pred_masks, gt_masks, and metrics have been defined earlier in your script)\n",
    "# plot_masks_with_metrics(gt_masks, pred_masks, metrics)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "electron",
   "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}