bounding box regression copy 4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load all necessary imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-16 12:24:43.138251: 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-16 12:24:43.170015: 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-16 12:24:43.170043: 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-16 12:24:43.170790: 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-16 12:24:43.175657: 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-16 12:24:43.816494: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n",
      "2024-04-16 12:24:44.875613: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 21372 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\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py\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": "markdown",
   "metadata": {},
   "source": [
    "Data Loading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-16 12:25:10.970603: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1929] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 21372 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3090, pci bus id: 0000:68:00.0, compute capability: 8.6\n"
     ]
    }
   ],
   "source": [
    "with h5py.File('TrainingData5zeroes.h5', 'r') as hdf:\n",
    "    ls = list(hdf.keys())\n",
    "    images = hdf.get('images')\n",
    "    boxes = hdf.get('boxes')\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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Normalization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_shape = (64,64,1)\n",
    "num_classes = 280\n",
    "num_coordinates = 4\n",
    "\n",
    "x_input = layers.Input(shape=input_shape)\n",
    "#Layer 1\n",
    "x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x_input)\n",
    "x = layers.MaxPool2D()(x)\n",
    "x = layers.BatchNormalization()(x) \n",
    "x = layers.Conv2D(64, kernel_size=3, padding='same', activation='relu')(x)\n",
    "#Layer 2\n",
    "x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n",
    "x = layers.Conv2D(128, kernel_size=3, padding='same', activation='relu')(x)\n",
    "#Layer 3\n",
    "x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n",
    "x = layers.Conv2D(256, kernel_size=3, padding='same', activation='relu')(x)\n",
    "#Layer 4\n",
    "x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n",
    "x = layers.MaxPool2D()(x)\n",
    "x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n",
    "x = layers.MaxPool2D()(x)\n",
    "x = layers.Conv2D(512, kernel_size=3, padding='same', activation='relu')(x)\n",
    "x = layers.MaxPool2D()(x)\n",
    "#Layer 5\n",
    "x = layers.Conv2D(256, kernel_size=5, padding='same', activation='relu')(x)\n",
    "x = layers.MaxPool2D()(x)\n",
    "x = layers.BatchNormalization()(x) \n",
    "\n",
    "\n",
    "x = layers.Flatten()(x)\n",
    "# Probability output\n",
    "x_prob = layers.Dense(num_classes, activation='sigmoid', name='x_prob')(x)\n",
    "x_prob_reshape = layers.Reshape((-1, num_classes, 1), name='x_prob_reshape')(x_prob)\n",
    "\n",
    "# Bounding box output\n",
    "x_boxes = layers.Dense(num_classes * num_coordinates, activation='sigmoid', name='x_boxes')(x)\n",
    "x_boxes_reshape = layers.Reshape((-1, num_classes, num_coordinates), name='x_boxes_reshape')(x_boxes)\n",
    "\n",
    "\n",
    "model = tf.keras.models.Model(x_input, [x_prob_reshape, x_boxes_reshape])\n",
    "optimizer = tf.keras.optimizers.Adam(learning_rate=3e-5) \n",
    "model.compile(optimizer= optimizer, loss= {'x_prob_reshape': tf.keras.losses.BinaryCrossentropy(), 'x_boxes_reshape':tf.keras.losses.MeanSquaredError()}, metrics={'x_prob_reshape': 'accuracy'} )\n",
    "num_epochs = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check to see if "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "loaded_model = tf.keras.models.load_model(\"/home/m3-learning/Documents/Research Data/Derrick's Object Detection/Models/M11overfittedmodel3variant.h5\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-16 12:26:23.092975: I external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:454] Loaded cuDNN version 8904\n",
      "2024-04-16 12:26:23.181350: I external/local_tsl/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 15/313 [>.............................] - ETA: 2s"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-04-16 12:26:23.530415: I external/local_tsl/tsl/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 3s 9ms/step\n"
     ]
    }
   ],
   "source": [
    "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",
    "output =loaded_model.predict(inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(1, 280, 4), dtype=float64, numpy=\n",
       "array([[[0.609375, 0.375   , 0.609375, 0.390625],\n",
       "        [0.      , 0.      , 0.      , 0.      ],\n",
       "        [0.      , 0.      , 0.      , 0.      ],\n",
       "        ...,\n",
       "        [0.      , 0.      , 0.      , 0.      ],\n",
       "        [0.      , 0.      , 0.      , 0.      ],\n",
       "        [0.      , 0.      , 0.      , 0.      ]]])>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "targets['x_boxes_reshape'][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.608321  , 0.37544996, 0.60048765, 0.39058328],\n",
       "        [0.04114862, 0.04350902, 0.03601224, 0.03161911],\n",
       "        [0.02564523, 0.01642084, 0.0225285 , 0.02103107],\n",
       "        ...,\n",
       "        [0.00356427, 0.00505332, 0.00641309, 0.00199714],\n",
       "        [0.00315547, 0.00425017, 0.00402874, 0.00372648],\n",
       "        [0.01020624, 0.01075523, 0.00156876, 0.00145441]]], dtype=float32)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output[1][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSE Loss: 4.790622258574036e-05\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "r = np.random.randint(0,100)\n",
    "tensor1 = tf.constant(targets['x_boxes_reshape'][r], dtype=tf.float64)\n",
    "\n",
    "tensor2 = tf.constant(output[1][r], dtype=tf.float32)\n",
    "\n",
    "\n",
    "tensor2 = tf.cast(tensor2, tf.float64)\n",
    "\n",
    "\n",
    "mse_loss_fn = tf.keras.losses.MeanSquaredError()\n",
    "mse_loss = mse_loss_fn(tensor1, tensor2)\n",
    "\n",
    "print(\"MSE Loss:\", mse_loss.numpy())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAAF2CAYAAAC72fnJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA3i0lEQVR4nO3de3gTZb4H8G96C6WXFErpRWgpWqmIgIKUiAJKEe8IFZHFFQSOq5a756xwdgHdVcvKekCQi4IHcBGQsgssutysWI5aEAo8qGgtUqVc2irQpBRoS/OeP9iOTTKFSTJp3oTv53nm0cxMZn5zya/D+5t5xyCEECAiIp8K8nUARETEZExEJAUmYyIiCTAZExFJgMmYiEgCTMZERBJgMiYikgCTMRGRBJiMiYgkwGRMMBgMeOmll5TPK1asgMFgwI8//uizmPyRLPtNLY7+/fujf//+zR6Lr9brj5iMPdRw4jce2rZti7vvvhtbtmzxdXh+56WXXrLbl0FBQUhMTMRDDz2E3bt3N2ssjzzyCFq2bImqqqom5xk5ciTCwsJw+vTpZoxMLocPH8ZLL73k8z9C/i7E1wEEij/96U9ITU2FEALl5eVYsWIFHnjgAWzevBkPPfSQr8NzyW9/+1s88cQTMBqNPoth8eLFiIyMhM1mQ2lpKZYuXYq+ffviyy+/RPfu3ZslhpEjR2Lz5s3YsGEDnnrqKafp58+fx6ZNm3DfffchNjZWiv3WlO3bt3tt2YcPH8bLL7+M/v37o0OHDs223kDDZKyT+++/Hz179lQ+jx07FvHx8VizZo3fJePg4GAEBwf7NIbHHnsMbdq0UT4/+uij6NKlC3Jzc5stGT/yyCOIiorC6tWrVZPxpk2bUF1djZEjRwKQY781JSws7Jparz9iM4WXxMTEIDw8HCEh9n/vqqur8cILL6B9+/YwGo3o1KkT/vrXv6Jx53k//vgjDAYDVqxY4bRcx/bdhn/WHzlyBKNHj0ZMTAxMJhOefvppnD9/3u67NTU1mDJlCuLi4hAVFYVHHnkEx48fd1qHWptjhw4d8NBDD+Gzzz5Dr1690KJFC3Ts2BHvvfee0/cPHTqEfv36ITw8HO3atcMrr7yC5cuXe9SempCQAABO+7OiokL5w9eiRQt069YNK1eutJseFxeH/v372+3jI0eOICIiAsOHD29yneHh4Rg6dCjy8vJQUVHhNH316tXKfgTU99u+ffswaNAgtGnTBuHh4UhNTcWYMWOU6Z9++ikMBgM+/fRTu2WrnQOHDh3C6NGj0bFjR7Ro0QIJCQkYM2aMpiYSx7bbDh06ODWvNQwNsfz00094/vnn0alTJ4SHhyM2NhbDhg2z274VK1Zg2LBhAIC7777baRlqbcZXO2aNt/+vf/0r3nnnHVx//fUwGo24/fbbsXfv3qturz/ilbFOLBYLfvnlFwghUFFRgQULFuDcuXN48sknlXmEEHjkkUewc+dOjB07Ft27d8e2bdvwX//1Xzhx4gTmzp3r9voff/xxpKamIicnB/v378eyZcvQtm1b/OUvf1HmGTduHFatWoXf/OY3uOOOO/DJJ5/gwQcf1LyOI0eO4LHHHsPYsWMxatQo/O///i9Gjx6NHj164OabbwYAnDhxQvlRTp8+HREREVi2bJnL/3Q/c+YMAMBms+HEiRP485//jBYtWuDxxx9X5rlw4QL69++PI0eOYPz48UhNTUVubi5Gjx6NyspKTJo0CW3btsXixYsxbNgwLFiwABMnToTNZsPo0aMRFRWFRYsWXTGOkSNHYuXKlVi3bh3Gjx9vF9+2bdswYsQIhIeHq363oqIC9957L+Li4jBt2jTExMTgxx9/xD/+8Q+X9kWDHTt24OjRo3j66aeRkJCAb775Bu+88w6++eYb7N69GwaDQfOy5s2bh3PnztmNmzt3Lg4ePIjY2FgAwN69e/HFF1/giSeeQLt27fDjjz9i8eLF6N+/Pw4fPoyWLVuib9++mDhxIubPn4///u//xk033QQAyn8daTlmja1evRpVVVX43e9+B4PBgNdffx1Dhw7F0aNHERoa6sruk58gjyxfvlwAcBqMRqNYsWKF3bwbN24UAMQrr7xiN/6xxx4TBoNBHDlyRAghRElJiQAgli9f7rQ+AGLWrFnK51mzZgkAYsyYMXbzDRkyRMTGxiqfDx48KACI559/3m6+3/zmN07LbNimkpISZVxKSooAIHbt2qWMq6ioEEajUbzwwgvKuAkTJgiDwSAOHDigjDt9+rRo3bq10zLVNGyP4xATEyO2bt1qN++8efMEALFq1SplXG1trTCbzSIyMlJYrVZl/IgRI0TLli3F999/L+bMmSMAiI0bN14xFiGEuHTpkkhMTBRms9lu/JIlSwQAsW3bNmWc437bsGGDACD27t3b5PJ37twpAIidO3fajVc7B86fP+/0/TVr1jgdF7Xj169fP9GvX78m41i3bp0AIP70pz9dcX0FBQUCgHjvvfeUcbm5uarboLZercesYftjY2PFmTNnlHk3bdokAIjNmzc3uS3+is0UOlm4cCF27NiBHTt2YNWqVbj77rsxbtw4u6ugf/3rXwgODsbEiRPtvvvCCy9ACOHR3RfPPvus3ee77roLp0+fhtVqVdYNwGndkydP1ryOzp0746677lI+x8XFoVOnTjh69KgybuvWrTCbzXbtuq1bt1baVbX6+9//jh07dmD79u1Yvnw5brzxRmRlZeGLL75Q5vnXv/6FhIQEjBgxQhkXGhqKiRMn4ty5c8jPz1fGv/XWWzCZTHjssccwY8YM/Pa3v8XgwYOvGkdwcDCeeOIJFBQU2P3zfPXq1YiPj8eAAQOa/G5MTAwA4MMPP0RdXZ0LW6+u8RX4xYsX8csvv6B3794AgP3797u93MOHD2PMmDEYPHgw/vjHP6qur66uDqdPn8YNN9yAmJgYt9fnyjEDgOHDh6NVq1bK54bzr/E5FyiYjHXSq1cvZGZmIjMzEyNHjsRHH32Ezp07Y/z48aitrQVwuQ0uKSkJUVFRdt9t+CfdTz/95Pb6k5OT7T43nMBnz55Vlh0UFITrr7/ebr5OnTq5vY6G9TSso2E9N9xwg9N8auOupG/fvsjMzMTAgQMxevRo5OXlISoqChMmTLBbV1paGoKC7E9jtf3ZunVrzJ8/H4cOHYLJZML8+fM1x9Lwh2T16tUAgOPHj+P//u//8MQTT1yxYNevXz9kZWXh5ZdfRps2bTB48GAsX74cNTU1mtfd2JkzZzBp0iTEx8cjPDwccXFxSE1NBXC5mcwdVqsVQ4cOxXXXXYf33nvPrqnjwoULmDlzplLfaNOmDeLi4lBZWen2+lw5ZsDVz+tAwmTsJUFBQbj77rtx6tQpFBcXu/Tdptr+6uvrm/xOU0lB6PhWreZYR1MiIyORkZGB/fv3o7q62q1lbNu2DcDlH7Ja4bIpPXr0QHp6OtasWQMAWLNmDYQQV73aNxgMWL9+PQoKCjB+/HicOHECY8aMQY8ePZT2WleO9eOPP46lS5fi2WefxT/+8Q9s374dW7duBXC5bd0do0ePxsmTJ7Fx40ZER0fbTZswYQJeffVVPP7441i3bh22b9+OHTt2IDY21u31ucqX51xzYzL2okuXLgGA8sNLSUnByZMnnR4i+O6775TpwK9//SsrK+3m8+TKOSUlBTabDT/88IPd+KKiIreX2dR6jhw54jRebZyr1PZncXGxU2Jw3J/A5eaTZcuW4fe//z3i4uIwatQoZXlajBw5El9//TUOHTqE1atXIy0tDbfffrum7/bu3Ruvvvoq9u3bh/fffx/ffPMN1q5dC0D7sT579izy8vIwbdo0vPzyyxgyZAgGDhyIjh07at4GR7Nnz8bGjRvx3nvvIT093Wn6+vXrMWrUKLzxxht47LHHMHDgQNx5551OsbpSOHTlmF1rmIy9pK6uDtu3b0dYWJjyT7AHHngA9fX1eOutt+zmnTt3LgwGA+6//34AQHR0NNq0aYNdu3bZzXe1yv+VNCzb8Z/n8+bNc3uZagYNGoSCggIcPHhQGXfmzBm8//77Hi33zJkz+OKLL5CQkIC2bdsCuLw/y8rK8MEHHyjzXbp0CQsWLEBkZCT69esH4HKiGzduHHr16oXXXnsNy5Ytw/79+/Haa69pXn/DVfDMmTNx8OBBTW3gZ8+edbqCa2hLb2iqSElJQXBw8FWPdcMVouPy3D1+H3/8Mf74xz/iD3/4Ax599FHVeYKDg53Wt2DBAqer9oiICADOf1DUaD1m1yLe2qaTLVu2KH/dKyoqsHr1ahQXF2PatGnKP/8efvhh3H333fjDH/6AH3/8Ed26dcP27duxadMmTJ482a49d9y4cZg9ezbGjRuHnj17YteuXfj+++/djq979+4YMWIEFi1aBIvFgjvuuAN5eXm6XLE29vvf/x6rVq3CwIEDMWHCBOXWtuTkZJw5c0bzVdT69esRGRkJIQROnjyJd999F2fPnsWSJUuUZTzzzDN4++23MXr0aBQWFqJDhw5Yv349Pv/8c8ybN09pm580aRJOnz6Njz/+GMHBwbjvvvswbtw4vPLKKxg8eDC6det21XhSU1Nxxx13YNOmTQCgKRmvXLkSixYtwpAhQ3D99dejqqoKS5cuRXR0NB544AEAgMlkUm67MxgMuP766/Hhhx863dccHR2Nvn374vXXX0ddXR2uu+46bN++HSUlJZr2p6MRI0YgLi4OaWlpWLVqld20gQMHIj4+Hg899BD+9re/wWQyoXPnzigoKMDHH3+s3PrWoHv37ggODsZf/vIXWCwWGI1G3HPPPcofzca0HrNrks/u4wgQare2tWjRQnTv3l0sXrxY2Gw2u/mrqqrElClTRFJSkggNDRVpaWlizpw5TvOdP39ejB07VphMJhEVFSUef/xxUVFR0eStbT///LNqXI1vb7pw4YKYOHGiiI2NFREREeLhhx8WpaWlmm9te/DBB522X+2WqQMHDoi77rpLGI1G0a5dO5GTkyPmz58vAIiysrIr7k+1W9siIiKE2WwW69atc5q/vLxcPP3006JNmzYiLCxM3HLLLXa3gzXcCvXGG2/Yfc9qtYqUlBTRrVs3UVtbe8WYGixcuFAAEL169VKd7rjf9u/fL0aMGCGSk5OF0WgUbdu2FQ899JDYt2+f3fd+/vlnkZWVJVq2bClatWolfve734mvv/7a6da248ePiyFDhoiYmBhhMpnEsGHDxMmTJzUdP8fj5LiPGw8Nt6idPXtW2beRkZFi0KBB4rvvvhMpKSli1KhRdtuwdOlS0bFjRxEcHGy3DLXz42rHTIhfb22bM2eO03523N5AYRAiAFvCSTqTJ0/G22+/jXPnzkn7yDCRL7HNmHR34cIFu8+nT5/G3/72N9x5551MxERNYJsx6c5sNqN///646aabUF5ejnfffRdWqxUzZszwdWhE0mIyJt098MADWL9+Pd555x0YDAbcdtttePfdd9G3b19fh0YkLbYZExFJgG3GREQS8FoyXrhwITp06IAWLVogIyMDX375pbdWRUTk97zSTPHBBx/gqaeewpIlS5CRkYF58+YhNzcXRUVFqjeCN2az2XDy5ElERUW59JglEZFshBCoqqpCUlKSU+dIajPrrlevXiI7O1v5XF9fL5KSkkROTs5Vv9vwEAIHDhw4BMpQWlp61dynezNFbW0tCgsLkZmZqYwLCgpCZmYmCgoKrvp9Vx6HdHxdjCfUXj/jbb5Yp78LCQlxGhxxv5JstOQ13W9t++WXX1BfX4/4+Hi78fHx8UrfDY3V1NTY9e/auEezxj8iodKa4vgjU5tHK7UfrOPytMyj9zpl5u341ZavZZy/79fmoOdvx9sC4XhquSDw+d0UOTk5MJlMytC+fXtfh0RE1Ox0T8Zt2rRBcHAwysvL7caXl5crb/htbPr06bBYLMpQWlqqd0hERNLTPRmHhYWhR48eyMvLU8bZbDbk5eXBbDY7zW80GhEdHW03NBBCKIMam81mN/gbx/htNhuCgoLsBrJXV1fnNDQ+T4QQqvuV7OnZph4cHOw06Mnx+PpbE4VWXnkceurUqRg1ahR69uyJXr16Yd68eaiursbTTz/tjdUREfk9ryTj4cOH4+eff8bMmTNRVlaG7t27Y+vWrU5FPSIiuky6vimsVitMJlOzr1etScDxn7fNUdV1jEPmf2L74m4KyU5Xv6XneabWLHGll+deiywWi9MLXx2xUZKISAJ+04WmlitXT2hZFq/K7Hl7f3B//8qTIpu39yOvgvXBK2MiIgkwGRMRSYDJmIhIAlK3GTduJ9PSphsI1XeZ755oboFwPPWi93b703nm7XqRLOcZr4yJiCTAZExEJAEmYyIiCTAZExFJQOoCnquN6N5+NFlt+VrXqbVI4O3HobV0Ku7tgolWMscmK1mKUXry9vF1d//cd999TuO2bt3qdhy8MiYikoDUV8ZERL7U+Jr5uMO0Fjt3Kv9/PiQEf0tLg/vXxUzGRESatHMc0ejdnaipwW+Li/FHD5bPZExEpIHTlbHRCABoVVODYAAtL13yaPkBn4w9KWjoWTjQ8nZrvdepNY7mjsETesamZzHQk2Xp+aZmWfqT9qe3T1/JcVy+Ij4OwPFVyUvefBMAMHLaNERWVqJFeLj91bKLWMAjIpIAkzERkQSYjImIJMBkTEQkAb6QVDKBUvjQgy+eJgvEJ9jU+NN5pucx0bqshvmOCdFkAa9BKZou8jXgC0mJiPwEkzERkQSYjImIJMBkTEQkgYB/As8TvihyyFBIuVaKWLLQ8zzT+iSglnXIch7ouU61ZRn//VhzY5GRkQCAoLNnAZvt8n512I/K/tEpPl4ZExFJgMmYiEgCTMZERBIIqDZjtfYyra9K0vJdT9rQQkNDncbV1dVp+q6etLRP6vkqKVdvsnfnu+5yd/l6v/pJz3XK0Osc4F81hhqVntamTp0KAIh46y2gqgoRERFAVZXdPLq/5k3XpRERkVsC6sqYiMgbos6dQ2kT0xJ1WgeTMRFRE2rCwgAAQf/uo+JKqq4y/WqYjImImvBx377I3LULxtpaVFU1nW6rAMzwcF1+02ubWpHAkdbCnJ6vw9ESlyvflaFA5e8FGWpePF+ujr22ERH5CSZjIiIJuJyMd+3ahYcffhhJSUkwGAzYuHGj3XQhBGbOnInExESEh4cjMzMTxcXFesVLRBSQXE7G1dXV6NatGxYuXKg6/fXXX8f8+fOxZMkS7NmzBxERERg0aBAuXrzocbBERAFLeACA2LBhg/LZZrOJhIQEMWfOHGVcZWWlMBqNYs2aNZqWabFYBACvDgaDwWnQMp+34+JgPwQFBTkNvo4pEGLloM+gNY8AEBaL5aq5T9c245KSEpSVlSEzM1MZZzKZkJGRgYKCAj1XRUQUUHS9z7isrAwAEB8fbzc+Pj5emeaopqbG7tlwq9WqZ0hERH7B53dT5OTkwGQyKUP79k29X5WIKHDpmowTEhIAAOXl5Xbjy8vLlWmOpk+fDovFogylpU09AU5EFLh0TcapqalISEhAXl6eMs5qtWLPnj0wm82q3zEajYiOjrYb9GQwGJwGIYTToEbLPOQ9NpvNaZCVP8VK9oKCgpwGLbTmEa1cbjM+d+4cjhw5onwuKSnBwYMH0bp1ayQnJ2Py5Ml45ZVXkJaWhtTUVMyYMQNJSUl49NFHPQqUiCigabrfrJGdO3eq3roxatQoIcTl29tmzJgh4uPjhdFoFAMGDBBFRUWal6/3rW2u3H7CgQOHa29ojtsStdza5jcdBbmLnZgQ0ZXo/eYWNewoiIjITwR8f8Z6XgXzKtv3tLyr0N+PSSCeZzJvky/eG6i6PLe/SUREumEyJiKSAJMxEZEEmIyJiCQQ8AU8PRvZZSk4qJG1QKJ3keNaeLJN7+Om5dzw9u1dWrdJ1vO4OfDKmIhIAkzGREQSYDImIpJAwLcZ+6KN0ZP2N8c2M63tZbK2qzXH/ldrZ3Tk7f2jta3TF22iast3PEfVjpOWB2yaGucuX5zHwcHBTuPq6+ubPQ5eGRMRSYDJmIhIAkzGREQSYDImIpJAwBfwfMGTolWg9TLXHH3FylC89LdCq5ZjoOdxao7zwJGWwi7g/jHRO35eGRMRSYDJmIhIAkzGREQSYDImIpKA1AW8xg3wao3xWhrQvd2IL0ORrCnuxqFnscUXhRtPyHw83aV2DBx58mSdluX74ph70lOcFnztEhFRAGIyJiKSAJMxEZEEmIyJiCQgdQGvcQO8lsZ4rQ3xehZpvP2KHF8Uj/Qstly6dEm3ZTUHLd1eenJM3D33PCkWaSnOqcWldZwvinPuHpOQEOeU5+45yifwiIgCEJMxEZEEmIyJiCTAZExEJAGpC3hX09zvi9P6TjBP1unvT3tpOSYyP+XmbqHMF901ao1Vyzo9OT/1fBJN67nhOE5rDFqLdVqWp/d5zCtjIiIJMBkTEUmAyZiISAJ+3Wbc3D2taW3/1Npe5m89mjnScz/KQm3/a2kH1/NBEE/OM1+0x8twzuq9jVq2Se918sqYiEgCTMZERBJwKRnn5OTg9ttvR1RUFNq2bYtHH30URUVFdvNcvHgR2dnZiI2NRWRkJLKyslBeXq5r0EREgcalZJyfn4/s7Gzs3r0bO3bsQF1dHe69915UV1cr80yZMgWbN29Gbm4u8vPzcfLkSQwdOlT3wImIAorwQEVFhQAg8vPzhRBCVFZWitDQUJGbm6vM8+233woAoqCgQNMyLRaLAKDbYDAYnAY9l8+BAwf/HoKCgpwGvddhsViumvs8ajO2WCwAgNatWwMACgsLUVdXh8zMTGWe9PR0JCcno6CgwJNVEREFNLdvbbPZbJg8eTL69OmDLl26AADKysoQFhaGmJgYu3nj4+NRVlamupyamhrU1NQon61Wq7shERH5LbevjLOzs/H1119j7dq1HgWQk5MDk8mkDO3bt/doeURE/sitZDx+/Hh8+OGH2LlzJ9q1a6eMT0hIQG1tLSorK+3mLy8vR0JCguqypk+fDovFogylpaXuhERE5N9cKdjZbDaRnZ0tkpKSxPfff+80vaGAt379emXcd999JwDPC3hqjex6Fua0FPoCsRiotk3BwcFOgy/i8GQ+GfajL+JojmIUB9cHLQU8l9qMs7OzsXr1amzatAlRUVFKO7DJZEJ4eDhMJhPGjh2LqVOnonXr1oiOjsaECRNgNpvRu3dvV1ZFRHRt0X5dLJrM+suXL1fmuXDhgnj++edFq1atRMuWLcWQIUPEqVOnNK+DV8bNO/DKuHnj9/bAK2M5By1XxoZ/J1lpWK1WmEwmp/FaOnb3ZFO0dLAic6fo7lLbJrV9XV9f3+xxqO1bWY+BLHH5e+dTgcpisSA6OvqK87BvCiIiCUjdhWbjqw1v/3XXchXj7VfrAEBwcLDdZ72vSB2vnNT2qy+upGS4uvWEnvF7cnXLq2D/xStjIiIJMBkTEUmAyZiISAJMxkREEpC6gHe1ooiWd4fpSWtxxJPbnLx9C5kWnuxHo9Fo97lxJ1B6kLXQp2dxNxCKcM392wyEW/p4ZUxEJAEmYyIiCTAZExFJQOo246vR0g6lZ1uS1mXJ2q4JeL8dTUsbsb+372l5NL+pcbJSa/NWG6f1ODX3tqvF5W+P2PPKmIhIAkzGREQSYDImIpIAkzERkQT8poDnbiO7Jw37WpalRmuByrGHNqD5+w32t5vxZSj+eXufhYQ4/ywvXbrk1XX6ogApw7EE5Cm08sqYiEgCTMZERBJgMiYikgCTMRGRBKQt4BkMBl1euyRLkUCNL3po0/OpRS2FUL33tZ7L0/rUmZYX32rttU0LvYt1Wo6n1qcK1bj7pJ4nx1JLIVrmp+3U8MqYiEgCTMZERBJgMiYikgCTMRGRBKQt4Akh7BrW3S3E+aJYp+eTenoXHLQUPmTpJlHPVxl58j0t8/liX2hdp5bj6ckTeDJvu17faw68MiYikgCTMRGRBJiMiYgkwGRMRCQBaQt4jmR5ak5P7hZWPOG4PJmfSPJFHFrW6W/vVtNC5u4yZd1nuncP60kwRESkDyZjIiIJMBkTEUmAyZiISAJ+U8BT09zvc9MSQ1NxyFLMcSw6eLswKst2e6K595kaf9+PMhfg1d5FqeXJVC3dyrpyjHhlTEQkASZjIiIJuJSMFy9ejK5duyI6OhrR0dEwm83YsmWLMv3ixYvIzs5GbGwsIiMjkZWVhfLyct2DJiIKNAbhQqPG5s2bERwcjLS0NAghsHLlSsyZMwcHDhzAzTffjOeeew4fffQRVqxYAZPJhPHjxyMoKAiff/655oCsVitMJpNbGyMzra/4cbdtzRdtinre9O7JsmRo0/WEY/xaaw7efm0R6cdisSA6OvrKMwkPtWrVSixbtkxUVlaK0NBQkZubq0z79ttvBQBRUFCgeXkWi0UACLjBYDA4DUFBQU6Dnsv39jbpGb8ny9IrBl8NjvF7+1xRO198vQ8CfbBYLFfNfW63GdfX12Pt2rWorq6G2WxGYWEh6urqkJmZqcyTnp6O5ORkFBQUNLmcmpoaWK1Wu4GI6FrjcjL+6quvEBkZCaPRiGeffRYbNmxA586dUVZWhrCwMMTExNjNHx8fj7KysiaXl5OTA5PJpAzt27d3eSOIiPydy8m4U6dOOHjwIPbs2YPnnnsOo0aNwuHDh90OYPr06bBYLMpQWlrq9rKIiPyVyw99hIWF4YYbbgAA9OjRA3v37sWbb76J4cOHo7a2FpWVlXZXx+Xl5UhISGhyeUajEUaj0fXI/YzQWJTR8qohtWWpjVOjZ7FLz2KjL+KQhbu99/miJzR/evjE27HqvXyP7zO22WyoqalBjx49EBoairy8PGVaUVERjh07BrPZ7OlqiIgCmktXxtOnT8f999+P5ORkVFVVYfXq1fj000+xbds2mEwmjB07FlOnTkXr1q0RHR2NCRMmwGw2o3fv3t6Kn4goILiUjCsqKvDUU0/h1KlTMJlM6Nq1K7Zt24aBAwcCAObOnYugoCBkZWWhpqYGgwYNwqJFi7wSOBFRIHHpoY/mEKgPfahRa/PTcjg8apeS4AEJf2p3lJneb5rQwp+OnUxtxloe+pC21zaDwWC3sTIUafQ+uL7YJsd1aikYAtoLkM39xwRo/gQkS/LRut16nreybLsW3o5V7+WzoyAiIgkwGRMRSYDJmIhIAkzGREQSkLaAJ4SQrlggWzx60PpklydP/blL7yf13OW4nZ4UxLR8V+9CsS/OWxnu2tGbtwu5vDImIpIAkzERkQSYjImIJMBkTEQkAWkLeHrRsxiid2FF1thkeUTa39/rp8bdJxR98eShJ2SOzV1eP/e8unQiItKEyZiISAJMxkREEvCbNmN3X0cUEuK8iXV1dW7FoPtN3irtgPX19W4tS2v7qgw9kGlt/9Tao5wWWtuk3X0Fkrd50gbrT91e6knrdqenpzuN++6779xap+O57crDa7wyJiKSgN9cGRMRedO3ja6GjzcaXwVgBoC/e3n9TMZERA7aOXz+M5iMiYiaXcOVcSKAYABRzbBOv0nG7hYc3C3WeUJr4cDdYp0arQUeLfvRkwcMtBTdtC7L3XVq7WHO2wVCX/Rq54ve9bwtODjYaZyW347W7e7fvz8A4GxpKVpVV+NsRATu69ABAPBxURESLl26fCPApUtXXZYnhVYW8IiIJOA3V8ZERM3BdP48Pi4qAgDEabga1guTMRERgIuhoQCAICGQ4JCEz6s03emNzRRERAA23347TsXE4GxEBMpCQpThaFgYFrRt6/X1G4RkrftWqxUmk8lpvJZXAXm7B7VAfJJJbZv0fDLQkzi0Ft1kOAayxOVvvbtdKywWC6Kjo684D6+MiYgkwGRMRCQBJmMiIgkwGRMRScBvbm1ztwihtaDh7utwPFmnFt4ubHn7yUA9939TZOgWVIYiIiDPK7NkeH2Y1mVpPUfVusfUsnyteGVMRCQBJmMiIgkwGRMRSYDJmIhIAlIX8K7WxaGWxnI93x2mtXFez0KfJ+v0RTHEcT69C0pa3lvn70+hae3a09tPSvqii049l6Xnew9dmc9dvDImIpIAkzERkQQ8SsazZ8+GwWDA5MmTlXEXL15EdnY2YmNjERkZiaysLJSXl3saJxFRQHO7zXjv3r14++230bVrV7vxU6ZMwUcffYTc3FyYTCaMHz8eQ4cOxeeff+7yOrx1I71aW5sad9uItN5YrmX7PGn31dKm68myfNE2q2X5sjyA4S6t8cvSk54v1ul47qmdFzI8AOPS/hJuqKqqEmlpaWLHjh2iX79+YtKkSUIIISorK0VoaKjIzc1V5v32228FAFFQUKBp2RaLRQDw6hAUFKRp8PY6DQaD0+D4PS3zuDLouSxv7zO9ttHT7bxWB18cX63HTsbzTi3+hvEWi+Wquc+tZors7Gw8+OCDyMzMtBtfWFiIuro6u/Hp6elITk5GQUGB6rJqampgtVrtBiKia43LzRRr167F/v37sXfvXqdpZWVlCAsLQ0xMjN34+Ph4lJWVqS4vJycHL7/8sqthEBEFFJeujEtLSzFp0iS8//77aNGihS4BTJ8+HRaLRRlKS0t1WS4RkT9x6cq4sLAQFRUVuO2225Rx9fX12LVrF9566y1s27YNtbW1qKystLs6Li8vR0JCguoyjUYjjEaje9G7ydsN+57cWO7IpQKATsvTWphTG6flgQW9t8ndookvetfTk7fX6YsCmFr8wcHBTuO8Xbx0lyf736VkPGDAAHz11Vd2455++mmkp6fjxRdfRPv27REaGoq8vDxkZWUBAIqKinDs2DGYzWa3gyQiCnQuJeOoqCh06dLFblxERARiY2OV8WPHjsXUqVPRunVrREdHY8KECTCbzejdu7d+URMRBRjd+6aYO3cugoKCkJWVhZqaGgwaNAiLFi3SezVERAHFILzdsOUiq9UKk8nk6zA8Istr293lSVsq24xdj8Nd/n6eaeVPbcZNsVgsiI6OvuI8Uvfa1pz0/GH64geh5w/Tk8KNu+v0pIctX2ynXjH42zrdpbUnOrVt8kVPdFq+q/f+Z0dBREQSYDImIpIAkzERkQSYjImIJCB1Aa9xg7m3ixX+VAxR4+4dBL54GlEtVrX5/On1SVq7SNXzPNPzLgNv35mh9ZhrPQ/c3U5PtsnbOYJXxkREEmAyJiKSAJMxEZEEmIyJiCQgdQHPWw3m3i4MefI0mT/Rsh+1Fm5keYeZu/SMVev56Ysn0/Q8tz05N9wl8yPkvDImIpIAkzERkQSYjImIJMBkTEQkAakLeN6i9d1tjg37njT+y1KM0jMOX3QxKnMBRi9a96uehWh3fxNNjXOXLE/aatl2LU9durI9vDImIpIAkzERkQSYjImIJOA3bca+6FXK3fX5exumWm9ger7uyBP+tG/dbdNV+54aT9r/tbxCyBf7Wpae+tzddk/2Ga+MiYgkwGRMRCQBJmMiIgkwGRMRScBvCnjuNozLUhDwJ3r2BqaVLA9z6HWzf1PjtNB6fqrFqkaW4pwWvuj9TpYcwStjIiIJMBkTEUmAyZiISAJMxkREEvCbAp4MZGno93cy78dA7IFMi0B8VZi3n5jVe1/wypiISAJMxkREEmAyJiKSAJMxEZEEpC7gNS4g+KJLO0dan97xpyeefMHbrxXy9tN83i5i+eJpRE/OWXdfWaY1DnepLUuWJz3V8MqYiEgCTMZERBJwKRm/9NJLMBgMdkN6eroy/eLFi8jOzkZsbCwiIyORlZWF8vJy3YMmIgo0Ll8Z33zzzTh16pQyfPbZZ8q0KVOmYPPmzcjNzUV+fj5OnjyJoUOH6howEVEgcrmAFxISgoSEBKfxFosF7777LlavXo177rkHALB8+XLcdNNN2L17N3r37u1ycI0b1t1tePf2U0p6F3O0vJtMy/ea+q5jUUzmJ6rcjU3vfeYuPZ809PenFr1dJNO6f7ydD5r1HXjFxcVISkpCx44dMXLkSBw7dgwAUFhYiLq6OmRmZirzpqenIzk5GQUFBU0ur6amBlar1W4gIrrWuJSMMzIysGLFCmzduhWLFy9GSUkJ7rrrLlRVVaGsrAxhYWGIiYmx+058fDzKysqaXGZOTg5MJpMytG/f3q0NISLyZy41U9x///3K/3ft2hUZGRlISUnBunXrEB4e7lYA06dPx9SpU5XPVquVCZmIrjkePfQRExODG2+8EUeOHMHAgQNRW1uLyspKu6vj8vJy1TbmBkajEUajUXWaqw99eLsNUOtN5GrtV1pfZaTlFT+etIXJ0s7oLj2PsawPh2h9AEPmBxiamyfn9bJly5zGjR071mmc4/72eZtxY+fOncMPP/yAxMRE9OjRA6GhocjLy1OmFxUV4dixYzCbzZ6shogo4Ll0Zfyf//mfePjhh5GSkoKTJ09i1qxZCA4OxogRI2AymTB27FhMnToVrVu3RnR0NCZMmACz2ezWnRRERM1p7Lhxv35o/P8AMHy419fvUjI+fvw4RowYgdOnTyMuLg533nkndu/ejbi4OADA3LlzERQUhKysLNTU1GDQoEFYtGiRVwInImo2H3zg9VUYhGSNTFarFSaTCYB8bcZa1+lJm7GWZfl7u68n9DzG/r5v2Wasj4Y247GOV8ONDR8Og0NCduX8sVgsiI6OvmIcUidj8n9MGK7z9z8S1wotr6oSQkAIoSkZs6MgIiIJMBkTEUmAyZiISAJMxkREEpD6tUtX424PZ77g7dczyVookyEGvWkp3ADuF92u5WKdnq9n8sUTuT57Ao+IiPTBZExEJAEmYyIiCTAZExFJwG8KeLIWqLTSu7Ffr2X5+35V48k2aSnOedKFqSz7W9bitwy/CcA3T0HyypiISAJMxkREEmAyJiKSAJMxEZEEpC7gsT9j7xcSZCncaKXlGGvdJr3fL6iFnsvy5Hz3t+Pe3LT8xvT+bfLKmIhIAkzGREQSYDImIpKA1G3GrrZr+aJ9WG2derbp6n2juWM7l9ryQ0NDncbV1dXpsr6m1qmVnsdYLQ5v1x30XL6scfmCLx7S0P23qevSiIjILUzGREQSYDImIpIAkzERkQSkLuA1pqWBXmsRQs9ihS8KB1ppfdWTI3eLdWpk2Rd68uSYy1oU87de52SMwVO8MiYikgCTMRGRBJiMiYgkwGRMRCQBvyngaSmQeLvHKn8rEmh9wkxPsr7ORyst8fqiKKn3q6T87bhcTXPsCy1Pr3qCV8ZERBJgMiYikgCTMRGRBJiMiYgk4DcFPC3UnoxSa7CX9RVIzUFLsULrk3tax/kTPYtdWoulWpavNo8nr43SUmiVudjlqDkKnN7eBl4ZExFJgMmYiEgCLifjEydO4Mknn0RsbCzCw8Nxyy23YN++fcp0IQRmzpyJxMREhIeHIzMzE8XFxboGTUQUaFxKxmfPnkWfPn0QGhqKLVu24PDhw3jjjTfQqlUrZZ7XX38d8+fPx5IlS7Bnzx5ERERg0KBBuHjxou7BExEFDOGCF198Udx5551NTrfZbCIhIUHMmTNHGVdZWSmMRqNYs2aNpnVYLBYBgAMHYTAYnIagoCCnQc/ly7AsWfa1J9vU3PtCz1i9Ea/FYrlq7nPpyvif//wnevbsiWHDhqFt27a49dZbsXTpUmV6SUkJysrKkJmZqYwzmUzIyMhAQUGB6jJrampgtVrtBiKia41Lyfjo0aNYvHgx0tLSsG3bNjz33HOYOHEiVq5cCQAoKysDAMTHx9t9Lz4+XpnmKCcnByaTSRnat2/vznYQEfk1l5KxzWbDbbfdhtdeew233nornnnmGfzHf/wHlixZ4nYA06dPh8ViUYbS0lK3l0VE5K9cSsaJiYno3Lmz3bibbroJx44dAwAkJCQAAMrLy+3mKS8vV6Y5MhqNiI6OthuIiK41LiXjPn36oKioyG7c999/j5SUFABAamoqEhISkJeXp0y3Wq3Ys2cPzGazDuFeWVBQkNNAvuXJMRFCOA02m81pkIFarP5E7/gdl2UwGJwGPXkSv9bvejP+hkA0+/LLL0VISIh49dVXRXFxsXj//fdFy5YtxapVq5R5Zs+eLWJiYsSmTZvEoUOHxODBg0Vqaqq4cOGCpnV4cjeFnpV2DvoMMh8Tf78Dwp/2TyDsa0/i13I3hUvJWAghNm/eLLp06SKMRqNIT08X77zzjt10m80mZsyYIeLj44XRaBQDBgwQRUVFmpfPZBxYg8zHJBAShL/sn0DY195OxgYh5Pr3lNVqhclkcuu7gdCRT6CR+ZhcC2/A8IS3O03yt33tyVtsLBbLVethAdVrmyw/ck/4+2uLHMl8TPxp3/oimXmyfD3PY1kSubd/m6xwERFJgMmYiEgCTMZERBJgMiYikkBAFfBk4ckdBM1dwJP5bgd/4osik9Z1aplP7/j13HZfFOt88bvglTERkQSYjImIJMBkTEQkAenajP3pRvymyNLWJuP6ApXMD2Bo+S7PA3t67w8ty5PuyriqqsrXIXhM6NiDlLd5EitRoNL7d6Elr0nXN4XNZsPJkycRFRWFqqoqtG/fHqWlpX7Zz7HVamX8PsT4fcvf4wc83wYhBKqqqpCUlHTV7mOla6YICgpCu3btAPx6u42/dzrP+H2L8fuWv8cPeLYNWjs+k66ZgojoWsRkTEQkAamTsdFoxKxZs2A0Gn0dilsYv28xft/y9/iB5t0G6Qp4RETXIqmvjImIrhVMxkREEmAyJiKSAJMxEZEEpE3GCxcuRIcOHdCiRQtkZGTgyy+/9HVITdq1axcefvhhJCUlwWAwYOPGjXbThRCYOXMmEhMTER4ejszMTBQXF/smWAc5OTm4/fbbERUVhbZt2+LRRx9FUVGR3TwXL15EdnY2YmNjERkZiaysLJSXl/soYnuLFy9G165dlZvyzWYztmzZokyXOXY1s2fPhsFgwOTJk5Vxsm/DSy+9BIPBYDekp6cr02WPHwBOnDiBJ598ErGxsQgPD8ctt9yCffv2KdOb4zcsZTL+4IMPMHXqVMyaNQv79+9Ht27dMGjQIFRUVPg6NFXV1dXo1q0bFi5cqDr99ddfx/z587FkyRLs2bMHERERGDRoEC5evNjMkTrLz89HdnY2du/ejR07dqCurg733nsvqqurlXmmTJmCzZs3Izc3F/n5+Th58iSGDh3qw6h/1a5dO8yePRuFhYXYt28f7rnnHgwePBjffPMNALljd7R37168/fbb6Nq1q914f9iGm2++GadOnVKGzz77TJkme/xnz55Fnz59EBoaii1btuDw4cN444030KpVK2WeZvkNCwn16tVLZGdnK5/r6+tFUlKSyMnJ8WFU2gAQGzZsUD7bbDaRkJAg5syZo4yrrKwURqNRrFmzxgcRXllFRYUAIPLz84UQl2MNDQ0Vubm5yjzffvutACAKCgp8FeYVtWrVSixbtsyvYq+qqhJpaWlix44dol+/fmLSpElCCP/Y/7NmzRLdunVTneYP8b/44ovizjvvbHJ6c/2Gpbsyrq2tRWFhITIzM5VxQUFByMzMREFBgQ8jc09JSQnKysrstsdkMiEjI0PK7bFYLACA1q1bAwAKCwtRV1dnF396ejqSk5Oli7++vh5r165FdXU1zGazX8WenZ2NBx980C5WwH/2f3FxMZKSktCxY0eMHDkSx44dA+Af8f/zn/9Ez549MWzYMLRt2xa33norli5dqkxvrt+wdMn4l19+QX19PeLj4+3Gx8fHo6yszEdRua8hZn/YHpvNhsmTJ6NPnz7o0qULgMvxh4WFISYmxm5emeL/6quvEBkZCaPRiGeffRYbNmxA586d/SJ2AFi7di3279+PnJwcp2n+sA0ZGRlYsWIFtm7disWLF6OkpAR33XUXqqqq/CL+o0ePYvHixUhLS8O2bdvw3HPPYeLEiVi5ciWA5vsNS9drG/lOdnY2vv76a7v2Pn/QqVMnHDx4EBaLBevXr8eoUaOQn5/v67A0KS0txaRJk7Bjxw60aNHC1+G45f7771f+v2vXrsjIyEBKSgrWrVuH8PBwH0amjc1mQ8+ePfHaa68BAG699VZ8/fXXWLJkCUaNGtVscUh3ZdymTRsEBwc7VVvLy8uRkJDgo6jc1xCz7Nszfvx4fPjhh9i5c6fShSlwOf7a2lpUVlbazS9T/GFhYbjhhhvQo0cP5OTkoFu3bnjzzTf9IvbCwkJUVFTgtttuQ0hICEJCQpCfn4/58+cjJCQE8fHx0m+Do5iYGNx44404cuSIXxyDxMREdO7c2W7cTTfdpDS1NNdvWLpkHBYWhh49eiAvL08ZZ7PZkJeXB7PZ7MPI3JOamoqEhAS77bFardizZ48U2yOEwPjx47FhwwZ88sknSE1NtZveo0cPhIaG2sVfVFSEY8eOSRG/GpvNhpqaGr+IfcCAAfjqq69w8OBBZejZsydGjhyp/L/s2+Do3Llz+OGHH5CYmOgXx6BPnz5Ot3N+//33SElJAdCMv2HdSoE6Wrt2rTAajWLFihXi8OHD4plnnhExMTGirKzM16GpqqqqEgcOHBAHDhwQAMT//M//iAMHDoiffvpJCCHE7NmzRUxMjNi0aZM4dOiQGDx4sEhNTRUXLlzwceRCPPfcc8JkMolPP/1UnDp1ShnOnz+vzPPss8+K5ORk8cknn4h9+/YJs9kszGazD6P+1bRp00R+fr4oKSkRhw4dEtOmTRMGg0Fs375dCCF37E1pfDeFEPJvwwsvvCA+/fRTUVJSIj7//HORmZkp2rRpIyoqKoQQ8sf/5ZdfipCQEPHqq6+K4uJi8f7774uWLVuKVatWKfM0x29YymQshBALFiwQycnJIiwsTPTq1Uvs3r3b1yE1aefOnQKA0zBq1CghxOVbY2bMmCHi4+OF0WgUAwYMEEVFRb4N+t/U4gYgli9frsxz4cIF8fzzz4tWrVqJli1biiFDhohTp075LuhGxowZI1JSUkRYWJiIi4sTAwYMUBKxEHLH3hTHZCz7NgwfPlwkJiaKsLAwcd1114nhw4eLI0eOKNNlj18IITZv3iy6dOkijEajSE9PF++8847d9Ob4DbMLTSIiCUjXZkxEdC1iMiYikgCTMRGRBJiMiYgkwGRMRCQBJmMiIgkwGRMRSYDJmIhIAkzGREQSYDImIpIAkzERkQSYjImIJPD/x/y9kgNb16cAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 400x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def visualize_bounding_boxes(image, probability_vector, bounding_box_coordinates, threshold=0.9):\n",
    "    \"\"\"\n",
    "    Visualizes bounding boxes on an image based on a probability vector.\n",
    "\n",
    "    Parameters:\n",
    "    - image: A 3D tensor representing the image.\n",
    "    - probability_vector: A 1D tensor representing the probabilities associated with bounding boxes.\n",
    "    - bounding_box_coordinates: A 2D tensor representing bounding box coordinates.\n",
    "    - threshold: Probability threshold for visualization.\n",
    "\n",
    "    Returns:\n",
    "    None (displays the image with bounding boxes).\n",
    "    \"\"\"\n",
    "    # Convert to NumPy arrays for easier handling\n",
    "    image_np = image\n",
    "    prob_vector_np = probability_vector\n",
    "    bbox_coordinates_np = bounding_box_coordinates\n",
    "   # Denormalize image if necessary (adjust based on your normalization method)\n",
    "    denormalized_image = image_np  # Modify if normalization was applied during training\n",
    "\n",
    "    # Visualize the image\n",
    "    plt.figure(figsize=(4, 4))\n",
    "    plt.imshow(denormalized_image, cmap='gray')\n",
    "    plt.title(\"Bounding Box Visualization\")\n",
    "\n",
    "    # Plot bounding boxes based on probability threshold\n",
    "    for i in range(len(prob_vector_np)):\n",
    "        prob = prob_vector_np[i]\n",
    "        bbox = bbox_coordinates_np[i]\n",
    "        if prob > threshold:\n",
    "            # Denormalize bounding box coordinates if necessary\n",
    "            denormalized_bbox = bbox  # Modify if normalization was applied during training\n",
    "            y1, x1, y2, x2 = denormalized_bbox\n",
    "            plt.plot([x1, x2, x2, x1, x1],[y1, y1, y2, y2, y1],\n",
    "                     \n",
    "                     color='r', linewidth=2, label='Bounding Box')\n",
    "\n",
    "   \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "   \n",
    "    plt.show()\n",
    "\n",
    "t = np.random.randint(0,200)\n",
    "# probabilities = tf.convert_to_tensor(output[0][t,:])\n",
    "\n",
    "visualize_bounding_boxes(tf.convert_to_tensor(inputs[t]), probabilities.numpy()[t].squeeze(), tf.convert_to_tensor(output[1][t,0,:,:])*[64,64,64,64]) ##myprediction\n",
    "visualize_bounding_boxes(tf.convert_to_tensor(image_normalized[t]), probabilities.numpy()[t].squeeze(), tf.convert_to_tensor(boxes_np[t,0,:,:])*[64,64,64,64]) ##myprediction\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tiny_yolo",
   "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
}