yolo_512x512_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "igEd7obtcxR2"
   },
   "source": [
    "# Approach\n",
    "\n",
    "* This is a simplied version of YOLO. We take our 512x512 input, divide it into a 16x16 grid, each cell outputs five values:\n",
    "    * The confidence that there is pneumonia present\n",
    "    * The x, y, w, and h of the bounding box\n",
    "* For labels we have assigned each box to the cell which is in it's center and have assigned the actual x, y, w, and h values to that cell.\n",
    "\n",
    "# Network\n",
    "\n",
    "* The network consists of a number of residual blocks with convolutions and downsampling blocks with max pooling.\n",
    "* The network outputs a 16x16x1 array of confidences and a 16x16x4 array of bounding boxes.\n",
    "* The confidence cells have a sigmoid activation, the bboxes are linear.\n",
    "* We use a binary cross entropy loss for the confidence and mean squared error for the bounding boxes.\n",
    "\n",
    "# Predictions\n",
    "* To generate our predictions we loop through each cell of the output, if the confidence is greater than 0.5 we append the corresponding bounding box to the prediction string. \n",
    "\n",
    "**Note:** Since each pixel only outputs one bounding box there is currently no non-max suppression. We can add this later if neccessary.\n",
    "\n",
    "**Change Log:**\n",
    "* v2 - adding extra 1x1 convs for each output; changed loss weights to weight xe loss a bit higher; working on IOU metric function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LHncOor-cxSS"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import csv\n",
    "import random\n",
    "import pydicom\n",
    "import numpy as np\n",
    "import pickle\n",
    "import pandas as pd\n",
    "from skimage import measure\n",
    "from skimage.transform import resize\n",
    "import datetime\n",
    "import math\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "import matplotlib.patches as patches"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred: (3, 4)\n",
      "x12: [350   0 400]\n",
      "y12: [700   0 600]\n",
      "x22: [402 842   0]\n",
      "y22: [814 782   0]\n",
      "xI1: [177 641 100] yI1: [285 473 200]\n",
      "xI2: [350   0   0] yI2: [700   0   0]\n",
      "truth? [ True  True False]\n",
      "bboxes1_area: [100701      1 120701]\n",
      "bboxes2_area: [119780  62620      1]\n",
      "inter: [ 72384 302080      0]\n",
      "union: [ 148097 -239459  120702]\n",
      "iou: [0.48876074 0.         0.        ]\n"
     ]
    }
   ],
   "source": [
    "pred = np.array([ [150, 200, 200, 500], [0, 0, 0, 0], [100, 200, 300, 400]] )\n",
    "truth = np.array([ [177, 285, 225, 529], [641, 473, 201, 309], [0, 0, 0, 0]] )\n",
    "print(\"pred:\", pred.shape)\n",
    "\n",
    "x11, y11, w1, h1 = pred[:,0], pred[:,1], pred[:,2], pred[:,3]\n",
    "x21, y21, w2, h2 = truth[:,0], truth[:,1], truth[:,2], truth[:,3]\n",
    "\n",
    "x12 = x11 + w1\n",
    "y12 = y11 + h1\n",
    "\n",
    "x22 = x21 + w2\n",
    "y22 = y21 + h2\n",
    "\n",
    "print(\"x12:\", x12)\n",
    "print(\"y12:\", y12)\n",
    "print(\"x22:\", x22)\n",
    "print(\"y22:\", y22)\n",
    "\n",
    "xI1 = np.maximum(x11, x21)\n",
    "yI1 = np.maximum(y11, y21)\n",
    "print(\"xI1:\", xI1, \"yI1:\", yI1)\n",
    "\n",
    "xI2 = np.minimum(x12, x22)\n",
    "yI2 = np.minimum(y12, y22)\n",
    "print(\"xI2:\", xI2, \"yI2:\", yI2)\n",
    "\n",
    "bboxes1_area = (w1 + 1) * (h1 + 1)\n",
    "bboxes2_area = (w2 + 1) * (h2 + 1)\n",
    "truth_exists = w2 * h2 > 0\n",
    "print(\"truth?\", truth_exists)\n",
    "print(\"bboxes1_area:\", bboxes1_area)\n",
    "print(\"bboxes2_area:\", bboxes2_area)\n",
    "\n",
    "inter_area = truth_exists * (xI2 - xI1 + 1) * (yI2 - yI1 + 1)\n",
    "print(\"inter:\", inter_area)\n",
    "\n",
    "union = (bboxes1_area + np.transpose(bboxes2_area)) - inter_area\n",
    "print(\"union:\", union)\n",
    "\n",
    "iou = np.maximum(inter_area / union, 0)\n",
    "print(\"iou:\", iou)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 / 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAloAAAJCCAYAAAAY3mkcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3Xu8XHV97//XRwJIMAKCaCRAyM9ANSgIUWOjVrmkQluooj0g3vWkx6pF8VI9WDGn8vh5aYNarxxBY0XUIihVkKTesD4MmGACCSGIIcQgiqReqlSun/PH+iaM29mZ2XvPd++1k9fz8ZjHnvnOd81675nZs997rTWzIzORJEnS4D1kogNIkiTtqCxakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEqmTHQAgIfv/Yg89LGzJjoGAL+46x72mbrbRMcAzDIcs3TXlixtyQFmGY5ZujNLd23J0pYcACtXrrwzMx/Z1+TMnPDTjNlzsi0WL10/0RG2MUt3ZumuLVnakiPTLMMxS3dm6a4tWdqSIzMTWJF9dhx3HUqSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlfRWtiDgjItZExNqIeH3H+Osi4sYy/t6O8bdFxM0RsT4i/rRGcEmSpLab0mtCRBwO/E/gKcA9wNci4ivAgcDJwBGZeXdE7F/mPx44FZgDPAb494g4NDPvr/Q9SJIktVI/W7QeB1ydmXdl5n3At4HnAa8G3p2ZdwNk5h1l/snA5zLz7sy8BbiZpqRJkiTtVCIztz8h4nHAl4GnAf8NfB1YATyjjD8H+B3wpsz8fkR8CFiemZ8py58PXJGZFw+53YXAQoBp02cdvWjJFYP8vkZt+YYtzJu170THAMwyHLN015YsbckBZhmOWbozS3dtydKWHABnLjhsZWbO7WtyZvY8Aa8EVgJXAR8F3g+sAf4ZCJotVreU8x8CXtSx7PnA87d3+zNmz8m2WLx0/URH2MYs3Zmlu7ZkaUuOTLMMxyzdmaW7tmRpS47MTGBF9tGfMrO/g+Ez8/zMPDoznwn8ArgJ2AxcUtZ5DfAAsB9wG83xW1vNKGOSJEk7lX7fdbj1QPeDaI7P+izwJeDZZfxQYDfgTuAy4NSI2D0iDgFmA9cMProkSVK79XzXYfHFiNgXuBd4TWb+MiIuAC6IiDU070Z8admctjYivgDcANxX5vuOQ0mStNPpq2hl5jO6jN0DvGiY+ecA54wtmiRJ0uTmJ8NLkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRV0lfRiog3RMTaiFgTERdFxEMj4piIuLaMLYmIKR3znxURq8oy364XX5Ikqb16Fq2IOAD4W2BuZh4O7AK8EFgCnFrGbgVeWubvDXwEOCkz5wAvqJRdkiSp1frddTgF2KNstZoK/Ba4JzNvKtcvA04p518IXJKZmwAy844B5pUkSZo0IjN7T4o4AzgH+G9gKfAiYCNwSmauiIgPAMdk5hMi4v3ArsAcYBrwgcz8dJfbXAgsBJg2fdbRi5ZcMZjvaIyWb9jCvFn7TnQMwCzDMUt3bcnSlhxgluGYpTuzdNeWLG3JAXDmgsNWZubcviZn5nZPwD7AN4BH0hSoL9EUracB3wGuAd4FrCrzPwQsB/YE9gN+CBy6vXXMmD0n22Lx0vUTHWEbs3Rnlu7akqUtOTLNMhyzdGeW7tqSpS05MjOBFdmjP209TaG344BbMvPnABFxCfDHmfkZ4BllbAFwaJm/GdiSmb8FfhsRVwFHADf9wS1LkiTtwPo5RmsTMC8ipkZEAMcC6yJif4CI2B34O+BjZf6XgadHxJSImAo8FVg3+OiSJEnt1nOLVmZeHREXA9cC9wE/AM4D3hURf05T1j6amd8o89dFxNeA64AHgE9k5ppa34AkSVJb9bPrkMw8Gzh7yPCby6nb/PcB7xtbNEmSpMnNT4aXJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqpK+iFRFviIi1EbEmIi6KiIdGxPkRsToirouIiyPiYWXumRFxQxn/ekQcXPdbkCRJaqeeRSsiDgD+FpibmYcDuwCnAm/IzCMy84nAJuC1ZZEflLlPBC4G3lsluSRJUsv1u+twCrBHREwBpgI/ycxfA0REAHsACZCZ38zMu8pyy4EZg40sSZI0OURm9p4UcQZwDvDfwNLMPL2MfxI4EbgB+LOOgrV1uQ8BP83Md3W5zYXAQoBp02cdvWjJFWP8VgZj+YYtzJu170THAMwyHLN015YsbckBZhmOWbozS3dtydKWHABnLjhsZWbO7WtyZm73BOwDfAN4JLAr8CXgRR3X7wJ8BHj5kOVeRLNFa/de65gxe062xeKl6yc6wjZm6c4s3bUlS1tyZJplOGbpzizdtSVLW3JkZgIrske32XrqZ9fhccAtmfnzzLwXuAT4446idj/wOeCUrWMRcRxwFnBSZt7dV+OTJEnawfRTtDYB8yJiajke61hgXUQ8FrYdo3UScGO5/CTg4zQl6446sSVJktpvSq8JmXl1RFwMXAvcR/OuwvOAb0TEw4EAVgOvLou8D3gY8K9NB2NTZp5UIbskSVKr9SxaAJl5NnD2kOH5w8w9bqyhJEmSdgR+MrwkSVIlFi1JkqRKLFqSJEmVWLQkSZIq6etgeO34Zs6EW28d/vq95sOZC8YtznaZpbt+shx8MGzcOC5xJEm4RUvFrbdC5vCns8/e/vXjeTLL6LNsr0xLkgbPoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiU9i1ZEHBYRqzpOv46I15frXhcRN0bE2oh4bxnbNSKWRMT1EbEuIt5W+5uQJElqoym9JmTmeuBIgIjYBbgNuDQing2cDByRmXdHxP5lkRcAu2fmEyJiKnBDRFyUmRurfAeSJEktNdJdh8cCP8rMW4FXA+/OzLsBMvOOMieBPSNiCrAHcA/w6wHllSRJmjQiM/ufHHEBcG1mfigiVgFfBp4D/A54U2Z+PyJ2Bf6FppRNBd6Qmed1ua2FwEKAadNnHb1oyRVj/mYGYfmGLcybte9ExwDGN8uiRXD22e3I0otZuusnS6/HebxyjBezdGeW7szSXVuytCUHwJkLDluZmXP7mpyZfZ2A3YA7gUeVy2uAfwYCeApwSzk/H7gQ2BXYH1gPzNrebc+YPSfbYvHS9RMdYZvxzALbv35nvV96mWxZej3O45VjvJilO7N0Z5bu2pKlLTkyM4EV2Wd/GsmuwxNotmb9rFzeDFxS1nkN8ACwH/BC4GuZeW82uxO/C/TX+iRJknYgIylapwEXdVz+EvBsgIg4lAe3eG0CjinjewLzgBsHEVaSJGky6atolcJ0PHBJx/AFwKyIWAN8Dnhp2Zz2YeBhEbEW+D7wycy8brCxJUmS2q/nxzsAZOZvgX2HjN0DvKjL3N/QfMSDJEnSTs1PhpckSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSaqkZ9GKiMMiYlXH6dcR8fqIeERELIuIH5av+wxZ7skRcV9EPL9efEmSpPbqWbQyc31mHpmZRwJHA3cBlwJvBb6embOBr5fLAETELsB7gKVVUkuSJE0CI911eCzwo8y8FTgZWFLGlwB/2THvdcAXgTvGnFDaAV14IcycCQ95SPP1wgsnOpEkqYbIzP4nR1wAXJuZH4qIX2bm3mU8gF9k5t4RcQDwWeDZwAXAVzLz4i63tRBYCDBt+qyjFy25YuzfzQAs37CFebP2negYwPhmWbQIzj67HVl6mexZrr8e/u3f4N57HxzbdVf4i7+AJzyhbpZej/MgTPbHpxazdGeW7szS3hwAZy44bGVmzu1rcmb2dQJ2A+4EHlUu/3LI9b8oX/8VmFfOfwp4fq/bnjF7TrbF4qXrJzrCNuOZBbZ//c56v/QymiwHH9zc30NPBx9cP0uvx3kQJvvjU4tZujNLd2b5Q23JkZkJrMg++9OUERS4E2i2Zv2sXP5ZREzPzNsjYjoP7iacC3yu2cjFfsCJEXFfZn5pBOvSaMycCbfeOsqFE5rHrLv5L4QFnx3lbQ/YJM+yifvpttd+06YBZZIktcZIitZpwEUdly8DXgq8u3z9MkBmHrJ1QkR8imbXoSVrPNx6a7NxZDSC7S+77CY4viUHEk3yLAfN7N6HDzpoMJEkSe3R18HwEbEncDxwScfwu4HjI+KHwHHlsqQezjkHpk79/bGpU5txSdKOpa8tWpn5W2DfIWNbaN6FuL3lXjbqZNIO6vTTm69nnQWbbn2Agw5+COec8+C4JGnHMZJdh5IG5PTTS7GKXWDjKHf3SpJaz3/BI0mSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqqSvohURe0fExRFxY0Ssi4indVz3xojIiNivXI6I+GBE3BwR10XEUbXCS5IktdmUPud9APhaZj4/InYDpgJExIHAAmBTx9wTgNnl9FTgo+WrJEnSTqXnFq2I2At4JnA+QGbek5m/LFefC7wFyI5FTgY+nY3lwN4RMX2wsSVJktqvny1ahwA/Bz4ZEUcAK4EzgOOA2zJzdUR0zj8A+HHH5c1l7PbOSRGxEFgIMG36LM5ddtNov4eBWr5hy+TNMv+FMMrse82Hc5cNMEtFO1SWMTxmo8nS63EerxzjxSzdmaU7s3TXlixtyTFimbndEzAXuA94arn8AeB9wNXAXmVsI7BfOf8V4Okdy38dmLu9dcyYPSfbYvHS9RMdYZsRZ4FRr6vXopP6fqlozFnG8JgN1U+WAa5uTDnGi1m6M0t3ZumuLVnakiMzE1iRPfrT1lM/B8NvBjZn5tXl8sXAUTRbulZHxEZgBnBtRDwauA04sGP5GWVMkiRpp9KzaGXmT4EfR8RhZehY4NrM3D8zZ2bmTJoydlSZexnwkvLuw3nArzLz9q43LkmStAPr912HrwMuLO843AC8fDtzLwdOBG4G7uoxV5IkaYfVV9HKzFU0x2oNd/3MjvMJvGbMySRJkiY5PxlekiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpkin9TIqIjcB/AfcD92Xm3Ij4PHBYmbI38MvMPLLMfyLwceDhwAPAkzPzdwPOLkmS1Gp9Fa3i2Zl559YLmfk/tp6PiH8CflXOTwE+A7w4M1dHxL7AvQPKK0mSNGmMpGh1FREB/BVwTBlaAFyXmasBMnPLWNchSZI0GUVm9p4UcQvwCyCBj2fmeR3XPRNYnJlzy+XXA0cD+wOPBD6Xme/tcpsLgYUA06bPOnrRkivG/t0MwPINW5g3a9+JjgGMIsuiRXD22aNaV69FJ/X9UtGYs4zhMRtNlgGubkw5xotZujNLd2bpri1Z2pID4MwFh63c2nt6ysyeJ+CA8nV/YDXwzI7rPgq8sePym4BbgP2AqcD3gGO3d/szZs/Jtli8dP1ER9hmxFlg1Ovqteikvl8qGnOWMTxmQ/WTZYCrG1OO8WKW7szSnVm6a0uWtuTIzARWZB/9KTP7e9dhZt5Wvt4BXAo8BbYdj/U84PMd0zcDV2XmnZl5F3A5cFRfrU+SJGkH0rNoRcSeETFt63maY7DWlKuPA27MzM0di1wJPCEippYi9ifADYONLUmS1H79HAz/KODS5ph3pgCfzcyvletOBS7qnJyZv4iIxcD3aY7pujwzvzq4yJIkSZNDz6KVmRuAI4a57mXDjH+G5iMeJEmSdlp+MrwkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKmSvopWRGyMiOsjYlVErChjL4iItRHxQETM7Zh7fESsLPNXRsQxtcJLkiS12ZQRzH12Zt7ZcXkN8Dzg40Pm3Qn8RWb+JCIOB64EDhhbTEmSpMlnJEXr92TmOoCIGDr+g46La4E9ImL3zLx7tOuSJEmajPo9RiuBpWVX4MIR3P4pwLWWLEmStDPqd4vW0zPztojYH1gWETdm5lXbWyAi5gDvARYMc/1CYCHAtOmzOHfZTSOIXc/yDVsmb5b5L4RRZt9rPpy7bIBZKtqhsozhMRtNll6P83jlGC9m6c4s3Zmlu7ZkaUuOEcvMEZ2AdwJv6rj8LWDukDkzgJuA+f3c5ozZc7ItFi9dP9ERthlxFhj1unotOqnvl4rGnGUMj9lQ/WQZ4OrGlGO8mKU7s3Rnlu7akqUtOTIzgRXZZ2/queswIvaMiGlbz9NsoVqznfl7A18F3pqZ3x1DB5QkSZrU+jlG61HAf0TEauAa4KuZ+bWIeG5EbAaeBnw1Iq4s818LPBZ4R/k4iFVll6MkSdJOpecxWpm5ATiiy/ilwKVdxt8FvGsg6SRJkiYxPxlekiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpkr6LVkTsEhE/iIivDBn/YET8puPyQRHxzTL3uog4cZCBJUmSJouRbNE6A1jXORARc4F9hsx7O/CFzHwScCrwkTEllCRJmqT6KloRMQP4M+ATHWO7AO8D3jJkegIPL+f3An4y9piSJEmTz5Q+572fplBN6xh7LXBZZt4eEZ1z3wksjYjXAXsCxw0gpyRJ0qTTs2hFxJ8Dd2Tmyoh4Vhl7DPAC4FldFjkN+FRm/lNEPA34l4g4PDMfGHK7C4GFANOmz+LcZTeN6RsZlOUbtkzeLPNfCKPMvtd8OHfZALNUtENlGcNjNposvR7n8coxXszSnVm6M0t3bcnSlhwjlpnbPQH/P7AZ2Aj8FLgL+EU5v7GcHgBuLvPXAgd2LL8B2H9765gxe062xeKl6yc6wjYjzgKjXlevRSf1/VLRmLOM4TEbqp8sA1zdmHKMF7N0Z5buzNJdW7K0JUdmJrAie/Snraeex2hl5tsyc0ZmzqQ5uP0bmblPZj46M2eW8bsy87FlkU3AsQAR8TjgocDPx9gHJUmSJp1+j9EaiTcC/zci3kBzYPzLSvuTJEnaqYyoaGXmt4BvdRl/WMf5G4D5Yw0mSZI02fnJ8JIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZX0LFoR8dCIuCYiVkfE2ohYVMaPjYhrI2JVRPxHRDx2yHKnRERGxNxa4SVJktqsny1adwPHZOYRwJHAcyJiHvBR4PTMPBL4LPD2rQtExDTgDODqwUeWJEmaHHoWrWz8plzctZyynB5exvcCftKx2D8A7wF+N7iokiRJk0tfx2hFxC4RsQq4A1iWmVcDrwIuj4jNwIuBd5e5RwEHZuZXK2WWJEmaFKb0Mykz7weOjIi9gUsj4nDgDcCJmXl1RLwZWBwRC4HFwMt63WaZuxBg2vRZnLvsplF+C4O1fMOWyZtl/gthlNn3mg/nLhtglop2qCxjeMxGk6XX4zxeOcaLWbozS3dm6a4tWdqSY8Qyc0Qn4B3Am4EfdYwdBNxAswvxTmBjOf2OZpfi3O3d5ozZc7ItFi9dP9ERthlxlm17ekeu16KT+n6paMxZxvCYDdVPlgGubkw5xotZujNLd2bpri1Z2pIjMxNYkX32pn7edfjIsiWLiNgDOB5YB+wVEYeWaccD6zLzV5m5X2bOzMyZwHLgpMxcMZBWKEmSNIn0s+twOrAkInahOabrC5n5lYj4n8AXI+IB4BfAKyrmlCRJmnR6Fq3MvA54UpfxS4FLeyz7rFEnkyRJmuT8ZHhJkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKehatiHhoRFwTEasjYm1ELCrjF0bE+ohYExEXRMSuZTwi4oMRcXNEXBcRR9X+JiRJktqony1adwPHZOYRwJHAcyJiHnAh8EfAE4A9gFeV+ScAs8tpIfDRQYeWJEmaDHoWrWz8plzctZwyMy8v1yVwDTCjzDkZ+HS5ajmwd0RMrxFekiSpzfo6RisidomIVcAdwLLMvLrjul2BFwNfK0MHAD/uWHxzGZMkSdqpTOlnUmbeDxwZEXsDl0bE4Zm5plz9EeCqzPzOSFYcEQtpdi0ybfoszl1200gWr2b5hi2TN8v8F8Ios+81H85dNsAsFe1QWcbwmI0mS6/HebxyjBezdGeW7szSXVuytCXHiGXmiE7AO4A3lfNnA18CHtJx/ceB0zourwemb+82Z8yek22xeOn6iY6wzYizbNvTO3K9Fp3U90tFY84yhsdsqH6yDHB1Y8oxXszSnVm6M0t3bcnSlhyZmcCK7LM39fOuw0eWLVlExB7A8cCNEfEq4E9LqXqgY5HLgJeUdx/OA36VmbcPpBVKkiRNIv3sOpwOLImIXWiO6fpCZn4lIu4DbgW+FxEAl2Tm/wEuB04EbgbuAl5eJbkkSVLL9SxamXkd8KQu412XLZvUXjP2aJIkSZObnwwvSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWrZ3dhRfCzJncz0Ng5szmsiRJGoie/1RaO7ALL4SFC+Guu5rGfeutzWWA00+fyGSSJO0Q3KK1MzvrLLjrrt8fu+uuZlySJI2ZW7R2Zps2dR1+4NZN7BK/P7bXfDhzwThk6sOOlSUhes8aVJaDDx7MuiRJ/XGL1s7soIO6Dj/k4IPI5PdOZ5/NH4xN1GmHykKMa5aNG8f3KSZJOzuL1s7snHNg6tTfH5s6tRmXJEljZtHamZ1+Opx3XrM/KaL5et55HggvSdKAeIzWzu700y1WkiRV4hYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVEnPohURB0bENyPihohYGxFnlPF3RsRtEbGqnE7sWOaJEfG9Mv/6iHhozW9CkiSpjfr5HK37gDdm5rURMQ1YGRHLynXnZuY/dk6OiCnAZ4AXZ+bqiNgXuHegqSVJkiaBnkUrM28Hbi/n/ysi1gEHbGeRBcB1mbm6LLNlEEElSZImmxEdoxURM4EnAVeXoddGxHURcUFE7FPGDgUyIq6MiGsj4i0DSytJkjSJRGb2NzHiYcC3gXMy85KIeBRwJ5DAPwDTM/MVEfEm4DXAk4G7gK8Db8/Mrw+5vYXAQoBp02cdvWjJFQP6lsZm+YYtzJu170THAEaRZdEiOPvsdmSpaIfKMsDHrC33S1tygFmGY5buzNJdW7K0JQfAmQsOW5mZc/uanJk9T8CuwJXAmcNcPxNYU86fCizpuO7vgTdv7/ZnzJ6TbbF46fqJjrDNiLNAnSA5ye+XisacZYCPWVvul7bkyDTLcMzSnVm6a0uWtuTIzARWZB/9KTP7etdhAOcD6zJzccf49I5pzwXWlPNXAk+IiKnlwPg/AW7oq/VJkiTtQPp51+F84MXA9RGxqoz9b+C0iDiSZtfhRuCvATJqj6sPAAAUJklEQVTzFxGxGPh+ue7yzPzqoINLkiS1XT/vOvwPILpcdfl2lvkMzUc8SJIk7bT8ZHhJkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKehatiLggIu6IiDUdY0dExPci4vqI+LeIeHgZPz4iVpbxlRFxTM3wGuLggyGizmnRonq3vTNnOfjgiX7WSJIqmtLHnE8BHwI+3TH2CeBNmfntiHgF8Gbg74E7gb/IzJ9ExOHAlcABg42sYW3cWO+2l90Ex19Y7/ZHwiySpEmi5xatzLwK+M8hw4cCV5Xzy4BTytwfZOZPyvhaYI+I2H1AWSVJkiaV0R6jtRY4uZx/AXBglzmnANdm5t2jXIckSdKkFpnZe1LETOArmXl4ufxHwAeBfYHLgL/NzH075s8p4wsy80fD3OZCYCHAtOmzjl605IoxfSODsnzDFubN2rf3xHFglu7M0l1bsrQlB5hlOGbpzizdtSVLW3IAnLngsJWZObevyZnZ8wTMBNYMc92hwDUdl2cANwHz+7ntzGTG7DnZFouXrp/oCNuYpTuzdNeWLG3JkWmW4ZilO7N015YsbcmRmQmsyD47zqh2HUbE/uXrQ4C3Ax8rl/cGvgq8NTO/O5rbliRJ2lH08/EOFwHfAw6LiM0R8UrgtIi4CbgR+AnwyTL9tcBjgXdExKpy2r9SdkmSpFbr+fEOmXnaMFd9oMvcdwHvGmsoSZKkHYGfDC9JklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklRJz6IVERdExB0RsaZj7H0RcWNEXBcRl0bE3mV814hYEhHXR8S6iHhbzfCSJElt1s8WrU8Bzxkytgw4PDOfCNwEbC1ULwB2z8wnAEcDfx0RMweSVJIkaZLpWbQy8yrgP4eMLc3M+8rF5cCMrVcBe0bEFGAP4B7g14OLK0mSNHkM4hitVwBXlPMXA78Fbgc2Af+Ymf853IKSJEk7ssjM3pOa3X9fyczDh4yfBcwFnpeZGRHzgb8BXgbsA3wHOCEzN3S5zYXAQoBp02cdvWjJFUOnTIjlG7Ywb9a+Ex0DMMtwzNJdW7K0JQeYZThm6c4s3bUlS1tyAJy54LCVmTm3r8mZ2fMEzATWDBl7GfA9YGrH2IeBF3dcvgD4q163P2P2nGyLxUvXT3SEbczSnVm6a0uWtuTINMtwzNKdWbprS5a25MjMBFZkH/0pM0e36zAingO8BTgpM+/quGoTcEyZsycwD7hxNOuQJEma7Pr5eIeLaLZcHRYRmyPilcCHgGnAsohYFREfK9M/DDwsItYC3wc+mZnXVcouSZLUalN6TcjM07oMnz/M3N/QfMSDJEnSTs9PhpckSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSapkTEUrIvaOiIsj4saIWBcRT+u47o0RkRGx39hjSpIkTT5Txrj8B4CvZebzI2I3YCpARBwILAA2jfH2JUmSJq1Rb9GKiL2AZwLnA2TmPZn5y3L1ucBbgBxzQkmSpElqLLsODwF+DnwyIn4QEZ+IiD0j4mTgtsxcPZiIkiRJk1Nkjm6jU0TMBZYD8zPz6oj4AHAPzVauBZn5q4jYCMzNzDu7LL8QWAgwbfqsoxctuWKU38JgLd+whXmz9p3oGIBZhmOW7tqSpS05wCzDMUt3ZumuLVnakgPgzAWHrczMuX1NzsxRnYBHAxs7Lj8D+DpwB7CxnO6jOU7r0du7rRmz52RbLF66fqIjbGOW7szSXVuytCVHplmGY5buzNJdW7K0JUdmJrAi++xLo951mJk/BX4cEYeVoWOBazNz/8ycmZkzgc3AUWWuJEnSTmWs7zp8HXBhecfhBuDlY48kSZK0YxhT0crMVcCw+yjLVi1JkqSdkp8ML0mSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFVi0ZIkSarEoiVJklSJRUuSJKkSi5YkSVIlFi1JkqRKLFqSJEmVWLQkSZIqsWhJkiRVYtGSJEmqxKIlSZJUiUVLkiSpEouWJElSJRYtSZKkSixakiRJlVi0JEmSKrFoSZIkVWLRkiRJqsSiJUmSVEm1ohURz4mI9RFxc0S8tdZ6JEmS2qpK0YqIXYAPAycAjwdOi4jH11iXJElSW9XaovUU4ObM3JCZ9wCfA06utC5JkqRWqlW0DgB+3HF5cxmTJEnaaURmDv5GI54PPCczX1Uuvxh4ama+tmPOQmBhuXg4sGbgQUZnP+DOiQ5RmKU7s3TXlixtyQFmGY5ZujNLd23J0pYcAAdn5iP7mTilUoDbgAM7Ls8oY9tk5nnAeQARsSIz51bKMiJm6c4s3ZmlvTnALMMxS3dm6a4tWdqSY6Rq7Tr8PjA7Ig6JiN2AU4HLKq1LkiSplaps0crM+yLitcCVwC7ABZm5tsa6JEmS2qrWrkMy83Lg8j6nn1crxyiYpTuzdGeWP9SWHGCW4ZilO7N015YsbckxIlUOhpckSZL/gkeSJKmaCS9aE/2veiJi74i4OCJujIh1EfG0juveGBEZEftVWvcFEXFHRKzpGHtfyXJdRFwaEXuX8V0jYklEXF9yvm0cshwREd8r6/y3iHh4GT8+IlaW8ZURccwAcxwYEd+MiBsiYm1EnFHG3xkRt0XEqnI6sWOZJ5aca0umhw4oy0Mj4pqIWF1ue1EZv7A8Z9eU+23XMh4R8cHyXL4uIo4aRI4eWY6NiGvLffIfEfHYIcudUp7DA3+nTkTsEhE/iIivDBn/YET8puPyQeUx/UG5X078w1sbU46N5XFfFRErytgLyv30QOf3Xvm52y3H5zuesxsjYlXH/CrP23Lbfb+uVX7eHtbx/a+KiF9HxOsj4hERsSwifli+7jNkuSdHxH3RfFRQ1SzluteV+2ptRLy3jNV+zX1DWd+aiLio/IyfX37GryuP38PK3DOjeU28LiK+HhEHj0OWY8pry5pyP0zpmP+sch+ujYhvDzjLGWWda7c+PmX8Dx6jMv628txdHxF/OsgsA5OZE3aiOVD+R8AsYDdgNfD4cc6wBHhVOb8bsHc5fyDNwfy3AvtVWvczgaOANR1jC4Ap5fx7gPeU8y8EPlfOTwU2AjMrZ/k+8Cfl/CuAfyjnnwQ8ppw/HLhtgDmmA0eV89OAm2j+jdM7gTd1mT8FuA44olzeF9hlQFkCeFg5vytwNTAPOLFcF8BFwKvLnBOBK8r4PODqAd4vw2W5CXhcGf8b4FMdy0wDrgKWA3MrPH/PBD4LfKVjbC7wL8BvOsbO67iPHg9sHHCOjUN/RoHHAYcB3+r83is/d/8gx5Dr/wl4R+3nbbm9vl/Xaj5vh2TaBfgpcDDwXuCtZfytlNe5jnnfoDnG9/njkOXZwL8Du5fr9i9fq73m0nyA9y3AHuXyF4CXAQ/vmLO44z56NjC1nH818PkB3hfdsryC5kPHDy1j/wd4ZTm/N3ADcFDn/TWgLFs/U3Nq+Rn5d+Cx23mMHk/TG3YHDqHpEwP7ORrUaaK3aE3ov+qJiL1oCsb5AJl5T2b+slx9LvAWoNpBbJl5FfCfQ8aWZuZ95eJyms8go+TYs/xVsQdwD/DrmlmAQ2l+UQMsA04pc3+QmT8p42uBPSJi9wHluD0zry3n/wtYx/b/q8AC4LrMXF2W2ZKZ9w8oS2bm1i0zu5ZTZubl5boEruHBx+hk4NPlquXA3hExvWaWcnp4Gd8L+EnHYv9AU9Z/N4gMnSJiBvBnwCc6xnYB3kfzc/N78beTsYrMXJeZ67uMV3vubk9EBPBXNMUcKj5vR/G6Vu15O8SxwI8y89ayziVlfAnwlx3zXgd8EbijQoZuWV4NvDsz7wbIzK3rrfqaS1Mk9ii3PxX4SWb+GrY9X/YoGcjMb2bmXWW5zt8LtbL8FrgnM28q1297/acpoJdk5qaSbZCP0+Noiv5d5ffgt4HnMfxjdDJNGb47M28BbqbpFa0y0UVrov9VzyHAz4FPRrNb4xMRsWdEnEzzl+7qcczSzSto/tIEuJjmyX87sAn4x8wcWowGbS0PFt8X8PsfQrvVKcC1W38ABikiZtJsgbi6DL22bDq/oGNXw6FARsSVZTP30F/yY82wS9ndcwewLDOv7rhuV+DFwNfKUNXn8zBZXgVcHhGbS5Z3l7lHAQdm5lcHtf4h3k/zC/uBjrHXApdl5u1D5r4TeFHJeDnNL9JBSmBpNLsCF/ac/aBBP3e3l+MZwM8y84flcs3n7Uhf18brdfhUHiyaj+p4nvwUeBRARBwAPBf4aIX1D5flUOAZEXF1RHw7Ip5cxqu95mbmbcA/ltu9HfhVZi4FiIhP0twnfwT8c5fFX8mDvxeqZKHZqjUlHtzt/nwefP0/FNgnIr5VnusvGVQWmq1Zz4iIfSNiKs3W1gMZ/jGa6A7Rl4kuWhNtCs3uso9m5pNofqjeCfxv4B0TmIuIOAu4D7iwDD0FuB94DM0L6RsjYlblGK8A/iYiVtLshrpnSMY5NFtM/nrQKy7HJnwReH35K++jwP8HHEnzYvBPZeoU4OnA6eXrcyPi2EHlyMz7M/NImr8gnxIRh3dc/RHgqsz8zqDWN4osbwBOzMwZwCeBxRHxEJrdDm+skSMi/hy4IzNXdow9hqaMd/vFcBrNLs0ZNC+c/1IyDsrTM/Mo4ATgNRHxzF4LVHrubi/HaTz4ix3qPm9b97oWzQdXnwT869DrypbhrVvY3g/8XWY+MHRexSxTgEfQ7DZ9M/CFskWp2mtu+UPx5HK7j6HZcvYigMx8eRlbB/yPIcu9iGb3/PsGkWO4LDTPy1OBcyPiGuC/aO4LaO6vo2m2aP8p8PcRceggsmTmOpqfy6U0f8CuKusd7jGaFCa6aPX8Vz2VbQY2d2yluJjmBeoQYHVEbCyZro2IR49XqIh4GfDnwOnlRQiazbVfy8x7y2bT79L8wFWTmTdm5oLMPJrml8SPOjLOAC4FXpKZPxruNkajbCn6InBhZl5SsvysFI0HgP/Lg5uHN9OUnTvLpvXLaR7DgSq7Xr4JPKdkPBt4JM1xSluNy/O5I8sJNMf4bH3+fh74Y5pSfDjwrfIcngdcFoM7IH4+cFK57c8Bx9Bs/XwscHMZnxoRN5f5r6T5C5nM/B7wUJr/WTYQ5S/yrbsTLqXHroNaz93hcpTdMc+jeXy2qvm8Henr2ng8b0+g2Xr4s3L5Z1t3T5avW3cFzQU+VzI+H/hIRPzl0BsbcJbNNLvCMjOvodlKux91X3OPA27JzJ9n5r3AJTQ/u0DzRxXNz9bW3XVExHHAWcBJA96D0DVLZn4vM5+RmU+hOYRk627EzcCVmfnbzLyzXHfEoMJk5vmZeXRmPhP4RVnvcI/RRHeIvkx00ZrQf9WTmT8FfhwRh5WhY2l+APfPzJmZOZPmAT6qzK0uIp5Ds0vmpI598tBs1j2mzNmT5pfnjZWz7F++PgR4O/Cxcnlv4Ks0B2p+d8DrDJpjS9Zl5uKO8c5jRp7Lg/+E/ErgCRExtfxC+xOaAzUHkeWR8eC7PvcAjgdujIhX0fwld9qQv7wvA14SjXk0uwOG7kYbZJZ1wF4df00eT3O//Soz9+t4Di+neT6tGESWzHxbZs4ot30q8I3M3CczH92xzrsyc+s7IDfR/GwREY+jKVo/H0SWskts2tbzNMc+DfsP6ms9d3vkOA64MTM3dyxS7Xk7ite1as/bDkO36F0GvLScfynw5ZL9kI6MFwN/k5lfqpzlSzQHW1N+lnaj+cfFNV9zNwHzyuMfNI/RuijvGi5jJ21dX0Q8Cfg4zc/xoI9dGy7L1tf/3YG/o7z+0zxWT4+IKWX33lNpXosGomO9B9H8gfJZhn+MLgNOjYjdI+IQYDbNcbPtkhN8ND7NroSbaLaWnDUB6z8SWEHzDqAvAfsMuX4j9d51eBHNbrB7aV74XklzMN+PaTaZrgI+VuY+jGZT91qaF+Q3j0OWM8pjcxPNsT9bP+D27TS7I1Z1nAbyzhOa3ShZHo+tt30izTvZri/jlwHTO5Z5Ublf1gDvHeB98kTgB2Wda3jwHWP3lefr1nxbxwP4cLnuegb4Tr/tZHluWddqmnfYzeqy7LcGmWXIbT+Ljncddox3vuvw8TRbA1aX+2vBANc/q9zu6vIcOKvjftkM3A38jOYv8GrP3eFylOs+BfyvLstUed6W2+77da3m87bc/p7AFmCvjrF9ga8DP6R5N9kjuiz3KQb8rsNhsuwGfKY8DtcCx5Tx2q+5i2iK1Bqa17fdy8/J9WXsQsq7EMt99LOO5+xl45DlfTQFaj3NIRyd899c7pM1Q68bQJbvlNteDRy7vceoXHdWee6uB04YZJZBnfxkeEmSpEometehJEnSDsuiJUmSVIlFS5IkqRKLliRJUiUWLUmSpEosWpIkSZVYtCRJkiqxaEmSJFXy/wB9xZ2266QaDgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "coords = np.arange(0, 1024, 64)\n",
    "\n",
    "fig,ax = plt.subplots(1, figsize=(10,10))\n",
    "\n",
    "rect_1 = patches.Rectangle((150,200),200,500,linewidth=1,edgecolor='r',facecolor='none')\n",
    "plt.plot(177, 285, marker=\"o\", color=\"r\")\n",
    "rect_2 = patches.Rectangle((177,285),225,529,linewidth=1,edgecolor='b',facecolor='none')\n",
    "plt.plot(350, 700, marker=\"o\", color=\"b\")\n",
    "ax.add_patch(rect_1)\n",
    "ax.add_patch(rect_2)\n",
    "plt.xticks(coords)\n",
    "plt.yticks(coords)\n",
    "for item in coords:\n",
    "    plt.axvline(item, linewidth=0.5)\n",
    "    plt.axhline(item, linewidth=0.5)\n",
    "plt.xlim(0,1024)\n",
    "plt.ylim(0,1024)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pred: (?, 4)\n",
      "truth: (?, 4)\n",
      "x11: (?, 1)\n",
      "x21: (?, 1)\n",
      "x12: (?, 1)\n",
      "y12: (?, 1)\n",
      "union: (?, ?)\n",
      "iou: ()\n"
     ]
    }
   ],
   "source": [
    "pred = tf.placeholder(shape=(None, 16, 16, 4), dtype=tf.int32)\n",
    "truth = tf.placeholder(shape=(None, 16, 16, 4), dtype=tf.int32)\n",
    "\n",
    "pred = tf.reshape(pred, (-1, 4))\n",
    "truth = tf.reshape(truth, (-1, 4))\n",
    "\n",
    "print(\"pred:\", pred.shape)\n",
    "print(\"truth:\", truth.shape)\n",
    "\n",
    "x11, y11, w1, h1 = tf.split(pred, 4, axis=1)\n",
    "x21, y21, w2, h2 = tf.split(truth, 4, axis=1)\n",
    "\n",
    "print(\"x11:\", x11.shape)\n",
    "print(\"x21:\", x21.shape)\n",
    "\n",
    "x12 = x11 + w1\n",
    "y12 = y11 + h1\n",
    "\n",
    "x22 = x21 + w2\n",
    "y22 = y21 + h2\n",
    "\n",
    "print(\"x12:\", x12.shape)\n",
    "print(\"y12:\", y12.shape)\n",
    "\n",
    "xI1 = tf.maximum(x11, tf.transpose(x21))\n",
    "yI1 = tf.maximum(y11, tf.transpose(y21))\n",
    "\n",
    "xI2 = tf.minimum(x12, tf.transpose(x22))\n",
    "yI2 = tf.minimum(y12, tf.transpose(y22))\n",
    "\n",
    "inter_area = (xI2 - xI1 + 1) * (yI2 - yI1 + 1)\n",
    "\n",
    "bboxes1_area = (w1 + 1) * (h1 + 1)\n",
    "bboxes2_area = (w2 + 1) * (h2 + 1)\n",
    "\n",
    "union = (bboxes1_area + tf.transpose(bboxes2_area)) - inter_area\n",
    "\n",
    "print(\"union:\", union.shape)\n",
    "\n",
    "iou = tf.reduce_mean(tf.maximum(inter_area / union, 0))\n",
    "print(\"iou:\", iou.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hE3jDmgudDDP"
   },
   "outputs": [],
   "source": [
    "# enter your Kaggle credentionals here\n",
    "os.environ['KAGGLE_USERNAME']=\"skooch\"\n",
    "os.environ['KAGGLE_KEY']=\"42f8a02ee92cc773d1dbe66565673ad3\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sSWY-U2TcxSn"
   },
   "source": [
    "# Load pneumonia locations\n",
    "\n",
    "Table contains [filename : pneumonia location] pairs per row. \n",
    "* If a filename contains multiple pneumonia, the table contains multiple rows with the same filename but different pneumonia locations. \n",
    "* If a filename contains no pneumonia it contains a single row with an empty pneumonia location.\n",
    "\n",
    "The code below loads the table and transforms it into a dictionary. \n",
    "* The dictionary uses the filename as key and a list of pneumonia locations in that filename as value. \n",
    "* If a filename is not present in the dictionary it means that it contains no pneumonia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "m_0ZGQyLdQS8",
    "outputId": "4848c0ce-4d75-4781-d01f-91cbd7626d77"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train dir: ./stage_1_train_images\n"
     ]
    }
   ],
   "source": [
    "ROOT_DIR = \"./\"\n",
    "\n",
    "train_dicom_dir = os.path.join(ROOT_DIR, 'stage_1_train_images')\n",
    "test_dicom_dir = os.path.join(ROOT_DIR, 'stage_1_test_images')\n",
    "print(\"Train dir:\", train_dicom_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hopsRmICcxSs"
   },
   "outputs": [],
   "source": [
    "with open('yolo_labels.p', 'rb') as handle:\n",
    "    pneumonia_locations = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = pneumonia_locations[\"fffb2395-8edd-4954-8a89-ffe2fd329be3\"]\n",
    "boxes = foo[:,:,1:]\n",
    "boxes[0,0,:] = 5, 10, 20, 20\n",
    "mask = boxes[:,:,0] > 0\n",
    "boxes[mask, 0] = 100 - boxes[mask,0]\n",
    "flipped = np.flip(boxes, axis=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0.,  0.,  0.,  0.],\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.]],\n",
       "\n",
       "       [[ 0.,  0.,  0.,  0.],\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.]],\n",
       "\n",
       "       [[ 0.,  0.,  0.,  0.],\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.]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[ 0.,  0.,  0.,  0.],\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.]],\n",
       "\n",
       "       [[ 0.,  0.,  0.,  0.],\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.]],\n",
       "\n",
       "       [[95., 10., 20., 20.],\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": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flipped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  5., 177., 641.])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "boxes[mask, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UoB6GBhIcxS6"
   },
   "source": [
    "# Load filenames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 51
    },
    "colab_type": "code",
    "id": "b_iB-IftcxTE",
    "outputId": "89a05e05-f2d9-45fc-d1ef-1a0cc289f98d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n train samples 23116\n",
      "n valid samples 2568\n"
     ]
    }
   ],
   "source": [
    "random.seed(72)\n",
    "\n",
    "# load and shuffle filenames\n",
    "folder = './stage_1_train_images'\n",
    "filenames = os.listdir(folder)\n",
    "random.shuffle(filenames)\n",
    "# split into train and validation filenames\n",
    "n_valid_samples = int(len(filenames) * 0.1)\n",
    "train_filenames = filenames[n_valid_samples:]\n",
    "valid_filenames = filenames[:n_valid_samples]\n",
    "print('n train samples', len(train_filenames))\n",
    "print('n valid samples', len(valid_filenames))\n",
    "n_train_samples = len(filenames) - n_valid_samples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "lorV7ZmDcxTa"
   },
   "source": [
    " # Data generator\n",
    "\n",
    "The dataset is too large to fit into memory, so we need to create a generator that loads data on the fly.\n",
    "\n",
    "* The generator takes in some filenames, batch_size and other parameters.\n",
    "\n",
    "* The generator outputs a random batch of numpy images and numpy masks.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "dFbLdFxVehhB"
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 12\n",
    "IMAGE_SIZE = 512\n",
    "CHECKPOINT_PATH = \"yolo1_512.h5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 1],\n",
       "       [0, 1, 0],\n",
       "       [1, 0, 0]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = np.array([ [1, 0, 0], [0, 1, 0], [0, 0, 1]])\n",
    "np.fliplr(foo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TueY1bVlcxTg"
   },
   "outputs": [],
   "source": [
    "class generator(keras.utils.Sequence):\n",
    "    \n",
    "    def __init__(self, folder, filenames, pneumonia_locations=None, batch_size=BATCH_SIZE, image_size=IMAGE_SIZE, shuffle=True, augment=False, predict=False):\n",
    "        self.folder = folder\n",
    "        self.filenames = filenames\n",
    "        self.pneumonia_locations = pneumonia_locations\n",
    "        self.batch_size = batch_size\n",
    "        self.image_size = image_size\n",
    "        self.shuffle = shuffle\n",
    "        self.augment = augment\n",
    "        self.predict = predict\n",
    "        self.on_epoch_end()\n",
    "        \n",
    "    def __load__(self, filename):\n",
    "        # load dicom file as numpy array\n",
    "        img = pydicom.dcmread(os.path.join(self.folder, filename)).pixel_array\n",
    "        # get filename without extension\n",
    "        filename = filename.split('.')[0]\n",
    "        label = pneumonia_locations[filename].copy()\n",
    "        \n",
    "        # remove the confidence and bboxes\n",
    "        confs = label[:,:,0]\n",
    "        boxes = label[:,:,1:]\n",
    "        \n",
    "        ## data augmentation may be complicated, let's do that later\n",
    "        # if augment then horizontal flip half the time\n",
    "        if self.augment and random.random() > 0.5:\n",
    "            img = np.fliplr(img)\n",
    "            \n",
    "            # update our x coords\n",
    "            mask = boxes[:,:,0] > 0\n",
    "            boxes[mask, 0] = 1024 - boxes[mask,0]\n",
    "            \n",
    "            # flip our boxes lr\n",
    "            boxes = np.flip(boxes, axis=0)         \n",
    "            \n",
    "            # flip the confs lr\n",
    "            confs = np.flip(confs, axis=0)\n",
    "            \n",
    "        # resize both image and mask\n",
    "        img = resize(img, (self.image_size, self.image_size), mode='reflect')\n",
    "\n",
    "        # add trailing channel dimension\n",
    "        img = np.expand_dims(img, -1)\n",
    "        return img, confs, boxes\n",
    "    \n",
    "    def __loadpredict__(self, filename):\n",
    "        # load dicom file as numpy array\n",
    "        img = pydicom.dcmread(os.path.join(self.folder, filename)).pixel_array\n",
    "        # resize image\n",
    "        img = resize(img, (self.image_size, self.image_size), mode='reflect')\n",
    "        # add trailing channel dimension\n",
    "        img = np.expand_dims(img, -1)\n",
    "        return img\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        # select batch\n",
    "        filenames = self.filenames[index*self.batch_size:(index+1)*self.batch_size]\n",
    "        # predict mode: return images and filenames\n",
    "        if self.predict:\n",
    "            # load files\n",
    "            imgs = [self.__loadpredict__(filename) for filename in filenames]\n",
    "            # create numpy batch\n",
    "            imgs = np.array(imgs)\n",
    "            return imgs, filenames\n",
    "        # train mode: return images and masks\n",
    "        else:\n",
    "            # load files\n",
    "            items = [self.__load__(filename) for filename in filenames]\n",
    "            \n",
    "            # unzip images and masks\n",
    "            imgs, confs, bboxes = zip(*items)\n",
    "            \n",
    "            # create numpy batch\n",
    "            imgs = np.array(imgs)\n",
    "            confs = np.expand_dims(np.array(confs), -1)\n",
    "            bboxes = np.array(bboxes)\n",
    "            \n",
    "            labels = {\"confidence_output\": confs, \"bboxes_output\": bboxes}\n",
    "            return imgs, labels\n",
    "        \n",
    "    def on_epoch_end(self):\n",
    "        if self.shuffle:\n",
    "            random.shuffle(self.filenames)\n",
    "        \n",
    "    def __len__(self):\n",
    "        if self.predict:\n",
    "            # return everything\n",
    "            return int(np.ceil(len(self.filenames) / self.batch_size))\n",
    "        else:\n",
    "            # return full batches only\n",
    "            return int(len(self.filenames) / self.batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3_GgDL7ncxT3"
   },
   "source": [
    "# Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bqobZQZQcxUE"
   },
   "outputs": [],
   "source": [
    "def create_downsample(channels, inputs):\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(inputs)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    x = keras.layers.Conv2D(channels, 1, padding='same', use_bias=False)(x)\n",
    "    x = keras.layers.MaxPool2D(2)(x)\n",
    "#     x = keras.layers.Conv2D(channels, (3,3), strides=(2,2), padding='same', use_bias=False)(x)\n",
    "    return x\n",
    "\n",
    "def create_resblock(channels, inputs):\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(inputs)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    x_1 = keras.layers.Conv2D(channels, 3, padding='same', use_bias=False)(x)\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x_1)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    x_2 = keras.layers.Conv2D(channels, 3, padding='same', use_bias=False)(x)\n",
    "    x = keras.layers.add([x_2, inputs])\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    x = keras.layers.Conv2D(channels, 3, padding='same', use_bias=False)(x)\n",
    "    x = keras.layers.add([x, x_1])\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    x = keras.layers.Conv2D(channels, 3, padding='same', use_bias=False)(x)\n",
    "    x = keras.layers.add([x, x_2])\n",
    "    return x\n",
    "\n",
    "def create_network(input_size, channels, n_blocks=2, depth=4):\n",
    "    # input\n",
    "    inputs = keras.Input(shape=(input_size, input_size, 1))\n",
    "    x = keras.layers.Conv2D(channels, 3, padding='same', use_bias=False)(inputs)\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    \n",
    "    x = keras.layers.Conv2D(channels, 3, strides=(2,2), padding='same', use_bias=False)(x)\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    \n",
    "    x = keras.layers.Conv2D(channels, 3, padding='same', use_bias=False)(x)\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    \n",
    "    x = keras.layers.Conv2D(channels*2, 1, padding='same', use_bias=False)(x)\n",
    "    \n",
    "    # residual blocks\n",
    "    for d in range(depth):\n",
    "        channels = channels * 2\n",
    "        x = create_downsample(channels, x)\n",
    "            \n",
    "        for b in range(n_blocks):\n",
    "            x = create_resblock(channels, x)\n",
    "        \n",
    "    # output\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "    x = keras.layers.LeakyReLU(0)(x)\n",
    "    \n",
    "    x_2 = keras.layers.Conv2D(512, (3,3), padding='same', dilation_rate=(2,2), activation=None, name=\"dilated_conv_1\")(x)\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x_2)\n",
    "    x = keras.layers.LeakyReLU(0.01)(x)\n",
    "    \n",
    "    x = keras.layers.Conv2D(512, (3,3), padding='same', dilation_rate=(2,2), activation=None, name=\"dilated_conv_2\")(x)\n",
    "    x = keras.layers.BatchNormalization(momentum=0.9)(x)\n",
    "    x = keras.layers.LeakyReLU(0.01)(x)\n",
    "    \n",
    "    c = keras.layers.Conv2D(768, (1,1), padding='same', activation=None, name=\"fc_1_c\")(x)\n",
    "    c = keras.layers.BatchNormalization(momentum=0.9)(c)\n",
    "    c = keras.layers.LeakyReLU(0.01)(c)\n",
    "    c = keras.layers.Dropout(0.25)(c)\n",
    "    \n",
    "    c = keras.layers.Conv2D(768, (1,1), padding='same', activation=None, name=\"fc_2_c\", kernel_regularizer=keras.regularizers.l2(l=0.01))(c)\n",
    "    c = keras.layers.BatchNormalization(momentum=0.9)(c)\n",
    "    c = keras.layers.LeakyReLU(0.01)(c)\n",
    "    \n",
    "    b = keras.layers.Conv2D(768, (1,1), padding='same', activation=None, name=\"fc_1_b\")(x)\n",
    "    b = keras.layers.BatchNormalization(momentum=0.9)(b)\n",
    "    b = keras.layers.LeakyReLU(0.01)(b)\n",
    "    b = keras.layers.Dropout(0.25)(b)\n",
    "    \n",
    "    b = keras.layers.Conv2D(768, (1,1), padding='same', activation=None, name=\"fc_2_b\", kernel_regularizer=keras.regularizers.l2(l=0.01))(b)\n",
    "    b = keras.layers.BatchNormalization(momentum=0.9)(b)\n",
    "    b = keras.layers.LeakyReLU(0.01)(b)\n",
    "    \n",
    "    confidence = keras.layers.Conv2D(1, (1,1), padding='same', activation=\"sigmoid\", name=\"confidence_output\")(c)\n",
    "    boxes = keras.layers.Conv2D(4, (1,1), padding='same', activation=\"linear\", name=\"bboxes_output\")(b)\n",
    "    \n",
    "    model = keras.Model(inputs=inputs, outputs=[confidence, boxes])\n",
    "    \n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AvdSzGI4cxUL"
   },
   "source": [
    "# Train network\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 3451
    },
    "colab_type": "code",
    "id": "DCgIz8CwcxUO",
    "outputId": "ce38cdfb-1806-488d-838f-d180e198a099"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'create_network' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-0d0272a6df3e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     71\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m \u001b[0;31m# create network and compiler\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 73\u001b[0;31m \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcreate_network\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mIMAGE_SIZE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchannels\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m24\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn_blocks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdepth\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     74\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     75\u001b[0m losses = {\n",
      "\u001b[0;31mNameError\u001b[0m: name 'create_network' is not defined"
     ]
    }
   ],
   "source": [
    "# define iou or jaccard loss function\n",
    "def iou_loss(y_true, y_pred):\n",
    "    y_true = tf.reshape(y_true, [-1])\n",
    "    y_pred = tf.reshape(y_pred, [-1])\n",
    "    intersection = tf.reduce_sum(y_true * y_pred)\n",
    "    score = (intersection + 1.) / (tf.reduce_sum(y_true) + tf.reduce_sum(y_pred) - intersection + 1.)\n",
    "    return 1 - score\n",
    "\n",
    "# combine bce loss and iou loss\n",
    "def iou_bce_loss(y_true, y_pred):\n",
    "    return 0.4 * keras.losses.binary_crossentropy(y_true, y_pred) + 0.6 * iou_loss(y_true, y_pred)\n",
    "\n",
    "# mean iou as a metric\n",
    "def mean_iou(y_true, y_pred):\n",
    "    y_pred = tf.round(y_pred)\n",
    "    intersect = tf.reduce_sum(y_true * y_pred, axis=[1, 2, 3])\n",
    "    union = tf.reduce_sum(y_true, axis=[1, 2, 3]) + tf.reduce_sum(y_pred, axis=[1, 2, 3])\n",
    "    smooth = tf.ones(tf.shape(intersect))\n",
    "    mean_iou = tf.reduce_mean((intersect + smooth) / (union - intersect + smooth))\n",
    "    return mean_iou\n",
    "\n",
    "def adj_mean_iou(y_true, y_pred):\n",
    "    y_pred = tf.round(y_pred)\n",
    "    y_true_pos = tf.reduce_max(y_true, axis=[1, 2, 3])\n",
    "    \n",
    "    intersect = tf.reduce_sum(y_true * y_pred, axis=[1, 2, 3])\n",
    "    union = tf.reduce_sum(y_true, axis=[1, 2, 3]) + tf.reduce_sum(y_pred, axis=[1, 2, 3])\n",
    "    smooth = tf.ones(tf.shape(intersect))\n",
    "    \n",
    "    return tf.reduce_mean((intersect + smooth) / (union - intersect + smooth))\n",
    "\n",
    "def weighted_binary_cross_entropy(y_true, y_pred):\n",
    "    weight = 768\n",
    "    weights = tf.multiply(tf.cast(weight, tf.float32), tf.cast(tf.greater(y_true, 0), tf.float32)) + 1\n",
    "    xe = tf.reduce_mean(tf.losses.sigmoid_cross_entropy(multi_class_labels=y_true, logits=y_pred, weights=weights))\n",
    "    \n",
    "    return xe\n",
    "    \n",
    "def bbox_overlap_iou(bboxes1, bboxes2):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "        bboxes1: shape (total_bboxes1, 4)\n",
    "            with x1, y1, x2, y2 point order.\n",
    "        bboxes2: shape (total_bboxes2, 4)\n",
    "            with x1, y1, x2, y2 point order.\n",
    "        p1 *-----\n",
    "           |     |\n",
    "           |_____* p2\n",
    "    Returns:\n",
    "        Tensor with shape (total_bboxes1, total_bboxes2)\n",
    "        with the IoU (intersection over union) of bboxes1[i] and bboxes2[j]\n",
    "        in [i, j].\n",
    "    \"\"\"\n",
    "    \n",
    "    bboxes1 = tf.reshape(bboxes1, (-1, 4))\n",
    "    bboxes2 = tf.reshape(bboxes2, (-1, 4))\n",
    "    \n",
    "    x11, y11, w1, h1 = tf.split(bboxes1, 4, axis=1)\n",
    "    x21, y21, w2, h2 = tf.split(bboxes2, 4, axis=1)\n",
    "    \n",
    "    x12 = x11 + w1\n",
    "    y12 = y11 + h1\n",
    "    \n",
    "    x22 = x21 + w2\n",
    "    y22 = y21 + h2\n",
    "    \n",
    "    xI1 = tf.maximum(x11, x21)\n",
    "    yI1 = tf.maximum(y11, y21)\n",
    "\n",
    "    xI2 = tf.minimum(x12, x22)\n",
    "    yI2 = tf.minimum(y12, y22)\n",
    "    \n",
    "    true_boxes = tf.cast(tf.greater(w2 * h2, 0), tf.float32)\n",
    "    inter_area = true_boxes * (xI2 - xI1 + 1) * (yI2 - yI1 + 1)\n",
    "\n",
    "    bboxes1_area = (w1 + 1) * (h1 + 1)\n",
    "    bboxes2_area = (w2 + 1) * (h2 + 1)\n",
    "    \n",
    "    union = (bboxes1_area + bboxes2_area) - inter_area + 1\n",
    "\n",
    "    return tf.reduce_mean(tf.maximum(inter_area / union, 0))\n",
    "\n",
    "# create network and compiler\n",
    "model = create_network(input_size=IMAGE_SIZE, channels=24, n_blocks=1, depth=4)\n",
    "\n",
    "losses = {\n",
    "    \"confidence_output\": weighted_binary_cross_entropy,\n",
    "    \"bboxes_output\": \"mean_squared_error\",\n",
    "}\n",
    "lossWeights = { \"confidence_output\": 10.0, \"bboxes_output\": 0.1 }\n",
    "\n",
    "metrics_dict = {\n",
    "    \"confidence_output\": 'accuracy',\n",
    "    \"bboxes_output\": [bbox_overlap_iou],\n",
    "}\n",
    "\n",
    "model.compile(optimizer='adam',\n",
    "              loss=losses,\n",
    "              loss_weights=lossWeights,\n",
    "              metrics=metrics_dict)\n",
    "\n",
    "# cosine learning rate annealing\n",
    "def cosine_annealing(x):\n",
    "    lr0 = 0.002\n",
    "    epochs_drop = 5\n",
    "    drop = 0.85\n",
    "    lrate = lr0 * math.pow(drop, math.floor((1+x)/epochs_drop))\n",
    "    return lrate\n",
    "\n",
    "learning_rate = tf.keras.callbacks.LearningRateScheduler(cosine_annealing)\n",
    "checkpoint = keras.callbacks.ModelCheckpoint(CHECKPOINT_PATH, monitor='val_loss', verbose=1, save_best_only=False, save_weights_only=True, mode='auto', period=1)\n",
    "\n",
    "# create train and validation generators\n",
    "folder = './stage_1_train_images'\n",
    "train_gen = generator(folder, train_filenames, pneumonia_locations, batch_size=BATCH_SIZE, image_size=IMAGE_SIZE, shuffle=True, augment=True, predict=False)\n",
    "valid_gen = generator(folder, valid_filenames, pneumonia_locations, batch_size=BATCH_SIZE, image_size=IMAGE_SIZE, shuffle=False, predict=False)\n",
    "\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jSSSpmNE-L1L"
   },
   "outputs": [],
   "source": [
    "# model.load_weights(CHECKPOINT_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 527
    },
    "colab_type": "code",
    "id": "fM5VeiuDcxUY",
    "outputId": "c3d66d6d-3c06-4aa6-f58d-46cfa42cdd9f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/eric/.local/lib/python3.5/site-packages/skimage/transform/_warps.py:110: UserWarning: Anti-aliasing will be enabled by default in skimage 0.15 to avoid aliasing artifacts when down-sampling images.\n",
      "  warn(\"Anti-aliasing will be enabled by default in skimage 0.15 to \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "1925/1926 [============================>.] - ETA: 0s - loss: 69799.5480 - confidence_output_loss: 0.0128 - bboxes_output_loss: 69780.6510 - confidence_output_acc: 0.9983 - bboxes_output_acc: 0.4971\n",
      "Epoch 00001: saving model to yolo1_512.h5\n",
      "1926/1926 [==============================] - 1484s 770ms/step - loss: 69797.2420 - confidence_output_loss: 0.0128 - bboxes_output_loss: 69778.3446 - confidence_output_acc: 0.9983 - bboxes_output_acc: 0.4971 - val_loss: 64552.2993 - val_confidence_output_loss: 0.0110 - val_bboxes_output_loss: 64532.8702 - val_confidence_output_acc: 0.9987 - val_bboxes_output_acc: 4.3200e-04\n",
      "Epoch 2/5\n",
      "1431/1926 [=====================>........] - ETA: 5:31 - loss: 65738.6509 - confidence_output_loss: 0.0108 - bboxes_output_loss: 65718.8871 - confidence_output_acc: 0.9986 - bboxes_output_acc: 0.5007"
     ]
    }
   ],
   "source": [
    "history = model.fit_generator(train_gen, validation_data=valid_gen, callbacks=[learning_rate, checkpoint], epochs=5, shuffle=True, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7tyG7P79Y42U"
   },
   "outputs": [],
   "source": [
    "history = model.fit_generator(train_gen, validation_data=valid_gen, callbacks=[learning_rate, checkpoint], epochs=15, shuffle=True, verbose=1, initial_epoch=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 269
    },
    "colab_type": "code",
    "id": "y_bLpJPBcxUh",
    "outputId": "49c438f6-aabc-41b9-f98e-1bf8519da3cc"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAD8CAYAAAB0FmJXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xl8U1X++P9X0iTN2jZpm+4bLVAo\nO2UpyE5BwWVExToiKiouozPzGfx+hunPkVE/svgZnHHQUT8is4oyIq6ACwLKUig7pawF2tJ935es\nvz/ahlaghZI2CZzn4+E0ubn35pwyzX3n3HPeb4ndbrcjCIIgCIIgCDc5qasbIAiCIAiCIAjuQATG\ngiAIgiAIgoAIjAVBEARBEAQBEIGxIAiCIAiCIAAiMBYEQRAEQRAEQATGgiAIgiAIggCAzNUNEASh\ne5YuXcqRI0eQSCSkpqYyZMgQx2tbtmzh7bffRqFQMHv2bObNm8fHH3/MF1984djn2LFjHDp0iJMn\nT/Lyyy8jlUrx8fFh5cqVqFQqV3RJEARBEFxKIvIYC4LnSU9P5/333+fdd9/l7NmzpKamsm7dOgBs\nNhtTpkzh008/xc/PjyeeeIJXX32V4ODgDsdv3ryZJUuWMG/ePP77v/+bIUOGsGLFCsLDw3nwwQdd\n1TVBEARBcJmrmkqxdOlS7r//flJSUjh69GiH1woLC3nggQe49957efHFFx3bv/jiC+68807mzJnD\n9u3bndpoQbjZpaWlMX36dABiY2Oprq6mrq4OgMrKSnx8fDAYDEilUsaOHcvu3bs7HP/WW2/xzDPP\nAPDOO+84RpsNBgNVVVW92BNBEARBcB9dTqVIT08nJyeHdevWXTIyBbB8+XIWLFhAcnIyL730EgUF\nBahUKt566y0++eQTGhoaWLVqFZMnT+70fUpLa7tsrF6vprKyoeteeQDRF/fkTn0JDNRd8bWysjIS\nEhIczw0GA6WlpWi1WgwGA/X19WRnZxMWFsbevXsZPXq0Y9+jR48SEhJCYGAgAFqtFoCGhgY+//xz\n3njjjS7bJv5ePdeN1Bdwn/509vfqajfb3yvcWP0RfXG+zv5euwyMrzQypdVqsdlsHDhwgNdffx2A\nJUuWALBp0yaSkpLQarVotVpeeeUVZ/QDmczLKedxB6Iv7slT+9J+RpREImH58uWkpqai0+kIDw/v\nsO/69eu5++67O2xraGjg6aefZsGCBcTGxnb5fnq9+qp+V+4cLFwr0Rf3daP1xxU89bPvSm6k/oi+\n9K4uA+PORqYqKirQaDQsW7aMzMxMEhMTWbRoEXl5eTQ1NfHUU09RU1PDc889R1JSUqfvIy60nk30\npXcZjUbKysocz0tKShwjwACjR49m7dq1AKxcuZKwsDDHa3v37uWFF15wPLdYLDzzzDPcfvvtzJkz\n56re/2q+8QcG6q5qpMoTiL64L3fpjyd8bgiC0LVrzkrRfmTKbrdTXFzM/PnzCQsLY+HChY75xFVV\nVbz55psUFBQwf/58tm3bhkQiueJ5xYXWc4m+9IzOLrTjx49n1apVpKSkkJmZidFodEyJAHj88cdZ\nsWIFKpWKbdu28eijjwJQXFyMRqNBoVA49n3vvfcYPXo09913X891RhAEQRA8QJeBcWcjU3q9ntDQ\nUCIjIwFISkrizJkz+Pv7M3z4cGQyGZGRkWg0GioqKvD39++hbgjCzWXEiBEkJCSQkpKCRCJhyZIl\nbNiwAZ1OR3JyMnPnzmXBggVIJBIWLlyIwWAAoLS01PG4zQcffEB4eDhpaWkAjBkzhmeffbbX+yQI\ngiAIrtZlYNzZyJRMJiMiIoLs7Gyio6PJzMxk9uzZDB48mMWLF/PEE09QXV1NQ0MDer2+xzsjCDeT\n559/vsPz+Ph4x+MZM2YwY8aMS44ZNGgQq1ev7rBt586dPdNAQRAEQfAwXQbGXY1MpaamsnjxYux2\nO/369WPq1KlIpVJmzpzJ3LlzAXjhhReQSkWRPUEQBEEQBMF9XdUc485GpqKiovjwww8vOSYlJYWU\nlJTrbJ4gCIIgCIIg9A4xjCsIgiAIgiAIiMBYEHrdltwfyKo67+pmCIJHazA38PnZzVQ0ikqNwo3J\nbDXz1blvOFx43NVNualcc7q2m8mqVX/i1KkTVFSU09TURGhoGD4+vixd+r9dHrtp05doNFomTZrS\n5b6zZ09j48bvndFkwc1VNFXyadZGxgSPJM4vxtXNEQSP9Z/TX7Cv+CAGHx0TAm9xdXMEwanMVjPv\nZvyDExWn2Zz9PVMjJnBX7G3IpCJs62niN9yJ5577L6AlyD137izPPvvrqz521qw7eqpZggcrqCsC\nIFAV4OKWCILnOlF+mn3FBwEoqSuDwC4OEAQP0j4ojtf3pcZSw9YLO8iqOsejCQ9iVIvrR08SgXE3\nHDy4n48++jcNDQ08++x/cejQAbZv/x6bzUZS0ngWLFjI+++/i5+fHzExsWzY8B8kEik5OeeZPHka\nCxYsvOx5z57N4vXXVyCRSFCrNbzwwh+QSr148cXFmEwmzGYzv/nNbwkLC79kW//+8Zc9p+BeCuuL\nAQjVBrm4JYLgmUxWEx+e2oBUIsVmt1FSX+7qJl2XpUuXcuTIESQSCampqQwZMgRoKcbTfuH7hQsX\nWLRoEbfeeiuLFy+moKAALy8vli1bRkREhKuaLzhZ+6B4kH88jw+ej8FfzV93/Zs9RftZse8NHug/\nh8Tg4a5u6g3LYwLj/2zN4uCZUqxWe9c7X6VR8UbmTo3r1rFnz2bx4YcbUCgUHDp0gL/+dTVSqZS5\nc+/i/vt/3mHf48czWbv2E2w2G/fdd8cVA+M33vgjzzzzKxISBrF27b/4+OOPiIvrS2Cgkd/97kXy\n8/O4cCGXoqKCS7YJnqGgvmXEOEQT7OKWCIJn2nj+O8qbKkiOnEx60QFK6su6PshNpaenk5OTw7p1\n6zh79iypqamsW7cOgKCgIP71r38BLWXbH3roIaZOncpXX32Fj48PK1euZOfOnaxcuZI///nPruyG\n4CSXC4rlUhlKmTcPDZxLf0McH53awN+Of8iJyjPM7fczvL0UXZ9YuCZi8V03xcX1dZTVVSqVPPvs\nQp577kmqqqqoqanpsG///vEolUrUanWn58zOPk9CwiAARoxI5PTpkyQkDCEzM4P//d+l5OfnMXbs\nuMtuEzxDYV0RcqmMAJWh650FQejgQm0+Wy/sIEBpYFbMdPxVBsoaKrHarK5uWrekpaUxffp0AGJj\nY6murqauru6S/T799FNmzpyJRqMhLS2N5ORkAMaNG8fBgwd7tc1CzzBbzfxfxj85UXGahHZBcXuj\ng0eweNSviNCFsadwPyv2/YX8ukIXtfjG5TEjxnOnxvGL+4dTWlrr6qYAIJfLASgqKmTdug9Ys+YD\n1Go1Dz0095J9vby8rvn8FosZqVRKQEAAf//7hxw8uJ9PP11PZmYGjz76xGW3Ce7NZrdR1FBCsCYI\nqUR8JxV6n81uI7+mCAUaVzflmlltVtaeXI/NbiMlfg4KLwX+SgPnqnOobK72yC+bZWVlJCQkOJ4b\nDAZKS0sd1WXbfPzxx6xZs8ZxTFtZd6lUikQiwWQyOQZqBM/TFhQfrzhFgn88T1wmKG5jVAeyaOQv\n+PzsJrZd2Mlr+1dxT9ztTAhLQiKR9HLLb0weExi7q6qqKvR6PWq1mlOnTlJUVITZbO7WuWJiYjl2\n7CiDBg3h0KGD9O8/gH379mKxWEhKGk90dAwrVy6/7DbB/ZU1lmO2WQgV0ygEF7DZbbx/7AMOl2Zw\nT987mBoxwdVNuiY/5O0itzafMcEjGWDoB4B/azBc3ljhkYHxT9ntl04VPHToEH369LkkWO7smJ/S\n69XIZF0P0AQG6rpupAfxhP6YrGZW7voHxytOMTxkEIvGL0ThJb9kv5/25emgBxldMIS/7v0H605/\nxvn6bJ4aPQ+twv2/9Lr7v4sIjK9T3779UKnUPP30AgYPHsZdd81h5coVDBky9JrP9etfP+9YfKfT\n6UhNXUJNTQ0vv/x7PvjgH0ilUh577EmMxqBLtgnur6B14V2IRiy8E3qX3W5n/ZkvOVyaAcBnWZvo\n4xtFtE+ki1t2dcobK/jy3Ddo5GrmxN3u2O6vbA2Mmyp65H1r6k3sPVGMTCphyohwp5/faDRSVnZx\njnRJSQmBgR1TbGzfvp2kpKQOx5SWlhIfH4/ZbMZut3c5WlxZ2dBlWwIDdW5zR9YZPKE/ZquZ/zv2\nT46Xn2Kgf38e7vcA1RVNQFOH/a7Ul0h5NItH/Zq/Z35Iev5hzmzKZsGgn9PHN7p3OtAN7vLv0llw\nLgLjq/DT1GsjRiQyYkQi0DJN4vXX3+z0+LZ9gcvmK27bFhPTh1Wr3u3wmkaj5e2337/kmMttE9xb\nYWuqtlCtGDEWeteW3B/4IW8XIZogHhh6J3/avZr3j33A4lG/QiPvfO2Dq9ntdj46/Skmm5mU/nM6\njIgFqPRAS+DsLBarjSNZZezKKCLjXDlWm50AX2WPBMbjx49n1apVpKSkkJmZidFovGRkOCMjg1mz\nZnU45uuvv2bChAls27aNMWPGOL1dQs8zW828d+xfjqB44aD5yC8zUtwVP29ffjl8IZuzv2fz+S38\n6eA7zI6ZwYyoyWLKXjeJwFgQeklbRgoxlULoTelFB/ns7Cb8vH35xdDH6BcRwW3R09iUvYV/nfgP\nTw5+2K3nJh4oOcLx8lPE6/syOnhEh9f8lf4AlF3niLHdbie7qJbdGUXsPVFMXWPLdLjIIC3jB4Uw\nNqFn7vKMGDGChIQEUlJSkEgkLFmyhA0bNqDT6RwL7EpLS/H393ccM2vWLHbv3s0DDzyAQqFg+XIx\nlc7TmG0W3jv2LzLLTzLQ0P2guI1UImV2TDL9/Prw9+Mf8eW5rzldmcXDAx/A19u9py24IxEYC0Iv\nKawvRumlxM/b19VNEW4SJyvO8O8TH6OSKXlm6AL0Sj8AbouZTlZ1Nhllx/n+wo9Mj5zk4pZeXr25\ngfWnv0AulfNA/JxLAni90hcviZTyxspunb+qrpm0zCJ2ZRRRUFYPgI9azoxREYwfHEKE8fLzep2p\nfa5igPj4jjnpv/zyyw7P23IXC57JbLPwXsY/LwbFg68vKG6vrz6W3436Nf868R+OlZ9gWfqfmD/w\nfgb693fK+W8WIjAWhF5gsVkobiglShfh1qNzwo3jQm0B72X8EwmwcPDDhGlDHK9JJVIeGfgAy/b9\nic/PbqaPbzR9fKNc19gr+DRrI7XmOn4WO4sAlf8lr0slUgLUhmuaY2wyWzl0poxdxwrJPF+B3Q4y\nLwmJ/QMZNziEQTEGZF7iFrTgfD0ZFLfRKjQ8NeQRtuft4rOsjbx15H2mR07ijj4zRTnpqyR+S4LQ\nC0oayrDZbaLindAryhsr+OuR92myNrMg4UH66WMv2cfXW8eChJ/zl0PvsebYBywe/Su0cvdZ0X66\nMou0wn2Ea0M7zaBh1PqTUXwKk9WE4grFDux2O2cLatiVUUj6iRIamy0AxIT4MH5wMKMHBKFVOTdA\nEYT2zDYLq1uD4gGGfj0SFLeRSCRMibiFWL9o1hz7gC25P3Cm6hwLEn5+2S+YQkciMBaEXiAq3gm9\npd7cwFtH1lBjquWevncwMujKGXL66eOYHZPMV+e/5V/H1/HkkEfcYsGOyWrmw5MbkCDh5/H34CW9\ncqqxQE0AcIrypspLMr6UVzexO7OI3RmFFFc2AuCnVTB5eCTjB4UQGuA+XwSEG1dbUHysNSh+cvDD\nPRYUtxepC2fxqF/x0anP2Fd8kGXpb/Dz+Hs6/UwQRGAsCL3CkZFCBMZCDzJZzbxz9O8UN5QwLWLi\nVeUqnhk9layq8xwrP8n3uT+SHDW55xvahW+yv6eksYwpEbcQ5RPR6b5GTcsIWHljBSGaIJpNVg6c\nLmFXRhEncyqxA3KZlDEDgxg/OJiBUQakUjGdSegdLUHxv3o9KG6jlCl5JCGFeEMc6059yprMDzhV\neYZ7+955xTssNzvXDw24sSeffJSTJ0902PbOO2/y4Yf/vuz+Bw/u54UX/huAxYt/c8nrn3yyjvff\n75iO7f333+WTT9Y5qcWCu3LkMBZTKYQeYrPb+PvxDzlXnc1I41B+Fjer64NonW+c8AC+Ch1fnPua\nrKrzPdzSzhXUFfFt7nb03n7cHjOzy/2NmgAAjhfksWbjCX795k5Wf3WCEzmVxIb78sht8fzp2Vt4\n8s4EBsX4i6BY6DUXg+ITLgmK2xsbksjiUb8iTBvCroJ0Xtu/ioLWARuhIxEYdyI5eSZbt37XYdv2\n7VuZPn1Gl8cuX/56TzVL8ECF9UVo5Rp08p5f5S7cfOx2Ox+f/pwjpcfo69eHhwbef01TInQKLY8m\n/By73c7fMtdSZ6rvwdZemc1uu1j2uf/dKGXeV97XZqeoooHDx+oA2JJxhp0ZhWiVcu4YF82yJ8eS\nOm8kE4eGolaKm6NC7zLbLLx/zD2C4jZBGiP/b+SzTAofT2F9Ma/t/ws78/dcVfXEm4n4tOjEtGkz\nePrpx3jmmV8CcPLkCQIDAwkMNLJv315Wr34HuVyOTqfj5Zc75pKcPXsaGzd+z/796fzlLysxGPzx\n9w8gNDTsiu/317++QUbGESwWK/fcM5dbb53N5s1fsWHDf5DJ5MTF9WPRot9edpvgvkxWE2WNFcT5\nxYiMFEKP+C5nOz/mpxGqCWbh4IeRd2P1eV99LLf3mcmX577mH8c/4umhj/b6fOMf8tI4X5NLvM9A\nqDGyq7CQmgYT1XUmahpM1NRf/K+2wYwdQNaMagQEBNp46Jbh9I/0Qyr+zgQXaguKM8pOtC60c31Q\n3EbuJWduv7vor4/j3yf+w4enNnCyMouf978HtVzl6ua5BY8JjDdkfcXRPcew2pz3zWa4cXCH8qI/\npdcbCA0N4/jxYwwcOIitW78jOflWAGpra1my5H8IDQ3jlVdeZO/eNNTqSytIvfvum/z+96/Qt28/\nnn/+l1cMjA8fPsi5c2d5++01NDY28vDDKUycOJmPPvo3r732Z4KCgtm48Quam5suu83bW+mcX4rg\ndEX1Jdixi4p3Tmaz28ivKyJYY+xWIHij2Ft4gM/PbUbv7ccvhj12XRe3GVGTyao6x/GKU3yXs52Z\n0VOvu31Wm43aBrMjoK1u/7Nd0FvdXI2l7zawyzi0PYhDliOXPZ/K2wsftYJggxpfrTfjhoby95yd\n6PwsDIjSX3d7BeF6WNoFxfH6viwc/DAKNwmK2xsamECErqWc9KGSo2RX5zIxLInRISNu+lz7N+/V\n5ColJ9/K999/x8CBg9i160fefnsNAH5+fqxY8T9YrVYKCvIZOXLUZQPjwsJC+vbtB8CwYSNobm6+\n7PucPHmcYcNaqjqpVCqio/tw4cIFpk+fSWrq/2PmzNuYPn0m3t7Ky24T3JfISOFcdaZ60gr3sbNg\nL2WN5UwJv4V7+93p6ma5xImK0/z75MeoZCqeGbrgui9oUomUhwemsHzfG3x57hv6+EbTV9+ny+Oa\nTBYKyxvIL62noLyegrJ6ymuaqK4zUd/YOrLbCZW3F7LYTCReVkIbxhI9JBYfjRwfjQIfjQJfjXfL\nc7UChbxjhorAQB1flhgoa6zAbreLuzKCy1hsFla3C4qfHPKIWwbFbQxKPb8a/iSbs7fwXe4PfH5u\nM1+c+5oBhn6MDRnJkIAEtxnp7k0eExjPibudJ5MeoLS0tlffd9KkKfzzn2tITp5JREQkPj4+ACxb\n9gr/+79/Jjo6htdfX3HF46XSi7ciO5vHI5FIaP+yxWJGKpXw0EOPkpx8G9u3b+GXv3yat976v8tu\n8/X1u/7OCj2ip0pBL126lCNHjiCRSEhNTWXIkCGO17Zs2cLbb7+NQqFg9uzZzJs3j48//pgvvvjC\nsc+xY8c4dOgQJ0+e5A9/+AMA/fv356WXXnJqO53BbrdzrjqHHflpHCo5isVuRS6V4e2lYE/Rfu6M\nvfWmW2F9oTaf9zL+iRQJTw5+2Gl3JNrmG79x6F3+lrmW343+NTpFy9z4xmaLI/Bt+a+BgrI6ymsu\n/cKv8pbhq1EQGqBpCW7VCnw0cny13vioFa1BrxxfjYLMiuO8d6yQvn59+NWUu685uPVXGiisL6bB\n0ohGfukAhSD0tJag+N8eExS38ZJ6cXufmUyNmMCBkiPsKTzA8YpTHK84hUqmIjFoGGNDRt5Uxak8\nJjB2FbVaQ2xsX/75z785plEA1NfXERQUTG1tLQcPHiA2tu9ljw8ICCQ3N5uIiCgOHTpAQsLgy+4X\nH5/AP/7xPg899AgNDQ3k5+cRHh7Ju+++xWOPPUlKyjyys89TVFTERx99cMk2ERi7r8K61owUGudl\npEhPTycnJ4d169Zx9uxZUlNTWbeuJbuJzWbjlVde4dNPP8XPz48nnniC6dOnc99993Hfffc5jt+8\neTMAr776qiOwXrRoET/88AOTJrlHieAmSxPpRYfYkZ/m+IIRpA7klrCxjA0eyZbcH/kmZyuHSjIY\nEzLSxa3tPWWNFfz1yBpMVjMLBj14VaO61yJUGcE4/0nsLNvG8h3vYyifSGFZAxWXCYB9tQoGROkJ\nC9AQ2u6/qy2Y0WBu5D+nP0MmlfFA/D3duvj6qwxAS8o2ERgLve1iUHzco4Li9tRyNRPCkpgQlkRh\nfTF7Cw+QXnSAHflp7MhPI1gTxNjgkYwOHoGvt4+rm9ujRGB8FZKTb+V//mcJS5a84tg2Z859PP30\nY0RERPLgg/NZs+b/WLjwmUuOXbjwGV544bcEB4dgNF45MBo6dBj9+8fzi188gcVi4amnnkWlUqFW\na3jyyUfRarWEhobRt28/0tP3XLJNcF+F9cX4efs6dWFDWloa06dPByA2Npbq6mrq6urQarVUVlbi\n4+ODwdASLIwdO5bdu3czZ84cx/FvvfUWf/zjHzGZTOTn5ztGm6dMmUJaWprLA+O82gJ25Kexr/gQ\nzVYTUomU4cYhTAwbS1+/WEfwlBQyim9ytpJWuO+mCYzrTPW8dWQ1NaZa7u17JyOMQ7o+6AoamswU\nlDc4RoDzW39W1jYDChT9Aqnyy6e0aT9a2wASovWEtAa+YQEaQvyvPgC+ks/PbabaVMvtMTMJUgd2\n6xwBypa5xWVNFUT6hF9XewThWrTMKf7Ao4PinwrRBPGzuFnc0WcmJyvPkFa4n4zSTD47u4kvzn3N\nQEM/xoQkMjhg4A25vuPG61EPmDRpCpMmTemw7fHHn+Lxx59yPL/ttpZFfG2jyhs3fg/A2LHjGDt2\n3BXP/dhjTzoeP/nkLy55/aGHHuGhhx7pcpvgnhotjVQ2VzHA4NwvL2VlZSQkJDieGwwGSktL0Wq1\nGAwG6uvryc7OJiwsjL179zJ69GjHvkePHiUkJITAwECKi4sd04MA/P39KS0tdWpbr5bZauZgyVF2\n5O/hfE0OAHpvP5IjpzAudNRlRykC1f7008dxujKL4obSbgdWnsJkNfHO0b9T0lDG9MhJTIm45ZqO\nv1BSx+e7c8jKrSC/rJ6qOtMl++h13iTEGAj11xDgH82W2rXUh2fx1PAp9NPHOasrAGRVnWdn/h5C\nNEEkR3X/y1j7EWNB6C1tQfHRsszWoNg9F9p1l5fUiwT/eBL846k3N3Cg+DBphfs5Vn6SY+UnUctU\nJAYNJykkkQhd2A0z1UIExoLQgwpbC3v0dMW79vPXJRIJy5cvJzU1FZ1OR3h4xxG09evXc/fdd3d5\nns7o9WpksiuX6W0TGKjrcp+i2hK+PbuD7efTqDPVI0HC8JAEkmMnMiJkUId5+pdza/8JnN6TxZGq\nIzwYdfl+OcPV9KUn2Ww2/rj7A87X5HBL5CgeHzv3qtOpXSiu5cNvT7HjcL5jW4CfihHxRiKDdEQE\n6YgM1hFh1KH5yQjwyDIdf9j6Ov848RGvzfz/8FM65zaq2WrmP/s/RYKEX4ydT0hA9zNKxIVEQAY0\nUOfyfyfh5mCxWVjTGhT318e1BsU37joHjVzNxPBxTAwfR0FdEXuK9pNedJAf83fzY/5uQjXBjAlp\nmWrho/Dsv0ERGAtCD2qrLBTi5FRtRqORsrIyx/OSkhICAy+Olo4ePZq1a9cCsHLlSsLCLqYJ3Lt3\nLy+88ALQMtJcVVXleK24uBij0djl+1dWNnS5T2Cg7oqLZa02KxnlJ9iRl8bJyjMAaOUaZkRNYXzo\nGALaRgDLuy400cc7DrVMxbZzaUwLnoKXtOuA/Vp11pfeYLfbWXf6M/bnH6G/Po77+txNeVnXv5uS\nqka+2HmetMwi7HaICtYxf9ZAgn29UXlf+vHfUNdEQ11Th20GjNwZexufZm1k5Y/v8eywx52S33jT\n+e/IryliYlgSentgt3+/gYE6pE0thUDyKotd9u8kAvIbg91up8HSSHVzDTWm2os/TTXUNNc6Hlc3\n19BsNdFfH8dTQx65oYPinwrVBjMn7nbu6nMbxytOsafwABllx/k0ayOfn91Mgn9/xgYnMihgADIP\nnGrheS0WBA9S4Bgxdm4p6PHjx7Nq1SpSUlLIzMzEaDSi1V6sqvf444+zYsUKVCoV27Zt49FHHwVa\nAl+NRoNC0fIhLpfL6dOnD/v37ycxMZFvv/2Whx56yKltba+quZpd+XvZVZBOtakGgFjfGCaGjWWo\ncXC35qvJveSMCh7BD3m7OFZ+kqGBCV0f5GG+ydnGjvw0wrQhPDH4oS4vNhU1TXy5O5udRwux2uyE\nB2q4e0IfhvUNwGj0uebgcVrERLKqzpFRdoLN2d8zOyb5erpDUX0x32Rvxc/blztjb7uucwGoZEo0\ncjXlTWIqhXB5NruNWlNdx2C3uZYaUw3Vplpqmlt/mmqx2Cydnksr1xCg8ifaJ4J7+955UwXF7XlJ\nvRgcMJDBAQOpM9ezv/gwewv3k1F2goyyE2jkakYFDWds61QLTyECY0HoQW1TKYKdHBiPGDGChIQE\nUlJSkEgkLFmyhA0bNqDT6UhOTmbu3LksWLAAiUTCwoULHQvxSktLHY/bpKam8uKLL2Kz2Rg6dCjj\nxl15Tnx32Ow2TlVksaNgDxllx7HZbSi9lEwKH8ctoWOdkmZsXMgofsjbRVph+g0XGKcV7ufLc1+j\n9/bjmaELUMmuvIizuq6ZjWnRZTpRAAAgAElEQVQ5bD+cj8VqJ8ig5u4JMSTGG6+rGpxEIuGhAfez\nLP3PbD6/hVjfaOINl8/E05WWss8bsNitzO13FyqZc/Kw+ysNFNQXYbPber1in+A+ShrKOFB8hIbz\ntRTXVDgC3lpTHfZOMmpLJVJ8FDrCNCH4eOvwVejw8fbBV6HD19sHn9afOrm2R+5KeTqtXMPk8PFM\nDh9Pfl0hewr3s6/oENvzdrE9bxdh2hDGhiQy27dnF3abLTZKqxoJDdB0+xwiMBaEHlRYV0SA0oB3\nD4woPP/88x2ex8fHOx7PmDGDGTNmXHLMoEGDWL16dYdtcXFxjmkXzlTbXMeW3B/Ymb+H0sZyACK0\noUwIS2Jk0DCUMm+nvVe4LpRIXTjHyk5S1Vx9w1Ruyiw/xdqT61HLVDw77LEr9quu0czmPTl8fyAP\nk8VGgK+Su26JYWxCEF5dzNG+Whq5mscGPcjrB9/m75kf8rvRv+5W2qa0gn2crT7P0MBBDA0c5JS2\nQcsCvNzaPGpMtTfMv79wdWx2G8fLT/FD3m6OV5zq8JpcKsdXoSPGN6pDsPvToFcjV4svVE4Spg3h\nnr538LPYWWSWn2RPUctUi0/OfElW7VkWDnzEqe9ntlg5dr6C/SdLOJxVRmOzlcUPjqBfRPfS2F5V\nYNxZIYHCwkJ+85vfYDabGThwIC+//LLjtaamJm6//XaeeeaZDqmiBOFmUGuqo9ZcR7TvQFc3pddt\nz9vFZ1kbMdssyKUyxgYnMiF8bI8miR8XOoqPTuWxp/AAtzqhlLGr5dbksfrYv5BKpDw55JHL3nVo\naLLw7b5cvt13gSaTFb3Om5Rx0dwyJASZl/Mv8jG+UdwdO4tPsr7ib5lr+eXwhdcUTFQ31/Dp2Y0o\nvZTM7XeXU9sWoGy5E1LWWOFRgfG1Xl/r6+v57W9/S3V1NWazmV/84hdMmDDBhT1wnXpzA2mF+9iR\nl0ZZ6zSaPr5RTAhLYlhUf6z1UpReyhsmW4Kn8ZJ6MSQwgSGBCdSa6lix7y9kV15wyrnbguF9J0s4\nfKaMJpMVAH8fbyYPDyM6uPtz/rsMjDsrJACwfPlyFixYQHJyMi+99BIFBQWEhoYC8Pbbb+Pr6zkf\nUILgTIU9VPHOE9SZ6gn1CSYxYBhjQhJ7pehCYtAwPjnzFWmF+5gRNdmjR3/KGsv565E1mK1mHh80\njzi/mA6vN5ksfH8gj6/35lLfZMFHLefuCX2YPDwU+VVkC7keUyImkFV1niNlmWw6/x2395l51cd+\nfOYLGi1N3N/vbqcHr/6qlqwW5Y0Vl/y+3FV3rq9bt24lJiaGRYsWUVxczMMPP8zXX3/twl70vgu1\n+fyQt5v9xYccX77HhYxiYvg4x1zWQB8dpc2uWzArdKRTaAnRBnG8/BQN5sZu5fU3W6wcO1fBvlM/\nDYaVTB4WRmK8kZgQ3XV/EeoyMO6skIDNZuPAgQO8/vrrACxZssRx3NmzZ8nKymLy5MnX1UBB8FQF\ndT2z8M4T3N5nBo8G3tOrGQJUMhUjjEPYW3SArKpzTs+521vqTPW8dfh9as113NfvLoYZL1bLNJmt\nbD+Uz8Y9OdQ2mNEoZdw7OZZpI8LxVvTOvEeJRMK8AfeRt6+Ar7O3EusbwwD/rvN0Z5Qd51DJUfr4\nRnFL2Bint8u/dcTYkxbgdef6qtfrOXWqZbpATU0Nen3309x5EovNwqGSDH7M38256pY85wFKAxPC\nk0gKGSUqHnqAIHUgx8tPUdJYSrQ88qqOMVusZJy7OE3ip8HwqAFGooOvPxhur8vAuLNCAhUVFWg0\nGpYtW0ZmZiaJiYksWrQIgBUrVvD73/+ezz77zGmNFQRP0lbC2Nmp2oQrGxc6mr1FB9hdsM8jA2OT\n1cTbR/9GSWMZyZGTmRw+HgCL1caOIwV8uTubqjoTSoUXd90SQ3JiBGpl7y8VUcvVPDZoHisP/JW/\nH2+Zb9zZCHCTpYmPTn2Kl8SLB/rf0yOj+ReLfFQ6/dw9pTvX19mzZ7NhwwaSk5Opqanh3XffdWEP\nel5lUxU7C/ayq2AvtaY6AAb692dS2DgG+vf36DtDN5u2AkzF9aVE+1w5MDaZW4PhUy3BcHNrMBzg\nq2Ty8DBGxTs/GG7vmj9R2xcAsNvtFBcXM3/+fMLCwli4cCHbt2+nqqqKYcOGERERcdXndWbBAE8h\n+uKenNWXsqNlSCVSEiJjkN9A1ZDcWaxvNEZ1AIdKM5hrvgu1B40iWW1W1mR+QHZNLqOCRnBn7K1Y\nbTZ2Hyvii53ZlNc0oZBLmTU2ilvHRF53KebrFeUTwd1xs1l/5ouW+cbDFl5xtf6X576hqrma26Kn\nOSULyeUYlHokSDxqxPinrub6Wl1dTWhoKO+//z4nT54kNTWVDRs2dHpeT7u+2u12jpee4ZszP5Ce\nfxib3YZGruL2ftOYETeRYF3XudbBffrjDDdCX/rZIuEU1EmqL+lPs9nKwZPF7DxcwL4TRTQ2twTD\nQQY1twwNZfzQUOLC/XplvniXgXFnhQT0ej2hoaFERrZE/klJSZw5c4bMzEwuXLjA9u3bKSoqQqFQ\nEBwc3GkaqOstGOBpRF/ck7P6Yrfbya3Kx6gKoKqiCWjq8pjLtUW4NhKJhHEho/ns7CbSiw85Rlw9\nwX/OfE5G2Qni9X35efw9pJ8o4fMd5ymubETmJSU5MYJZSVH4atwnZ+rk8PFkVZ3ncGkGG89/x52x\nt16yz/nqXH7I202QOpCZUT23KFIuleHr7UOZB5WF7s71NS8vj1tuaSkFHh8fT0lJCVarFS+vKwe+\nnnJ9bbI0O6qptaW6DNOGMCl8HKOChrfkC26C0qau2+kO/XGWG6Uv3uaWXPvnywooLa1tHRkuZ9/J\nEo6cLe84Mtw6TSIq6OLIcFlZndPa0tn1tcvAuLNCAjKZjIiICLKzs4mOjiYzM5PZs2fzxBNPOI5f\ntWoVYWFhTs+NKgjurKq5mkZLE/GGrudeCs41JmQkX5z7mt0F6UwKG+cRK9Kzqs6zM38PYZoQEpW3\n8crfD5JfWo+XVMLk4WHcnhSFwcc5+X6dqWW+8b3k1ebzTc5WYv1iSPDv73jdarOy9uR67Nh5oP+c\nHr9z4q80cK46G4vN4hEVt7pzffXy8uLIkSPMnDmT/Px8NBpNp0GxJyiuL+HH/DT2FB6gydqEVCJl\npHEok8LH08c3yiP+hoWu+Sp88PZSkF1RyDufH+NIVjnN5pZgONBPSeKIlmkS7YNhV+jyk6OrQgKp\nqaksXrwYu91Ov379mDrV89MkCcL16qmKd0LXfBQ6BgcM5EjpMS7U5hPpE+7qJl2R2WKjuq6Zj09s\nAqDhbDzv5Z5GIoHxg4O5c3wMgX7Xvnq7N6lkqtb5xm/xj+Mf8rtRv0avbMkf+n3ujxTUFzEuZDR9\n9bE93pYAlYGz1eepaKrCqA7o8fe7Xt25vjY2NpKamsq8efOwWCz84Q9/cHU3usVmt3Gs7AQ/5O12\nlIX3VeiYFjmB8aFjupUjW7h2tQ0mtuzPI+NcOXY70BqPtoWlLfGpxPHYEa469pN0OObi65KfnAPs\ndmjyVdLkXU7BiWKMfmoS442MijcSGaR1my9AV/WVurNCAlFRUXz44YdXPPa5557rZtMEwXO1pWoL\nuQlTtbmDcSGjOFJ6jN2F+1wSGDebrVTXNVNVZ6KqrpnqOhNV9c1U1Zqorm99XtdMfZMFqa4c7wE5\nWKsCKMj1ZvQAI3fdEkOIf/crN/W2SJ9w5vS9g/+c/ow1mWv59fAnKW+qZFP2d+gUWu6Om9Ur7fBX\ntqZsa6rwiMAYrv36qtFoeOONN3qlbT2hzlTP7oJ0dhTsoaKpZaFknF8Mk8LHMzQgQVSV6yUVNU18\nnZ7Lj0cKMJltyLwkeHlJwc7FCoF2HLUCL05/t7d7fHG7vd3OV64vCD5aH8xeNfzXg/0ZFB7mNsFw\ne+5/r0kQPFBBXVsOYzFi7AoDDP3w8/ZlX9Eh5sTNbpmb6ASNzRaq601U1zVT2RrwtgW5VXXNVNe3\nPG5bOHIlGqUMX603EUFaygIOUg9MCZ3K+AnxhAdqndLW3jYxLIkzVec4VHKUL899Q05tHmabhYf6\n9t4iyIuZKTxnnvHNIr+ukK0XdrC/+DAWmwWFVM4toWOYGD6OMG2Iq5t30yiqaGDTnhzSjhVhtdkx\n+Hgzc1IkE4eG4i13/peStgWl9tb/+aHUi/WZecg0DW4ZFIMIjAWhRxTWFyOTyghQ+bu6KTclL6kX\nY0MS+Tr7ew6VZDAmZOQ1HW+22MgtriUrv5qs/GqKKhooq25yLA65Eq1Kjr+PEl+tN34aBX46b3w1\nCvy03vhpvfHVKvDVKFC0XoAyy0/x1yMlDA4YyP1DErvdX3cgkUh4ML5lvvF3udsBGOQfzwjjkM4P\ndKKLuYw9J2Xbjcxut3Oy4gzfX/iRExWnATCqApgYPo4xwSO7VeRB6J6colo27snhwMkS7ECwQc1t\nYyNJSgjukSqZbdqC37YZGaGtGUWKG0oZ4KZrcERgLAhOZrPbKKwvJlhtFLcFXSipNTDeXZjeZWBc\nXW/ibGsQnJVfTXZhLRarzfG6Tq3A6KfCV9sW5Lb89NVcfOyjUSCXXf0Fxm6389W5bwC4PWZG9zrp\nZlQyJY8NmscfD7yFVCLl/v539+qoUIAYMXYLZpuF/cWH2do6xxygr18fpkVOJME/XuQe7iV2u53T\nF6rYmJbDsfMtfxNRwTpmj41iRL9ApNLeH7EN1bXcRS1pKOtiT9cRgbEgOFl5YyVmm1nML3axAJU/\n/fVxnKrMorih1JFc3mazk1da1yEQLq26mE5PKpEQYdQSF+ZLbLgPcWG+xMcGOjVVELRUgsutzWN4\n4GDCdaFOPbcrRejCeH7kL5BKpBiUvVuVzdfbB5nEizIPzmXsyerNDezI38OPebuoNtUilUhJDBrG\n1IgJRPlcfV0D4frY7XaOnC1nU1oOWfnVAMRH+jErKYqEaINLpzCEOALjUpe1oSsiMBYEJ2sbIQnV\nivnFrjYudDSnKrP48viPBDQOJyu/mrMFNR2mRGiUMobE+hMb5ktcmC8xITqUio4fjc6+kNjsNr46\n/y0SJMyKSXbqud1BhC7MJe/bFoyLEePeVdpQztYLO9hTuA+TzYzSy5tpEROZHDG+178c3cysNhv7\nTpawKS2XvNKWL/LD4gKYlRRFXNiVK1P2JpVcia9CR7EIjAXh5nExI4UIjHub3W6nuLKRrLzW0eCC\nBuwRcg6WHaLpiC/YpYT4qx1BcFyYL8H+aqS9PIJyuPQY+XWFJAYN67FKcDcrf5WBkorTNFmaUcq8\nXd2cG9q56my25P7I0dJM7NjRe/sxO2I840NHo5KJ+cO9xWyxsetYIZv35FBa1YREAmMTgpg1Jopw\no/st5jWqA8mqOo/JakbhhlVhRWAsCE5W6MhhLAKentZstpJdWNMyEpzf8rOu0ex4XSGX4meMoVZz\nmrtmaZgWl+jyUso2u42N57+7YUeLXa19yjaR7cD5rDYrR8oy2Zr7I+drcgGI1IUxLWIiw41DxLqK\nXtTYbOGHwwV8sy+X6joTMi8pk4eHceuYSIxunP88SB3ImapzlDaWueXfqAiMBcHJCuqK8PZSOIoc\nCNfOZrdT12CmsrYlDVplXTNVbY9rTY7t7YNgaCklmhBjcIwGhxs1FDX0Z2n6aQpsJ9GqklzUo4sO\nFB+hqL6YscGJjnnPgvO0T9nmjhddT9VkaSatcB/bLuykvHUO9+CAAUyLmEicXx+3Tb11I6prNLNl\n/wW+P5BHfZMFb4UXt42JJHlUBH5a979LYmz93CtuKHXLv1ERGAuCE1ltVoobSonQhYmV11fQZLJQ\nVdca3DqC3Z8GwCastiuniVcqvPDTehNh1F5cKBfmi1536UUhTBtClC6CzPKTVDVX4+fturl2VpuV\nTee/QyqRclvMdJe140YmUrY5V1VzNdsv7GJnwV4aLY3IpTJuCR3D1IgJBGmMrm7eTaWipolv0i/w\nw5F8TGYbWpWcuyfEMHVkOBql+01JuJK2AQF3XYAnAmNBcKKSxjKsdutNX9ijvLqJvadKySuqobL2\nYuDbVfELL6kEX62CqGAdeq03frqWdGh6nXe7596ovK/to2tc6ChyTl1gT+F+bo2edr3d67b04kOU\nNJYxPnSMI7WY4FwiZZtz5NUW8P2FH9lffBib3YZWrmF2TDITwpLQKdxv3uqNrKC0jn9vOsHu1qIc\nep0390xsLcqh8LypK0ZHYOyeKdtEYCwITtRW8e5mX3j30dYzHDjVcTRAo5Th76NsyQPcLtDVa73R\ntwbAOo2iRxbCjQwaxidnviStYB8zoqa4ZDTfarOy+fwWZBIvbnNhcH6ja5tKIVK2XTu73c7xilN8\nn/sjpyqzAAhWG5kaOYHRQSOQu+FCKXdlt9uxWG00m22YzFbMFhvNZismiw2z2Uqz5eJ2k9lKs9mG\n2dLyuslsw2SxYjJbqWkwcyK7ApsdggxqZvVCUY6e5q/U4yXxctvMFCIwFgQncmSkuMkzDdw/NY5p\no6OQ2mwto7ztqr25gkqmZIRxKHuK9nOm8hz9DXG93oa0wn2UN1UwKXycmH/egzQyNUovbzFifA1s\ndhtbz+3ms+PfUtS6eLifPo5pERMY6N9fTAv7iZp6E9sO5XMmr6oliG0NeFuC2ZafZrONK08Guzax\n4b7MTIxwWVEOZ/OSehGg8qe4oRS73e5289NFYCwITiQyUrQI8FUxIM5IaWmtq5vikBQ6ij1F+9ld\nmN7rgbHZZuHr7K3IpTJmRk3t1fe+2UgkEvxVBsoay93youuODpVksCbzA6QSKaOCRjAtcoLLclG7\ns4Kyer7dl8vuY8WOyphSiQSFXIpC7oVCJnVUwPSWtWyTy6R4y71QyKXIZS0/vWVeyOVSFK3Pu/oZ\nE2lweoEhVwtSB1LcUEKdud7tpuaIwFgQnKigvgiNTI2PQufqpgg/EesbTZA6kMOlx6g3N6CRq3vt\nvXcV7KWyuYqpERPw9fbptfe9WfkrDeTXFbrlRdcdJfj3Z2Hiz4lURIu7GT9ht9s5kVPJN+kXyDhX\nDoBRr2LGqAiSEoKveb1Dd9yIX+6M6gCgJTOFu/2NisBYEJzEZDVT2lBOrF/0DflB5ukkEgnjQkfz\nadZG9hUdYnLE+F55X5PVzLfZW1F4KZgRNaVX3vNm56+6mMvY3S667kgpUzI9doJb3eFxNYvVRvqJ\nYr5Nv0BuSctobd9wX2aOjmRYXMANMaXBldpnpojzi3FxazoSgbEgOElxQwl27Df9NAp3NiZ4JJ+f\n3czuwnQmhY/rlS8wO/LTqDbVMiNqigjSeokjZVtjBdE+kS5ujeBJ6pvMbD+Uz/cH8qiqMyGVSBg9\nwMiMUZH0CRV3e5zFnTNTiMBYEJyktzNSLF26lCNHjiCRSEhNTWXIkCGO17Zs2cLbb7+NQqFg9uzZ\nzJs3D4AvvviC1atXI5PJ+OUvf8nkyZPZt28fr7/+OjKZDLVazWuvvYavr+ty/fYknULLkICBHC49\nRm5tHlE+ET36fk2WZr7N2YbSy5tpkRN79L2Eiy6mbBO5jIWrU1LVyHf7LrDzaCHNZitKhRczRkUw\nfWQ4AW5cRc5TBbUr8uFuRGAsCE7StvAupBdGjNPT08nJyWHdunWcPXuW1NRU1q1bB4DNZuOVV17h\n008/xc/PjyeeeILp06fj7e3NW2+9xSeffEJDQwOrVq1i8uTJLFu2jD/+8Y/06dOHd955h3Xr1rFw\n4cIe74OrjAsdzeHSY+wu3NfjgfGPebupM9dzW/R0tHJNj76XcFHbiLFI2SZ0JSu/mm/Sczl4uhS7\nHfQ6b+66JYaJQ0NRK0WI1FO0cg0qmUoExoJwI7uYqq3nR4zT0tKYPr2lclpsbCzV1dXU1dWh1Wqp\nrKzEx8cHg6ElOBg7diy7d+9GqVSSlJSEVqtFq9XyyiuvAKDX66mqqgKgurqaPn369Hj7XWmAoR9+\n3r7sLzrMnLjb8fZS9Mj7NFqa2JL7AyqZiqkRE3rkPYTL8/egIh+d3fkpLCzkN7/5DWazmYEDB/Ly\nyy8Dl7/zI1w9m83OwdOlfJOey9mCGgCignTMHB1BYrzRo3MEewqJREKQOpALtflYbVa8pO5TqEQE\nxoLgJAX1xfgqdL0yMlhWVkZCQoLjucFgoLS0FK1Wi8FgoL6+nuzsbMLCwti7dy+jR48GoKmpiaee\neoqamhqee+45kpKSSE1NZd68efj4+ODr68uiRYu6fH+9Xo1M1vUHWWCge2bnmBY7nk+ObyKr8TST\nY5Ku6phr7cv6zB+ptzSQMvhOokLdq3Suu/67dNfl+uPrraPKXOXWfe3szg/A8uXLWbBgAcnJybz0\n0ksUFBSgUqkue+dH6Fpjs4WdGYV8t+8CZdVNAAyLC2Dm6Aj6RfiJRdO9LEgdSHZNLuVNlY4sFe5A\nBMaC4ASNliYqmiqJ1/d1yfvb7RdTyUskEpYvX05qaio6nY7w8HDHa1VVVbz55psUFBQwf/58tm3b\nxiuvvMKbb77JyJEjWbFiBWvXrmX+/Pmdvl9lZUOXbQoM1LntKvchvkP4hE18c2oHCdpBXe5/rX1p\nMDfw5cktaORqRukT3er34M7/Lt1xpf7ovfVcqM2nuKS6VwpUdCcA7+zOj81m48CBA7z++usALFmy\nBIBNmzZd9s6PcGUVNU18fyCP7YcLaGy2IJdJmTwslORREYT4iylOrtIWDJc0lIrAWBBuNG3Vonpj\nGgWA0WikrOziat6SkhICAwMdz0ePHs3atWsBWLlyJWFhYTQ1NTF8+HBkMhmRkZFoNBoqKio4deoU\nI0eOBGDcuHF8+eWXvdIHVwpQGYjX9+Vk5RmK60sI0jh3RPf73B9ptDTxs9hZKGVKp55buDr+Sj3Z\nNblUNVdjUOpd3ZzL6uzOT0VFBRqNhmXLlpGZmUliYiKLFi0iLy/vsnd+rkdxRQPvfHGc2vpmJBJw\njJtKJC2PWzdIkCBxPG7bRdK2K7Tb1vG4i+eSeUlReXuh8pahVHih9pah9JahUshQeXuhbPvpLUPt\nLbuuaQ25xbV8k55L+okSrDY7Pmo5MyfEMHl4GD7qnplCJVw9Y7uUbTDAtY1pRwTGguAEBa3zi3sr\nVdv48eNZtWoVKSkpZGZmYjQa0WovpgJ7/PHHWbFiBSqVim3btvHoo49iNptZvHgxTzzxBNXV1TQ0\nNKDX6wkICCArK4u4uDgyMjKIiorqlT642rjQUZysPENa4X5+FjfLaeetM9WzLW8nOoWWSeHjnHZe\n4dq0n2fsroHxT7W/82O32ykuLmb+/PmEhYWxcOFCtm/fDlz+zk9n0wC6mvpUUNXEodMlmC02p/XF\nWeQyKWqlDLW3HJVS5nisbnusbH3sLUPV+thssfHn9Uc5mtUyeBARpONnk2KZPCLcpaXpr4c7Twm6\nVm19GSCPhmNQba92q/6JwFgQnKA3M1IAjBgxgoSEBFJSUpBIJCxZsoQNGzag0+lITk5m7ty5LFiw\nAIlEwsKFCx0L8WbOnMncuXMBeOGFF5BKpbz00ku88MILyOVyfH19Wbp0aa/0wdWGBA5CI1Ozp3A/\nd/SZ6bTFH9/lbqfZauKOPrei6KGFfULXAhyZKSpxzQSnrnV250ev1xMaGkpkZEse5qSkJM6cOYO/\nv/9l7/z4+/tf8X26mvoU6qfk42W3U1JS49jWEqPbaYvVW59ib7et/X5t/+vY327/yXEtL5qtNpqa\nrTSaLDQ2W2kyWWhsbnnc2Gyh0WRxvN7UbKHR1Lq92UxFbRPNJmunfWlvQJSemaMjGdzHgEQiobqq\n6ylg7uhGmv7Uvi9eVhUSJOSU5/d6/zoLxEVgLAhOUFjXFhj33iKr559/vsPz+Ph4x+MZM2YwY8aM\nS45JSUkhJSWlw7YRI0bw0Ucf9Uwj3ZhcKmN08Ai25e0ko/wEwwK7nmvclermWn7I242fty+3hI5x\nQiuF7vKEzBSd3fmRyWRERESQnZ1NdHQ0mZmZzJ49m8GDB1/2zs/18pJKPCIbg81mp8nULqB2BM4W\nmlofmy02JiVGolO4f39uZgovOXqln9sV+RCBsSA4QUF9Ef5KvZhP6mGSQkexLW8naQXpTgmMv8vZ\nhtlmZmbUVORecie0UOguR/U7N85l3NWdn9TUVBYvXozdbqdfv35MnToVqVR62Ts/NwupVOKYRtGZ\nG2mU9UYWpA7kRMVpmixNbnP9FIGxIFynOlM9NaZaBvm7z+IB4eqEaUOI8okgs/wUVc3V+Hl3v+Jf\nZVMVOwr2YFDqGRc6yomtFLrDoPRDgsStR4yh8zs/UVFRfPjhh5ccc7k7P4LgiYzqAE5UnKakoYxI\nn/CuD+gFN8/XTEHoIY7CHr1UClpwrvEho7FjZ0/h/us6zzc527DYLNwWPQ2ZVIw5uJqX1Au90o/y\nJlEWWhDcldENS0OLwFgQrlNB68K7UG3vLLwTnGtE0FAUUjm7C/Zhs3dvVX55YyW7C9IJUPkzJnik\nk1sodJe/Uk91cw1mq9nVTREE4TKCOqRscw8iMBaE69TbGSkE51LJlIwIGkp5UwWnK8926xxfZ2/B\narcyK3q6W5U2vdn5qwzYsVMhRo0FwS0ZVWLEWBBuOAV1RUiQEKwO7HpnwS2ND20pmZ1WuO+ajy1p\nKGNP0QGC1EZGBQ93dtOE69A+ZZsgCO5Hr/RFLpWLEWNBuFHY7XYK64swqgNEFgIPFuMTRZDayOGS\nDOrM9dd07ObsLdjsNmbHTO+V0sPC1fOElG2CcDOTSqQY1QEUN5Z1KHDjSlf1Kb506VLuv/9+UlJS\nOHr0aIfXCgsLeeCBB7j33nt58cUXHdtfe+017r//fu655x6+/fZb57ZaENxEtamGBkujWHjn4SQS\nCeNCR2GxW9lXdOiqjyuqL2Ff0SFCNcEMNw7pwRYK3eEJKdsE4WZnVAVgspqoNtV0vXMv6DIwTk9P\nJycnh3Xr1vHqq6/y6st/2roAACAASURBVKuvdnh9+fLlLFiwgPXr1+Pl5UVBQQF79uzhzJkzrFu3\njtWrV980lbSEm8/Fwh5ifrGnGxM8Ei+JF7sL0q965GLT+e+wY2d2nxlitNgN+ataCl+IEWNBcF9t\nC/CK691jOkWXn+RpaWlMnz4dgNjYWKqrq6mrqwPAZrNx4MABpk6dCsCSJUsIDQ1l1KhRvPHGGwD4\n+PjQ2NiI1Xr1ZRwFwVMUtKZqExkpPJ9OoWVwwEAK6ovIrc3rcv/8ukIOlBwhQhfG0ICEXmihcK18\nFDrkUpkYMRYEN9aWsq2k0UMC47Kysg7lJg0GA6WlLY2vqKhAo9GwbNkyHnjgAVauXAmAl5cXarUa\ngPXr1zNx4kS8vMRKbeHG05aRIlRMpbghjGtdhLe7IL3LfTee/w6A22NmIJFIerRdQvdIJVIMSgPl\njWLxnSC4K3fLZXzNWejb32K02+0UFxczf/58wsLCWLhwIdu3b2fy5MkAbNmyhfXr17NmzZouz6vX\nq5HJug6eAwN119pktyX64p6upS+lh0uRSWUMiIxBJtJ0ebwBhr7ovf3YX3yYOX3vwNtLcdn9cmvz\nOFJ6jGifSBL84y+7j+Ae/FV6ihtKaLQ0opKpXN0cQRB+IsjTAmOj0UhZWZnjeUlJCYGBLZ3Q6/WE\nhoYSGRkJQFJSEmfOnGHy5Mns2LGDd955h9WrV6PTdR1oVFY2dLnPjVT7XPTFPV1LX2x2G7nVBQSp\nA6ks7/r/v91pi9C7pBIpY0MS2Zy9hYMlR0kKSbzsfhvPtSwovr2PGC12d46UbY2VROhEYCwI7kYt\nV6GTaylpKOt6517Q5VSK8ePH88033wCQmZmJ0WhEq9UCIJPJiIiIIDs72/F6TEwMtbW1vPbaa7z7\n7rv4+fn1XOsFwYUqmqowWU0iI8UNJikkEQkS0q4wneJ8dQ7Hyk8S6xtDvL5vL7dOuFaOlG1inrEg\nuK3/n707j6uqzh8//roLcFfgXriXTRDEnTLFJcklU9EmqzErwcZlxsqpsfw2k1PGzxnnm3tlU9le\nVjNTGmVOX6dpWtyaFve1cEOURUD2fRO49/cHcoVUQATuBd7Px8NH3HvuOef9uXG47/O5n8/7Y9VZ\nyKvIp9pW4+xQmu8xjoyMJCIigtjYWBQKBUuWLGHTpk0YjUaio6OJi4tj0aJF2O12+vbty/jx4/n4\n448pKCjgsccecxxn9erVBAYGtmtjhOhImRcm3klFiq7FR2umn6k3xwsSOVeWjb/e2mj7Zxd6i++Q\n3uJOwVGyTSpTCOGy/HS+JBWdIbciz+mdTS0aY7xw4cJGj/v3vzimrmfPnmzYsKHR9piYGGJiYtog\nPCFcV32pNpl41/XcFDiC4wWJ7Mzcy129pzieP1V4huMFifQz9aaPKdyJEYqWcpRskx5jIVyWozJF\neY7TE2MpvClEK0mptq5rkCUCvZuO3Zn7qWnw1d5np+uGld3ea7KzQhNXyVfjA0iPsRCuzJUm4Eli\nLEQrZZSdw13phlljav7FolNxU6oZ4R9JSXUpP+UeA+BE/ikSC08z0Kcfvbx6OjlC0VI6Ny1atZbc\nSinZJoSrcqWSbZIYC9EKtbZassqy8df7yYpnXdRNARdqGmfuxW6389mZC73FYZOcGZZoBV+NifyK\n/BavaCiE6Fi+WjNKhdIlKlPIJ7oQrZBTkUeNvZZAmXjXZQUa/An1DOFo3gm2nf6e00UpDPKNoKdn\nsLNDE1fJR2vmvK2akupSZ4cihLgMtVKNr8ZMtvQYC9E51Y8vDjDIxLuu7KbA4dix89b+ugnGt/eS\n3uLOyMdRy9j1xhmvWLGCmJgYYmNjOXLkSKNtmZmZzJgxg3vuuYc///nPjbZVVlYyceJENm3a1JHh\nCtFurDpfSqvLKKtu+3UBroYkxkK0wsWloKXHuCsbar0Bd5U7NruNIdZBBBkCnB2SaAVHLWMXS4z3\n7NlDSkoK8fHxLF++nOXLlzfavmrVKubOncvGjRtRqVRkZGQ4tr322mt4eXl1dMhCtBtXGWcsibEQ\nrZBZKhUpugONWsNI/2G4KdVMCYt2djiilXw0rlmybefOnUycOBGA8PBwioqKKC2tG+5hs9nYv38/\n48ePB2DJkiWOtQCSkpI4deoU48aNc0rcQrQHvwYl25xJEmMhWiGjLAutWouXu6ezQxHt7O4+t/PK\nHcudXltTtJ6vi/YY5+bmYjJdrGpjNpvJyalLCvLz89Hr9axcuZIZM2awZs0ax+tWr17NokWLOjxe\nIdqTq/QYt2iBDyHERdW11eRU5BLqGeLUlc9WrFjB4cOHUSgUxMXFMWjQIMe2LVu28Nprr+Hu7s6U\nKVOYOXMmAJs3b+btt99GrVazYMECxo0bR3V1NYsWLSIlJQW9Xs9LL70kX9E2oFaq8dYYySkpcXYo\nopXM9WOMXbxkW8OqGXa7naysLGbPnk1QUBDz5s1jx44dFBYWMnjwYIKDWz4J1GTSoVarmn2dxWJs\nVdyuqiu1pzu0RW0Ig4NQWFvg1PZKYizEVcoqz8Fmtzl1xbuGYxOTkpKIi4sjPj4eqPsKdunSpfzz\nn//E29ubBx98kIkTJ+Lh4cErr7zCJ598Qnl5OWvXrmXcuHF89NFHmEwm1qxZQ3x8PPv27WPChAlO\na5sQbc1d5YaXu9HleoytViu5uRfLU2VnZ2Ox1PWamUwmAgMDCQkJASAqKorExEQSEhJIS0tjx44d\nnDt3Dnd3d/z9/bnpppuueJ6CguYnM1ksRnJyus7NX1dqT3dpi92uQKPy4GzBuXZvb1OJtyTGQlyl\nixUpnDe++EpjEw0GAwUFBXh6emI21/WSjRw5kh9++AGNRkNUVBQGgwGDwcDSpUsB2L59OwsWLACQ\npdxFl+WjNZNcnEatrRaVsvne044watQo1q5dS2xsLAkJCVitVgwGAwBqtZrg4GCSk5MJDQ0lISGB\nKVOm8OCDDzr2X7t2LUFBQU0mxUJ0FgqFAqvOl4yyLGx2m9PWCJAxxkJcJVeoSNHU2ESz2UxZWRnJ\nyclUV1eze/ducnNzOXv2LJWVlTz00EPcd9997Ny5E4D09HT++9//MmvWLH7/+99TWFjolDYJ0Z58\nNGZsdhuFVUXODsUhMjKSiIgIYmNjWbZsGUuWLGHTpk18/fXXAMTFxfHUU08RGxuL0Wh0TMQToquy\n6izU2GrIr3Te55D0GAtxlTLre4xdaDJWw7GJCoWCVatWERcXh9FopEePHo5thYWFvPzyy2RkZDB7\n9my2b9+O3W4nLCyMRx55hFdffZU33niDJ598ssnzdccxi9IW19WS9gT7+LM3C2o8Klyq/QsXLmz0\nuH///o6fe/bsyYYNG66476OPPtpucQnhDA0rU9RPmu1okhgLcZUySrMwuhkwuhucFkNTYxMBRowY\nwfr16wFYs2YNQUFBVFZWMmTIENRqNSEhIej1evLz8/H19WX48OEAjB49mrVr1zZ7/u42ZlHa4rpa\n2h6tre56TTqXjp8yqF3iEEJcm4aVKQb69HNKDDKUQoirUFlTRV5lvlPHF0Pd2MQvv/wS4JKxiQAP\nPPAAeXl5lJeXs337dqKiohg9ejS7du3CZrNRUFBAeXk5JpOJsWPH8u233zqOFRYW5pQ2CdGefLUX\nahm72AQ8IcRFrlDLWHqMhbgK58rrxxc7dxhFw7GJCoXCMTbRaDQSHR3N9OnTmTt3LgqFgnnz5jkm\n4k2ePJnp06cDsHjxYpRKJbNmzeLJJ59k48aN6HQ6Vq9e7cymCdEuHMtCu9giH0KIiyxaXwCyy3Ob\neWX7kcRYiKuQWer8iXf1mhqbOGnSJCZNmnTJPrGxscTGxjZ6TqvV8tJLL7VPkEK4CG8PL5QKJXkV\nrl3LWIjuTKP2wNvDy6mLfMhQCiGugiuUahNCXD2VUoXZw9vlloUWQjRm1VkoqCqkqva8U84vibEQ\nV6G+VJsrVaQQQrSMj9ZM8fkSztdWOzsUIcQV1I8zznHScApJjIW4Chml5zB5eKNVa5wdihDiKtWP\nM86XXmMhXJZfg8oUziCJsRAtVFZdTtH5YgIM0lssRGfkc6Euaq5UphDCZVl19RPwJDEWwqW5wop3\nQojW89XUlWyTyhRCuK6LPcYylEIIl1a/4p0kxkJ0TvU9xlLLWAjXZdaYUCtU0mMshKvLuFCqTYZS\nCNE5ORLjSinZJoSrUiqU+Op8ySrPwW63d/z5O/yMQnRSmWXnUKDAX2d1dihCiFYwuhlwV7pJj7EQ\nLs5PZ6GytpLi86Udfm5JjIVoAbvdTkbZOXy1ZtxV7s4ORwjRCgqFAh+tWWoZC+HinLk0tCTGQrRA\n8flSyqrLZXyxEJ2cj8ZMRU0l5dXlzg5FCHEFVq3zKlN0iiWha221vPnj30Blx1/jT7AxiGBjEBat\nD0qF5Pai/WXKindCdAmOkm2V+YS46ZwcjRDicvz0zqtl3CkSY4VCQUVNFUl5Z/iJE47nNSoPehgD\nCTYGEWLsQbAxCD+dRZJl0eYulmqTiXdCdGaOkm0V+YQYezg5GiHE5Vjrh1JUSGJ8WUqFkj8MfRi9\nt5pDZ06SVppOanE6aaXpJBUmc6rwjOO17ko3R7IcbOxBiDEIf50VlVLlxBaIzi6j9EKPsQylEKJT\nk5JtQrg+g5sevVonPcbN0blp6WPqRR9TL8dzVbXnSS/NILUknbQLyXJycRqni1Icr1Er1QQZAup6\nlg1BBHsGEaD3x03ZqZovnCiz7BxKhdKxIo8QonOqXxZaSrYJ4dqsOgspJWnU2mo7tHOz02eGHip3\nenmF0ssr1PFcdW016WWZpJWkk1aSTmpJOmdLMkgpTnO8RqVQEaj3I/jCEIwQzyAC9QG4q9yc0Arh\nyuorUvjpLKjlZkqITs3VeoxXrFjB4cOHUSgUxMXFMWjQIMe2zMxM/vCHP1BdXc3AgQN5+umnAXjm\nmWfYv38/NTU1/Pa3v2XSpEnOCl+IduOns3CmOIXcynxHlYqO0KJP+dZcuE3t097cVG6EeoYQ6hni\neK7GVkNmWRapJWdJK8kgteQs6aWZpJVmQGbda5QKJWGeIdx/3Uy8PDw7LF7h2vIrC6mqPS8VKYTo\nArRqDXo3nUuUbNuzZw8pKSnEx8eTlJREXFwc8fHxju2rVq1i7ty5REdH87//+79kZGSQmppKYmIi\n8fHxFBQUcNddd0liLLqk+m9os8tzXCsxbs2Fe/bs2Sb3cQa1Uu2oZlGv1lbLufLsumEYJekkF6WS\nVJTMplOf8ZuI+5wYrXAljooUkhgL0SX4aMxklJ3DZrc5dbL2zp07mThxIgDh4eEUFRVRWlqKwWDA\nZrOxf/9+nn/+eQCWLFkCgJ+fn6OjydPTk4qKCmpra1GpZB6N6Frqk+Gs8hyu78DzNvsX4UoXLuC4\ncMePHw/UXbiBgYFN7uNKVEoVQYYAogKGMb3vL1k4bD49PYPZl3WIkwVJzg5PuAhHRQpZClqILsFH\na6bGVkPx+RKnxpGbm4vJZHI8NpvN5OTUTTbKz89Hr9ezcuVKZsyYwZo1awBQqVTodHVl5jZu3MjY\nsWMlKRZdktVJi3w022Ocm5tLRESE43H9hWswGBpduAkJCQwbNozHH3+8yX1cmVKhJKbvVJ7d9zLx\nJz8lbvhjUs1CkOHoMZbEWIiuwLd+Al5FAd4eXk6O5iK73d7o56ysLGbPnk1QUBDz5s1jx44djBs3\nDoAtW7awceNG3nnnnWaPazLpUKub/yyzWIytjt0VdaX2dMe2eJk1KPYoyK8u6ND2X/VMopZcuE3t\ncyWucuFaLAOZWDCar5O+ZW/BPu7oP7Edz9X9ftE7g5+3JacyBzeVGwOCQ1EqpUa2EJ2dj7a+lnEe\n4d6hTovDarWSm5vreJydnY3FUtdLZjKZCAwMJCSkbq5MVFQUiYmJjBs3jm+//ZbXX3+dt99+G6Ox\n+b+9BQXNr/JnsRjJyXFuD3pb6krt6c5tMWtMnC3KbPP2N5WzNJsYt+bCbWqfK3GlCzc6cAI/pO7n\no5/+RX9D/3bpUejOv+iu7OdtsdltpBVnEqD3Iy+vrMNjEUK0vYsl25w7AW/UqFGsXbuW2NhYEhIS\nsFqtjm9W1Wo1wcHBJCcnExoaSkJCAlOmTKGkpIRnnnmG9957D29vb6fGL0R789NZOJp/goqaCrRq\nbYecs9nur1GjRvHll18CNHnh1m8PCwtrcp/OQO+mY2r4bVTVnmdT4mfODkc4UU5FHjW2GqlIIUQX\ncrFkm3NrGUdGRhIREUFsbCzLli1jyZIlbNq0ia+//hqAuLg4nnrqKWJjYzEajYwfP57PP/+cgoIC\nHnvsMWbNmsWsWbPIyMhwajuEaC8XK1PkNvPKttNsj3HDC1ehUDguXKPRSHR0NHFxcSxatAi73U7f\nvn0ZP348SqXykn06m5EBw/g+Yw/7sw8zKv9G+pl7Ozsk4QT1E+9kfLEQXYdZY0KBwuk9xgALFy5s\n9Lh///6On3v27MmGDRsabY+JiSEmJqZDYhPC2RpWpujpGdwh52zRGOOrvXAvt09no1Qoiek3lWf2\nruWjk5/y1IjHZHGHbijzwlLQgQbpMRaiq3BTqvHy8CTXRRb5EEJcnjMqU8hMoiaEGHswJmgk58qz\n2Z72nbPDEU7gyhUpVqxYQUxMDLGxsRw5cqTRti1btnD33XczY8YM3n//fcfzmzdv5s4772TatGmX\nTJT99ttv6devX0eELoTT+WjMFFYVUWurdXYoQograNhj3FEkMW7GHb0mY3DT83nyFgoqC50djuhg\nGWVZaFQemDxca5JLw4V3li9fzvLlyx3bbDYbS5cu5a233uKDDz5g+/btnDt3joKCAl555RXWr1/P\n66+/ztatWx37VFVV8eabbzY7SVaIrsJXa8aOnXz5uy6Ey/Ly8MRd6SaJsSvRXZiId772PJtOyUS8\n7qTaVkN2eQ4Ben8UCoWzw2mkqUV0CgoK8PT0xGw2o1QqGTlyJD/88AM7d+4kKioKg8GA1Wpl6dKl\njuO9/vrr3Hfffbi7uzulPUJ0NB9NXck2VxhnLIS4PKVCiVVnIbs8F5vd1jHn7JCzdHI3BgwlzLMn\nB7KPcDw/0dnhiA6SXZ6DzW5zyRXvmloxy2w2U1ZWRnJyMtXV1ezevZvc3FzOnj1LZWUlDz30EPfd\ndx87d+4E4MyZMxw/fpxf/OIXTmmLEM5QX5kityLPyZEIIZrip7NQbaumqKq4Q84ns8laoH4i3uq9\nL/HRyU+JG/F7mYjXDVysSOH6E+8aLqKjUChYtWoVcXFxGI1GevTo4dhWWFjIyy+/TEZGBrNnz2b7\n9u2sXLmSxYsXX9X5XGVBno4kbXFdrWlPuL0HHIMKZVmXez+E6ErqS7Zlledg0rT/sEbJ7loo2BjE\n2B5RfHP2B7alfcuknrc4OyTRzuorUrjixLvmFtEZMWIE69evB2DNmjUEBQVRWVnJkCFDUKvVhISE\noNfrycjI4PTp044qMtnZ2cycObPRhL3LcaUFeTqCtMV1tbY96ioNAGl559rk/ZDkWoj2YW0wAa+/\nuU+7n0+GUlyF28PqJuL954xMxOsOMi70GLtiqbbmFtF54IEHyMvLo7y8nO3btxMVFcXo0aPZtWsX\nNpuNgoICysvLCQgIYMuWLXz00Ud89NFHWK3WZpNiIboCLw9P1AoVuTLGWAiX5tfBJdukx/gq6Ny0\n3NV7Cv849hGfJP6LB66f5eyQRDvKKDuHwU2P0c31Vm1sbuGd6dOnM3fuXBQKBfPmzcNsrhtPOXny\nZKZPnw7A4sWLUSrl3lh0T0qFErPGRJ7UMhbCpVk7uGSbJMZXaYR/JN9n7OFgzo8cyzvJAJ++zg5J\ntIOq2vPkVeTT2zvM5SpS1Gtq4Z1JkyYxadKkS/aJjY0lNjb2isfctm1b2wUohIvz0ZrJzj9JZU0V\nGrWHs8MRQlyGVq3B093YYT3G0l10lZQKJTF9p6JAwUeJn1Jtq3F2SKIdnCvLwo7dJYdRCCHaRn3J\ntvzKAidHIoRoip/OQn5lIdW11e1+LkmMW6GHMZCbe9xEdnku21L/6+xwRDvoTBUphBCtU1+yTWoZ\nC+HarDpf7NjJ6YDyipIYt9KUsEkY3Q38J3mr9DZ0Qa68FLQQom34aOprGUtiLIQr68hxxpIYt5LO\nTctd4VOotlXzSeK/nB2OaGOZpRcqUkhiLESX5VvfYyyJsRAurSMrU0hifA1G+EcS7hXKoZyfSMg7\n4exwRBvKKDuHt4cXOjeds0MRQrQTR4+xDKUQwqVJj3EnoVAoiOl3F0qFko9PykS8rqK8uoLCqiIZ\nRiFEF6d306FReUiPsRAuzldjRqlQSo9xZxBkCODmoJvIqchja+o3zg5HtIFz5fXDKGTinRBdmUKh\nwEdrJq8yv9Gy6kII16JSqrBofcguz23+xddIEuM2MKVXNEZ3A18kb5Oehy4gw4WXghZCtC0fjZmq\n2vOUVTe/zLkQwnmsOl/KasopPV/WrueRxLgNaNVapvW+XSbidRGuvBS0EKJt+Wjrahk7q2TbihUr\niImJITY2liNHjjTalpmZyYwZM7jnnnv485//3KJ9hOiqOmqcsSTGbWS43xDCvcI4nJvAT7nHnB2O\nuAaZF3qM/aXHWIguz5kl2/bs2UNKSgrx8fEsX76c5cuXN9q+atUq5s6dy8aNG1GpVGRkZDS7jxBd\nVUdVppDEuI3UTcSbWjcRL3Fzh6zOItpHRtk5fDVmPFTuzg5FCNHOnFmybefOnUycOBGA8PBwioqK\nKC0tBcBms7F//37Gjx8PwJIlSwgMDGxyHyG6MqtWeow7nSBDAON6jCK3Io8tXXgins1uI68inx9z\nj/JVyna+ObMLm93m7LDaRFFlMaXVZQTIMAohugVnlmzLzc3FZDI5HpvNZnJy6j708/Pz0ev1rFy5\nkhkzZrBmzZpm9xGiK/PTd0yPsbpdj94N3RYWzb6sQ3yZso3h/pGO3ojOyG63U1hVRGZZFhll58gs\ny3L8O197/uILk6CvdzizB8Zg0ng7L+A2kFaUCUhFCiG6C7PmwhhjF5g43bAyht1uJysri9mzZxMU\nFMS8efPYsWNHk/tcicmkQ61WNfs6i8V4VfG6uq7UHmkL+NoN6Ny05J7Pa9f3QxLjNqZVa5jW+3be\nO7qBjYmbeWjQr50dUrPsdjsl1aVklNYnvxeT4IqaykavVSlU+OksBOj9CDT446+zcrDgCPvSD7N8\nz1+J7XcXw/wGO6kl1y6tKAOQihRCdBcatQdGN4NTJt9ZrVZycy+Wn8rOzsZiqesVM5lMBAYGEhIS\nAkBUVBSJiYlN7nMlBQXNV9ywWIzk5JS0phkuqSu1R9rSYH+tL2dLMsjKLkKpaP2gh6YS606TGB9P\nKeBccRU+OjVuLbjzdaZhfoP5PmM3P+Ye5cfco1zvO9DZITmUVpeRWXox+a3vCf55qSKlQolV60t/\nUx8C9H4EGPwJ1Pth0fqiUjZ+/ycOjOL/jmxlY+K/eDdhPT/mHiWm713o3LQd2bQ2UZ8YS0UKIboP\nH62ZtJJ0bHbbNX3YXq1Ro0axdu1aYmNjSUhIwGq1YjAYAFCr1QQHB5OcnExoaCgJCQlMmTIFs9l8\nxX2E6OqsWgspxWnkVRRg0fm0yzk6RWJcU2vjuQ8PYbPbUauUhAd60i/Em34hJsIDPXF3c61EWaFQ\nML3vVFbufYGPT26mn6kP7iq3Do3BZreRUpxGRuk5R/KbUXaOkvONJ2koUOCrNdPbK6wuAb6QBFt1\nFtyULfv1UCgUjAq8kT7e4fzt6IfsyzpEUmEyswfG0NcU3h7NazdpRRl1NwW6pntghBBdh4/GRHJx\nKkVVxR06HCwyMpKIiAhiY2NRKBQsWbKETZs2YTQaiY6OJi4ujkWLFmG32+nbty/jx49HqVReso8Q\n3YWfo2RbdvdOjNUqJU/cN4RjaUUcPJHFybRCTqQVwvfJqFUKegV60S/Ym/4h3oQHeblEohxo8OeW\nHqPZmvZfvk7dwZSw6HY/p91u50xxKvuyDnEg+/AlSbCPxsR1Pv0J0Ps7hkL46axtlrRbdb78IfJh\nvkjZxhfJW3np4JtMDLmZKb0mtTjJdia73U5qcQZWrW+niFcI0TZ8tBdLtnX0PImFCxc2ety/f3/H\nzz179mTDhg3N7iNEd+GYgFfRfivgdZpP/77B3oyKDCYnpydlldUkphVxPLWAE2mFJJ4t5GRaIf/6\nAdQqBWEBnvQLMdEvxJveQV54OClRvi1sIvuyDvFVynZu9I/EV9s+dzfppZnsyzrE/qxD5FUWAKB3\n0zEq8EbCPEMIMPjhr/NDo/Zol/M3pFKqmBIWzUBzP/52dANfp+7gaP4Jfj1whssPTyisKqKiupL+\npr7ODkUI0YF8L1SmyKvMpw+9nByNEOJKrFpfoH1LtnWaxLghvcaNwX18Gdyn7g0qr6wh8WwhJ1IL\nOZ5awKn0IhLPFvHZD6BS1ifK3vQPMdUlyu4dkyhr1Bqm9bmddxPW8/HJzTx8w2/a7Ng55Xnszz7E\nvqxDZF5Yqc1D5c4I/0iG+Q2mv6nPJWOBO1KYVwiLhj/GplOf8X3Gblbve4mp4bdxc4+bOnQM39Wo\nX/FOJt4J0b007DEWQrguq64u78suk8S4STqNmht6+3JD74uJ8qn0Qo6n1iXLpzOKOZVexL93pqBS\nKggNMNI/xES/YG969/BC495+b8NQ6w18n76bn/KOXfNEvMKqIg5kH2Ff1iFSitMAUCvV3GC5jmF+\ng7nOZ0CHj2VuikbtwX397+Y6n/58cHwjGxM381PuMWYNnI63h5ezw7tEZlndindSqk2I7sWnQY+x\nEMJ1uavcMXl4y1CKq6XTqBkU7sug8LpEuaKqhsSzRZxIK+BEaiFnMkpISi/m3ztTUCrqEuV+Id70\nCzbRp4cXWo+2e1sUCgXT+01lxZ6/8vHJ/7vqiXhl1eUcyv6RfVmHSCw8jR07SoWSAea+DPUbzGBL\nBFq1a1d/GGSJPE2dWQAAIABJREFUINQrhA+OfcxPecdZvvt5ZvS/m0jrIGeHhs1u41ThaXZl7udg\n9hFAKlII0d2YNd4oULhELWMhRNP8dBaOFyRSWVPVLkNEu2Ri/HNaDzWDwn0YFF43xreiqoak9KK6\nHuW0ApIzSzidUcx/dqWiUECQr56wAE/CAj3pFeBJkEWPStn6r/8D9H6MDx7DltRv+CplO7f3mtTk\n6ytrqvgx9yj7sg5xLP8ktfZaAHp5hTLMbzCR1kEY3TtXeR5PdyMPDfoN32Xs4pPEz1j30/v85D+U\ne/v+Eq1a0+Hx5FbksTtzP7vP7XeMy/bRmPlFv5sdY5iEEN2DSqnCpPF2/C0QQrgu64XEOLsihxBj\njzY/frdIjH9O66Hmul4+XNerLlGuPF9DUnoxx1MLSEwrJDmrhLM5ZXx7pG4VNHe1kp7+RsICPOkV\n6ElYgCe+XhoUCkWLz/mL0AnsyzrE16k7GOEfiYXGxaWrbTUcyzvBvqxD/Jh7lPO2aqBumelhfoMZ\nah2Mj9Z0uUN3GgqFgjFBUfT1Due9ox+y+9x+ThWeZvbAWHp7h7X7+StrqjiY8yO7M/eRWHgaqPta\nZqT/MEYGDCPcOxQ/q1eXKaQuhGg5H42JU4VnqLbVSFUaIVxYfcm27PJc5yXGK1as4PDhwygUCuLi\n4hg06OJX4OPHj8ff3x+Vqm6i13PPPYfBYODJJ5+kqKiI6upq5s+fz5gxY9o8+LaicVcTEWYmIqxu\nnFmtzUZGbjlnMos5nVHsGKOceLbIsY9R51aXKF/oWQ4L8MSgvfIQCc2FFfHeSfiAjxP/j4Eh/4PN\nbuNkQRL7sw5xMOcnKmoqALBofRjmN5hhfoPx74ITwfz0VhYOnc/nyVv4MnkbLxx4neie45gSFo26\njT+QbHYbSYVn2JW5nwM5RxxLWffx7sXIgGEMtlzfIdU6hBCuzUdrJrHwNPmVBY4PXiGE66mfgNde\nlSmazUL27NlDSkoK8fHxJCUlERcXR3x8fKPXvPXWW+j1esfj999/n7CwMB5//HGysrKYM2cOX3zx\nRdtH305USiXBVgPBVgNjbwgEoOp8LSlZdUMu6hPmI0l5HEnKc+xnNWnrEuULyXKI1dCopnKkdRDf\nZ+zmaN4JXti5joSskxSfr+ud9PbwIipgGMP8BhNi7HFVvdGdkUqp4o5ek4nw6cd7CR/yVcp2juWf\n5NcDY9vkZiCvIp9d5/azO3O/Y0KNj8bEjcFjuTFgaLuVzutITd2wbtmyhddeew13d3emTJnCzJkz\nAdi8eTNvv/02arWaBQsWMG7cODIzM3nqqaeoqalBrVbz7LPPNrvErBBdjaNkW0W+JMZCuLCLPcZO\nSox37tzJxIkTAQgPD6eoqIjS0tIml6A0mUycOHECgOLiYkymzj0EAMDDXUXfYG/6Bl8s/l5Udp4z\nmcWcySjm9IX/7jqaxa6jdWW/VEoFPSwGx/CLsEBP7unzS1btfYGdafvRq3WMDryRYX6DCfcOc9ky\nZu2pl1cocSMe4+PEzezK3MeqvS9yV+/bGRsUddU3B1W15zmU/SO7MvdxsjAJAHelGzf6D2VkwDB6\nd6H3uKkbVpvNxtKlS/nnP/+Jt7c3Dz74IBMnTsTDw4NXXnmFTz75hPLyctauXcu4ceN44YUXmD59\nOrfddhsffPAB7777Lk888YSTWyhEx6ov2SaVKYRwbSaNN2ql2nmJcW5uLhEREY7HZrOZnJycRonx\nkiVLSE9PZ+jQoTz++ONMmTKFTZs2ER0dTXFxMW+88Ua7BO9sXnp3Bvf2ZfCFMnF2u53sggpHknw6\ns5jUrBJSskrYfjAdAI27Cv/gcVgtHvjag/Aq0ZBb60ZVQQEGnRsGrRtGrTvubsou32tcT6PWMGvA\ndK73GcD6E5/w0clP+Sn3GDMH3IuXh2eT+9rtdpKKktmVuY8D2YepujBUord3GCP9hzHEej0aJ0zu\na29N3bAWFBTg6emJ2Vz3QT9y5Eh++OEHNBoNUVFRGAwGDAYDS5cuBequXw+PuuEkJpOJhIQE5zRK\nCCeqL9kmtYyFcG1KhRKr1pes8hzsdnub50pXPaDTbrc3erxgwQLGjBmDl5cX8+fP58svv6SqqorA\nwEDWrVvH8ePHiYuLY9OmTU0e12TSoVY3vyCFxWJs9jXOZLV6cl2/i0MBqmtsJGcWcTK1kJOpBZxM\nLSA5qZbkJBuQdsXjuKuVeOrd8dR7XPjvz/95YNS7NdruzKWw2+L/S7TlJob1iuDVPX/n8LmjrNz7\nV347fCYjegy+5LW5ZfnsSN7FN8m7yCqtu2u06MzcHDaSsaEj8Te0/qtQV/8dg6ZvWM1mM2VlZSQn\nJxMUFMTu3bsZMWIEAJWVlTz00EMUFxfz6KOPEhUVhU6nA6C2tpb169czf/58p7RJCGeqn9wsJduE\ncH1WnYWMsnMUnS9u83URmk2MrVYrubkXCylnZ2c3Gn84depUx89jx47l5MmT5OXlMXr0aKBu3ffs\n7Gxqa2sdE/Qup6CgvNlgLRZjp6wY4K1RM6KvLyP6XlyABDcVaemFlJRXU1pRTUlFNaXl1ZRWnG/w\nczUZuaWczqht0Xk83FQYtG4YdG4YtW54GzyIHh5MsLV9S7u17f8XJQ8OmMM3nj/w6al/89z3bxAV\nMJx7+tyBUqHkUM5PdUMlCpKwY8dN6cYI/0hG+g+jj6lX3VCJCsipaF08rvQ7djUJesMbVoVCwapV\nq4iLi8NoNNKjx8VZu4WFhbz88stkZGQwe/Zstm/fjkKhoLa2lieeeIKRI0cSFRXV7Pm6yo3s1ZC2\nuK62aI+PXY+bUk1RTVGXe3+E6GoaVqbo8MR41KhRrF27ltjYWBISErBarY5hFCUlJTz22GOOST57\n9+5l8uTJGAwGDh8+zOTJk0lPT0ev1zeZFHc3Oo0ai8WITtWy7v/qGhulFXWJcmn5hcT5QvJccpnn\nM/PKSKm2AbAz4RxTonpy+02hqFWdY3ytQqFgXI9R9Df15r2EDezM3Mux/JNU1lRSWVsFQLhXKCMD\nhjPEer1T6iA7W3M3rCNGjGD9+vUArFmzhqCgICorKxkyZAhqtZqQkBD0ej35+fn4+Pjw1FNP0bNn\nTx555JEWnb8r38hejrTFdbVle8waM1klua06niTTQnSchpUp+prC2/TYzSbGkZGRREREEBsbi0Kh\nYMmSJWzatAmj0Uh0dDRjx44lJiYGDw8PBg4cyK233kp5eTlxcXHMnDmTmpoa/vKXv7Rp0N2Nm1qJ\nyeiBydjysmJV1bUcSyngH1+eYPP3yRw4mcPcKQMI9W96zK4r8df7sXDYI/z7zNd8nbIDbw8vxgWP\n5kb/oY6Lortq6oYV4IEHHmD16tVotVq2b9/Ob37zG6qrq1m0aBEPPvggRUVFlJeXYzKZ2Lx5M25u\nbixYsMCJLRLC+Xy0JrLKs6moqeyWN9xCdBbtWZmiRWOMFy5c2Ohx//79HT/PmTOHOXPmNNqu1+t5\n8cUX2yA80VoebioG9/alX7A3H28/xY5DGSz7235uvTGEX44Oxa0FX4O7ArVSzS/Df8EvQieiVqq6\nTFWJa9XcDev06dOZO3cuCoWCefPmOSbiTZ48menTpwOwePFilEol69evp6qqilmzZgF1k/nkZlZ0\nRw1LtvUwBjo5GiHElVgvJMbtUctYlvfp4rQeambf2p9h/a2895/jfL4rhYOJOfzmtgH0DmrbcTnt\nyV115cVTuqumblgnTZrEpEmXLj0eGxtLbGxso+c+/PDD9glQiE6mYck2SYyFcF16Nx0GN3279BhL\n91s3MTDUzNP3j2DC0B5k5pWz8h/7+XBrIlXVLZvYJ4QQXZ1Pgx5jIYRrs+os5FUWUGOradPjSmLc\njWjc1fwqui+LfhWJ1aTlq71pLFm3hxOpBc4OTQghnK6+ZFuuLPIhhMvz01mw2W3kVuQ1/+KrIEMp\nuqG+wd78Ze4I/u/bM3y5N5XV6w9yS2QQ99wcjtZDfiWEEN2TrxN6jJta2n38+PH4+/s7qjo999xz\nGAwGnnzySYqKiqiurmb+/PmMGTOmw+IVwlX4OcYZ5+Kv92vm1S0nWVA35eGmYvr43gztb+Hdz4+z\n/UA6R07l8etf9CcizOzs8IQQosPp3HRo1VpyKzvmW7Smlnav99Zbb6HX6x2P33//fcLCwnj88cfJ\nyspizpw5fPHFFx0SrxCupL46VVuPM5ahFN1ceKAXS349nNtv6klBSRVr4g/x3n+O1S1CIoQQ3Yyv\nxkR+Rf4lq7y2hyst7d4Uk8lEYWEhAMXFxZhMpnaPUwhX5NdOlSkkMRa4qZVMGxvOn+YMI9hq4L+H\nM/nTut0cPpXb/M5CCNGF+GjNnLdVU1LddILaFnJzcxsltvVLuze0ZMkSZsyYwXPPPYfdbmfKlClk\nZGQQHR3NzJkzefLJJ9s9TiFcka/WBwWKNu8xlqEUwqGnv5E/zRnG57tS+Nf3yby48QhREX7MmNgX\ng1bKpQkhur6GlSk83Tt2Nbuf91IvWLCAMWPG4OXlxfz58/nyyy+pqqoiMDCQdevWcfz4ceLi4ti0\naVOTx+2OS7hD12qPtOXyrAZfcipz2/SYkhiLRtQqJXeOCiOyr4V3/n2MnQlZJCQXMGtSX4b2szo7\nPCGEaFeOWsYV+YR59WzXczW3tPvUqVMdP48dO5aTJ0+Sl5fH6NGjgbra5dnZ2dTW1jom6F1Od1vC\nHbpWe6QtV+br4UNC6XFSMrLQuemuKo4rkaEU4rJ6WAz8v9lDuXdcOOWVNbzyz5947dOfKC477+zQ\nhBCi3fho6ku2tf8EvFGjRvHll18CXLK0e0lJCffffz/nz9f9zd27dy99+vShZ8+eHD58GID09HT0\nen2TSbEQXVnDyhRtRXqMxRWplEp+MbIng/v48u7nx9l7PJtjKQXcF92HGwf4oVAonB2iEEK0KV9H\nj3Hb1ka9nOaWdh87diwxMTF4eHgwcOBAbr31VsrLy4mLi2PmzJnU1NTI8u2iW2tYmSLMK6RNjimJ\nsWhWgI+eRb+KZOv+s3zyTRJvbj7K3mPZzJrcD2+Dh7PDE0KINmO+MMa4o0q2NbW0+5w5c5gzZ06j\n7Xq9nhdffLFDYhPC1bVHZQpJjEWLKJUKoocHc0NvH977z3EOJuZyIrWQ2Al9mDre4OzwhBCiTbir\n3PByN8qy0EJ0AtYLiXFbVqaQxFhcFatJx8IZQ/jmUAYfbT/FO58f46t9aejcVbi7q/BwU6Fxu/iz\n45+7Cg83ZYOff76t7p9SKcMzROusXftXTpw4Rn5+HpWVlQQGBuHp6cWKFc82u+/nn/8Lvd7AzTff\n0gGRClfnozWTXJxGra0WlVLG77aHjrpeFy36A6tWPd8WIQsX5OXuiYfKXXqMhXMpFQpuGRLE9b3M\nrP86kRNpBaRX1dIW5fDVKiWaC0m0+4VkWeOuQuOu5vpwH266zh8PN/mgEpd69NHfA3UfmqdPJ/HI\nI4+1eN/bbrujvcISnZCPxszpohQKq4ocVSpE2+qo61WS4q5NoVBg1Vk4V5aFzW5Dqbj2mhKSGItW\n8/XSsuCeQVgsRrKzizlfY6Oqupbz52upqq6l0vGzjcrqGs5X26g6f+H56lqqLryu6uc/X3hdSXk1\nudWVVNfYADh0KpdN3yQxbkgQ4yN7YDLK+GbRvAMH9vHhh+9TXl7OI4/8noMH97Njx1ZsNhtRUaOY\nO3ce69a9gbe3N2Fh4Wza9BEKhZKUlDOMGzeBuXPnNTrehg3vX7J/SUkJTz+9mLKyMgwGA3/5ywpq\na2sveW7Dhn/g7e3N3XfHcPr0KZ5//hlefvlNYmPvom/f/owYcSN+fgG8/fbruLm5YTQaefrpVbi5\nufHCC89x9OhPqFQq/vjHp3jvvXXceeddDBs2gvPnzzNz5r2sX/8JarX8Wb9WjpJtlfmSGHewtr5e\np0yZwL//vZWkpFM8//xqFAoFOp2exYv/wqlTiWza9BHLlj3T6LWic/HTWUgrSaegsggf7bWvBCl/\nQUWbUCgUjuEQtLyUYIvYbHYKS6v45lAG2w+m8++dKXyxO5Xh/a1EDw8mLMCzbU8ortlH205xIDGH\n2tq2W1Z3eH8r08f3btW+SUmn2LBhE+7u7hw8uJ9XX30bpVLJ9Om/JCbmvkavPXo0gfXrP8Fms3Hv\nvXdc8kELXLL/hg3/YMSIKO69N5b4+A/Yt28Px48fveS5K8nISGfFiufo1Sucbdu2sGTJMgIDg1i6\n9M/s3r0TDw8PsrOzePPN9zh06ABbt37N5Mm3sXXr1wwbNoL9+/cwcuRNkhS3kfpFPnIrCujbDVZc\n7urXK8CLLz7H7373P0REXMf69f/g448/ZMiQoa2KT7gWq/ZiZQpJjEW3oFQqMHtquGtsL6ZE9WTX\n0Sy+3pvGrqNZ7DqaRe8eXkwaFkxkX4uMURaX1bt3H9zd3QHQaDQ88sg8VCoVhYWFFBcXN3ptv379\n0Wg0VzzW5fY/efI4DzzwMAAxMb8CYPPmTZc8l5h44grH1NKrVzgA3t7erF69jNraWjIy0hk6dDgF\nBflcf/0NAAweHMngwZHU1NTw2msvUVNTw7fffiPDQdqQ74UP17xKmYDnDG15vdZLTj5DRMR1AERG\nDuPdd9+UxLiLaFiZYoBP32s+niTGolNxd1Mx9oZAxgwK4GhyAV/tTePH03mcOluEr5eGiUN7MHpQ\nIDqN/Go70/TxvZkfM8RlVmtyc6tb0vzcuUzi4z/gnXc+QKfTMWvW9Ete29RiCVfaX6lUYbfbGr32\ncs81rP1dU1PTIL6Lv68rVy7l2WdfIDQ0jOefX33FY6nVaoYPH8m+fXs4c+Y01103qMn3QLTcxR7j\n9q9l7Aq66vV6JTU11SiVyktq8Te8JkXnYdW3bck2WflOdEoKhYKIMDO/n34Dyx64kXFDgiguO8+H\n206x8NXvWb/lJNmFFc4OU7iYwsJCTCYTOp2OEyeOc+7cOaqrq695/wEDBrJ//14APv30E/7zn88u\n+5xer3csAXzkyKHLnqOsrBQ/P39KSko4cGC/4/gHDuwD4OTJ46xZU5cwT558G+vWvS49X23M28ML\npUJJXkXH1DIWl3et12tDYWHh/PTTEQAOHjxAv34D0Ov15OXVXY+nTiVSXt780tnC9TQcStEWpFtN\ndHqBvnpmT+7HtLG9+OZQOlv3n2XLvrNs3XeWwX18mTQ8mL7B3rJSn6BPn75otToefngu118/mF/+\nchpr1qxm0KAbrmn/5cufYdmyP/PII/PQ6fT85S/LsNnslzxXXFzMH//4Pxw7lsDgwZGXPce0affy\n8MP3Exwcwq9+NZt33nmT1157h549w/jd7x4A4PHHFwHQv/8AiouLiY6+tW3eIAGASqnC7OEtQymc\n7Fqv14Yee2yhY/Kd0WgkLm4JWq0OjUbLQw/N5frrb8DfP7AdWiHam0atwcvds816jBV2u73tRttf\ng5Z8hWOxGF3mq55rJW1pPzW1NvYdz+arvWkkn6uLq6efkejhPRgxwA+16spflLhSWywWo7NDuCK5\nXl1DamoKa9as5sUXX23xPq7altZqr/a8dPBNThSc4q83L8dd5daiOFxVd7teoWu1R9rSvBcPvMHJ\nwiT+evMy3FXuLYrjSqTHWHQ5apWSkRH+3DjQj1PpRXy1N40DJ3N4+7NjfLwjifGRPRg3OBCjrvmL\nRwhX9emnG9m8+Z/8v//3v84OpUuqH2ecX5mPv97PydEIIZpi1flysjCJnIo8ggwB13QsSYxFl6VQ\nKOjTw5s+PbzJKaxg6/6zfHskg3/+9zSf/ZBMVIQ/0cODCfLVOztUIa7a1Kn3MHXqPc4Oo8uqr1+c\nWyGJsRCurmFlCkmMhWgBi7eW2Al9+OXoML47ksmW/Wn893AG/z2cQUSYmUnDg7kuTAr5CyHq+Grq\nS7bJBDwhXJ21PjEuu/ZxxpIYi25F66EmengwE4b24NCpXL7em0bCmXwSzuQT4KPjrlv6cF2IFxp3\nuTSE6M4cq99VyAQ8IVydn84KQHaFJMZCtIpSqSCyr4XIvhZSzpXw1d409hzL4tWNh9G4q7jpOn/G\nDQmih8Xg7FCvaMWKFRw+fBiFQkFcXByDBl2sY7tlyxZee+013N3dmTJlCjNnzgRg8+bNvP3226jV\nahYsWMC4cePIzMzkiSeeoLa2FovFwrPPPusori9Ed+UYSiGVKYRweWaNNyqFqk0qU0gdY9Ht9fQ3\n8uAdA3n2dzdx3+T+aD3UbDuQzp/X7WHl+/vZlXCO6hpb8wfqQHv27CElJYX4+HiWL1/O8uXLHdts\nNhtLly7lrbfe4oMPPmD79u2cO3eOgoICXnnlFdavX8/rr7/O1q1bAXjppZe47777WL9+PT179mTj\nxo3OapYQLsPoZsBd6SY9xkJ0AiqlCovWh+zyHK612JokxkJc4G3wYMakfjzzcBSPTLueiDAziWeL\nePNfR1n46vd8vOMUOS6yaMjOnTuZOHEiAOHh4RQVFVFaWgpAQUEBnp6emM1mlEolI0eO5IcffmDn\nzp1ERUVhMBiwWq0sXboUgN27dzNhwgQAbrnlFnbu3OmcRl2j3/72Nxw/fqzRc6+//jIbNrx/2dcf\nOLCPxYufAGDRoj9csv2TT+JZt+6Ntg9UdAoKhQIfrVlqGbeTjrheP//8X3zzzfY2ili4Oj+dhYqa\nSkqry67pODKUQoifUSmVjmEWWQXlfHMwg+9+zOQ/u1L5Ylcq1/XyYdyQQG4I90WpdM6iIbm5uURE\nRDgem81mcnJyMBgMmM1mysrKSE5OJigoiN27dzNixAgAKisreeihhyguLubRRx8lKiqKiooKx9AJ\nHx8fcnKa/yrKZNKhVje/FGtH1na9665fsmvXN4wZM8Lx3Hff7eDvf//7ZePw9tbh4eGGxWJk3bq3\nLtluMGiorvZw7OvKdWqvVldqC7RfewK8rGRmZKH1UmJwl+o1bSk6ejLbtn1N//4DHM/t2LGNtWtf\nb3bfVaueb9E5brvtjlbHJzofa4PKFEb31g+DlMRYiCb4mXRMH9+bu8aGse94DtsPpvPj6Tx+PJ2H\n2dODm28IZOwNgXgZPJwaZ8OvjhQKBatWrSIuLg6j0UiPHj0c2woLC3n55ZfJyMhg9uzZbN++/YrH\naUpBQfNLp3Z0UfobbxzLww/fz69//RAAx48fw2TyQanU8fnnW3j77ddxc3PDaDTy9NOrKCwsp6qq\nmpycEqZMmcC//72Vffv28NJLazCbffDx8SUwMIicnBJHW7Kzs1i69M8A1NTUsHjx/xIU1IMvvvg3\nGzfGo1AoiI39FRMmTLrsc/XnAVi8+AmmTZvOwYP7ychIJzMzgxdeeJWVK58mJyebiooK5s6dx6hR\nYxzLQCuVCq677gamTLmTZ55Zzquvvg3A3/62Dp1Oz733xjb7PnWlxQKgfdtjVHoCcOJsKiHGHk2+\ntrXJeVNzBcaPH4+/vz8qVd1N6HPPPYefn99l5wp0NhMmTOLhh+/nd79bANRdrxaLBYvFyt69uy+5\nXhtq6nptaN26N/D29ubuu2N49dUX+fHHw9TU1HL33dO59dYpPPLIPP7whyfo1as3n3wST2FhIfff\n/9sOew9E27qYGGfT2zus1ceRxFiIFnBTq4i6zp+o6/xJzSphx6EMdiac45/fnmHz98kM6ePLLUOC\n6N/T1CFLT1utVnJzcx2Ps7OzsVgsjscjRoxg/fr1AKxZs4agoCAqKysZMmQIarWakJAQ9Ho9+fn5\n6HQ6Kisr0Wg0ZGVlYbVarzm+Tac+48iun6i1td3CmkOs1zOt9+1X3G4ymQkMDOLo0Z8YOPA6tm37\n2rFUcklJCUuWLCMwMIilS//M7t070el0lxzjjTde5k9/WkqfPn1ZuHDBJR+0eXm5/OY3DxIZOYzP\nPvs/Nm36mPvvn8d7773N3/62gfPnq1m+fAlRUaMueW7ChElXjL2mpppXX32bgoJ8RowYyS9+cTvp\n6Wf5058WMWrUGF544Tn++Mc4evfuw9Klf0aj0VBdfZ7s7CysVj9++OE7Vq58rpXvrLgSR8m2ioJm\nE+PWaDhXICkpibi4OOLj4xu95q233kKvv9hbXT9X4JNPPqG8vJy1a9dec2LcVa/XeocOHeD06SRe\ne+0dKioqmDMnlrFjx7VJO4XrqK9lnF2e28wrm9aiMcYrVqwgJiaG2NhYjhw50mjb+PHjue+++5g1\naxazZs0iKysLqJv9fueddzJt2jR27NhxTUEK4UpC/IzMntyP5+ePYtakvgT46Nh3IodnPzzE/3tr\nN1/tTaOssrpdYxg1ahRffvklAAkJCVitVgyGi18dPfDAA+Tl5VFeXs727duJiopi9OjR7Nq1C5vN\nRkFBAeXl5ZhMJm666SbHsb766ivGjBnTrrG3p+joW9m69WsAvv/+v4wbVzd22tvbm9Wrl/HII/M4\neHA/xcVFl90/MzOTPn36AjB4cOQl281mHz7++EPmz3+Qjz5aT3FxEcnJZwgJCcXDQ4PRaGTVqucv\n+1xTBgyoGxZjNHpy7FgCDz88l+XL/+KIMzU1hd69+wDwpz89jb9/AJMm3ca2bV+Tm5uDXm/AbPZp\nxTsmmuIo2dZO44ybmivQ1D6XmyvQGbX39Vrv+PGjju1arZbQ0F6kpaW1ZVOEC7DqfAGuuTJFsz3G\nrnJHK4Sr0XqouSWyB+OGBHEqvYgdB9PZezybD7cmsumbJEYM8OOWyCDCAjzb/NyRkZFEREQQGxuL\nQqFgyZIlbNq0CaPRSHR0NNOnT2fu3LkoFArmzZuH2Vz3AT958mSmT58OwOLFi1EqlTz66KM8+eST\nxMfHExgYyNSpU685vmm9b+e3UTM6/Cv7m2++hb///R2ioycTHByCp2fde79y5VKeffYFQkPDeP75\n1VfcX6m82FdwuWEl69a9wY03jmTq1HvYvn0LP/zwHUqlCru9cdWSyz33czU1NY6f3dzcAPj66y8o\nLi7mlVfO0asyAAAJbElEQVTepri4mAcemHVJXPUmTpzM4sVPoNFoiY6e3OS5ROvULwvdXpUpmpor\nUG/JkiWkp6czdOhQHn/8cc6ePXvZuQJNaW5OwG8tM669Ma0wbdod3H333dx7712Eh/ciPLyux/eZ\nZ5bx5ptvEh4eztNPP43RqGk0J0ChUGCxGFGrVY4hLDqdO2p14yEter0HBoOGmho158+fd2xTKu34\n+Bhwd1djMumxWIxoNGr0eg+XHX/vqnG1Rnu1xdduQO+uI68q75rO0WxifKU72oYX7uX2qb+jNRgM\nnfqOVojmNFx6OnZCH777MZMdB9P57sdMvvsxk57+Rm4ZEsSNA/zwcG9+wlpLLVy4sNHj/v37O36e\nNGkSkyZd+tV9bGwssbGNx6FarVbefffdNovLmXQ6PeHhffj73991fC0LUFZWip+fPyUlJRw4sJ/w\n8D6X3d/X10JqajLBwT05eHA/ERHXN9peWFhIUFAP7HY73333DbW1Nnr2DCU1NYXy8nJUKhVPPvl7\nVq5cc8lzf/3rKygUCiorKwE4efLEJecvLCwkICAQpVLJN99so7q67puH0NAwEhJ+IiLiOlaufJoZ\nM2YRGhqGp6cnX375OWvWvNRWb6FooOGy0B3h5zdjCxYsYMyYMXh5eTF//nzHNzuXmyvQ1BAuV5wT\nUC80NJyXXnqFCROiHecvLi7Bzc3I6dMZfP/9TgIDe6LXX5wTYLfbyckpwWz2Zf/+HwkO7sl33/1A\nRMT1jmNYLEbKyqpwc6ukd+9+/O1v67jrrhmUl5dz5kwyer0P7u4aTp1KwWQKYOfO3YSFhbvk+Puu\nNC+gvdti1fiSUnKWc1mFqJRX/rxtKnFuNjHuqDtaIboCo86dX9zYk8kjQjh6Jp/tB9M5dCqX9/5z\nnPhtpxwLhwT5ygz39hIdfSvLli1hyZKLN+TTpt3Lww/fT3BwCL/61WzeeedN5s373SX7zpv3OxYv\nfhJ//wCsVr9Ltv/yl9P461+fxd8/kHvuieGZZ5bz44+Huf/+h3jssbrjxcTch1arveQ5hULB1Kn3\nMG/eHEJDe9Gv34BLjj9u3HgWLfoDR4/+xJQpd164aXmL//mfhTz33EoAIiKuJzQ07MLrJ/D999+i\n08nvU3vQqjXo1bp2G0rR3FyBht/ejB07lpMnTxIUFHTZuQI+Pp1zKE17Xq/1brhhMP369Wf+/Aep\nqanhoYceQavVcued01iz5hmCg4MJCmr7MeSi41l1Fs4Up5JXme+YjHe1FPZmpqH/6U9/4uabb3b0\nGs+YMYMVK1YQFlb3h/nTTz9tdEd71113kZqayoEDB67qjramprZF5Z+E6GxyCir4ancKX+1OJr+4\nCoC5d0Rw17jeTo6s9Vpyxy+9HO1v2bIl3HbbHURGDmvxPq7altZq7/as3vsSmWXn+OvNy5v8DGvN\nV7cHDhxg7dq1vPvuuyQkJLBs2TI2bNgA1E1Ae+yxxxwrWD722GNMnjyZyMhIFi1axLp16ygqKmLa\ntGls3br1ssNt6nW36xW6VnukLS33RfI2/nX6Cx4e9Buu872086FhHFfSbI9xR93RuvJXPe1B2uKa\n2qstk4YGMX5wAIcSc9l1NAt3ZfMfVl1pTJloW1VVVTz66G8ZMGDgVSXF4uqN6zGK5OK0dqk209xc\ngbFjxxITE4OHhwcDBw7k1ltvRaFQXHaugBACIq3Xk1ycSpAhoNXHaDYxHjVqFGvXriU2NvaS2e8/\nv6Pdu3dvozvaBx98kKKiIsfsdyG6M7VKybD+Vob1v/ZyaKJ78/Dw4M0333N2GN3CjQFDuTFgaLsd\nv6m5AnPmzGHOnDmX7HO5uQJCiLqhFA8N+vU1HaPZxFjuaIUQQgghRHfQogU+5I5WCCGEEEJ0ddKN\nK4QQQgghBJIYCyGEEEIIAUhiLIQQQgghBCCJsRBCCCGEEIAkxkIIIYQQQgCSGAshhBBCCAG0YElo\nIYQQQgghugPpMRZCCCGEEAJJjIUQQgghhAAkMRZCCCGEEAKQxFgIIYQQQghAEmMhhBBCCCEASYyF\nEEIIIYQAOklivGLFCmJiYoiNjeXIkSPODueaPfPMM8TExHD33Xfz1VdfOTuca1ZZWcnEiRPZtGmT\ns0O5Jps3b+bOO+9k2rRp7Nixw9nhdGpd6ZqV69U1yfXaduR6dV1d5XqFznPNqp0dQHP27NlDSkoK\n8fHxJCUlERcXR3x8vLPDarX/397dgsTSxmEYv/asGHRUdPEDQYtREBUMGmSDaLFYZDHIRqPRIBhM\nW/1Ag9iFXTCZBBcMY7HZ1KTIosOOiqhleE4znHTenX3P88xw/9puusNe8GcY2KurK25vbzk5OSEM\nQ5aWlpifn7c9K5aDgwO6urpsz4glDEP29/epVCp8fn6yu7tLPp+3PSuR0tSsenWTem0e9eq2NPQK\nyWrW+cPY933m5uYAGBkZ4e3tjY+PDzzPs7ysMVNTU4yNjQHQ2dnJ19cXURSRzWYtL2vM/f09d3d3\nzv7A/5bv+0xPT+N5Hp7nsb29bXtSYqWpWfXqJvXaPOrVXWnpFZLVrPOvUgRBQHd398/nnp4eXl5e\nLC6KJ5vN0tbWBkC5XGZ2djax0QKUSiU2NjZsz4jt8fGR7+9v1tbWWFlZwfd925MSK03Nqlc3qdfm\nUa/uSkuvkKxmnX9i/Ke0/IP1+fk55XKZ4+Nj21Madnp6yvj4OENDQ7anNMXr6yt7e3s8PT2xurrK\nxcUFmUzG9qzES0Oz6tU96vX/oV7dkLZeITnNOn8Y9/X1EQTBz+fn52d6e3stLorv8vKSw8NDjo6O\n6OjosD2nYdVqlYeHB6rVKrVajdbWVgYGBpiZmbE97T/L5XJMTEzQ0tLC8PAw7e3t1Ot1crmc7WmJ\nk7Zm1at71GvzqFc3palXSFizxnHX19emWCwaY4y5ubkxhULB8qJ43t/fzeLiogmCwPaUptrZ2TGV\nSsX2jIbVajVTLBZNFEWmXq+bfD5voiiyPSuR0tSsenWTem0e9eq+pPdqTLKadf6J8eTkJKOjoxQK\nBTKZDFtbW7YnxXJ2dkYYhqyvr/98VyqVGBwctLhK+vv7WVhYYHl5GYDNzU1+/XL+FXwnpalZ9eom\n9do86lX+hSQ1mzEmBS8UiYiIiIjE5Oa5LiIiIiLyj+kwFhERERFBh7GIiIiICKDDWEREREQE0GEs\nIiIiIgLoMBYRERERAXQYi4iIiIgAOoxFRERERAD4DeSk1zeeZikeAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fafdfeb71d0>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "plt.subplot(131)\n",
    "plt.plot(history.epoch, history.history[\"loss\"], label=\"Train loss\")\n",
    "plt.plot(history.epoch, history.history[\"val_loss\"], label=\"Valid loss\")\n",
    "plt.legend()\n",
    "plt.subplot(132)\n",
    "plt.plot(history.epoch, history.history[\"acc\"], label=\"Train accuracy\")\n",
    "plt.plot(history.epoch, history.history[\"val_acc\"], label=\"Valid accuracy\")\n",
    "plt.legend()\n",
    "plt.subplot(133)\n",
    "plt.plot(history.epoch, history.history[\"mean_iou\"], label=\"Train iou\")\n",
    "plt.plot(history.epoch, history.history[\"val_mean_iou\"], label=\"Valid iou\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7dpxfbugzcLT"
   },
   "source": [
    "## Sample Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "c-eU6Le2zdtF"
   },
   "outputs": [],
   "source": [
    "THRESHOLD = 0.5\n",
    "# look at some sample predictions\n",
    "samples = np.random.choice(valid_filenames, size=8, replace=False)\n",
    "\n",
    "for filename in samples:\n",
    "    # load the image\n",
    "    img = pydicom.dcmread(os.path.join(train_dicom_dir, filename)).pixel_array\n",
    "    \n",
    "    filename = filename.split('.')[0]\n",
    "    \n",
    "    f, ax = plt.subplots(figsize=(6, 6))\n",
    "    plt.imshow(img)\n",
    "    # get boxes for the truth\n",
    "    if filename in pneumonia_locations:\n",
    "        locs = pneumonia_locations[filename]\n",
    "        for i in range(16):\n",
    "            for j in range(16):\n",
    "                pixel_data = locs[i,j,:]\n",
    "                if pixel_data[0] > 0:\n",
    "                    x, y, w, h = pixel_data[1:]\n",
    "                    x = int(x)\n",
    "                    y = int(y)\n",
    "                    w = int(w)\n",
    "                    h = int(h)\n",
    "                    rect = patches.Rectangle((x,y),w,h,linewidth=1,edgecolor='b',facecolor='none')\n",
    "                    ax.add_patch(rect)\n",
    "    \n",
    "    # predict the image\n",
    "    img = resize(img, (IMAGE_SIZE, IMAGE_SIZE), mode='reflect')\n",
    "    yhat = model.predict(img.reshape(1, IMAGE_SIZE, IMAGE_SIZE, 1))\n",
    "    \n",
    "    conf = np.squeeze(yhat[0])\n",
    "    bboxes = np.squeeze(yhat[1])\n",
    "    \n",
    "    # loop through our predictions\n",
    "    for i in range(16):\n",
    "        for j in range(16):\n",
    "            # if we have a prediction\n",
    "            if conf[i,j] > THRESHOLD:\n",
    "                x,y,w,h = bboxes[i,j,:]\n",
    "                x = int(x)\n",
    "                y = int(y)\n",
    "                w = int(w)\n",
    "                h = int(h)\n",
    "                rect = patches.Rectangle((x,y),w,h,linewidth=1,edgecolor='r',facecolor='none')\n",
    "                ax.add_patch(rect)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3tAntxescxUq"
   },
   "source": [
    "# Predict test images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "fnu7ebfScxUu",
    "outputId": "2e91d334-3204-4213-b74c-4c112b1c3512"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n test samples: 1000\n",
      "02743848-e50a-4faf-a3f4-a6215613a23d.dcm\n",
      "2bd26d4b-b499-49e8-ad56-a20232b01af3.dcm\n",
      "02ea47e2-e51d-4d4c-a2a2-41af99a91254.dcm\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/eric/.local/lib/python3.5/site-packages/skimage/transform/_warps.py:110: UserWarning: Anti-aliasing will be enabled by default in skimage 0.15 to avoid aliasing artifacts when down-sampling images.\n",
      "  warn(\"Anti-aliasing will be enabled by default in skimage 0.15 to \"\n"
     ]
    }
   ],
   "source": [
    "THRESHOLD = 0.5\n",
    "\n",
    "# load and shuffle filenames\n",
    "folder = './stage_1_test_images'\n",
    "test_filenames = os.listdir(folder)\n",
    "print('n test samples:', len(test_filenames))\n",
    "\n",
    "# create test generator with predict flag set to True\n",
    "test_gen = generator(folder, test_filenames, None, batch_size=3, image_size=IMAGE_SIZE, shuffle=False, predict=True)\n",
    "\n",
    "# create submission dictionary\n",
    "submission_dict = {}\n",
    "# loop through testset\n",
    "for imgs, filenames in test_gen:\n",
    "    \n",
    "    # predict batch of images\n",
    "    conf_preds, bbox_preds = model.predict(imgs)\n",
    "    \n",
    "    # loop through batch\n",
    "    for confs, bboxes, filename in zip(conf_preds, bbox_preds, filenames):\n",
    "        predictionString = \"\"\n",
    "        print(filename)\n",
    "        for i in range(16):\n",
    "            for j in range(16):\n",
    "                conf = confs[i, j, 0]\n",
    "                if conf > THRESHOLD:\n",
    "                    x, y, w, h = bboxes[i,j]\n",
    "                    \n",
    "                    # possible thresholds to keep our boxes within reasonable sizes?\n",
    "                    if True: #w < 600 and h < 1000:\n",
    "                        # cast to ints\n",
    "                        x = int(x)\n",
    "                        y = int(y)\n",
    "                        w = int(w)\n",
    "                        h = int(h)\n",
    "                        \n",
    "                        # make sure our boxes don't run off the edges of the images\n",
    "                        w = np.minimum(w, 1024 - x)\n",
    "                        h = np.minimum(h, 1024 - y)\n",
    "                        \n",
    "                        # create the prediction string\n",
    "                        predictionString += str(conf) + ' ' + str(x) + ' ' + str(y) + ' ' + str(w) + ' ' + str(h) + ' '\n",
    "\n",
    "        # add filename and predictionString to dictionary\n",
    "        filename = filename.split('.')[0]\n",
    "        submission_dict[filename] = predictionString\n",
    "\n",
    "    # stop if we've got them all\n",
    "    if len(submission_dict) >= len(test_filenames):\n",
    "        break\n",
    "    break\n",
    "    \n",
    "# save dictionary as csv file\n",
    "sub = pd.DataFrame.from_dict(submission_dict,orient='index')\n",
    "sub.index.names = ['patientId']\n",
    "sub.columns = ['PredictionString']\n",
    "\n",
    "now = datetime.datetime.now()\n",
    "today = str(now)[:10]\n",
    "submission_file = today + \"_yolo_submission.csv\" \n",
    "sub.to_csv(submission_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "U1NEg9QCcxU4",
    "outputId": "c7e7ccf3-3e94-4996-a07d-a1098b69f3ce"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully submitted to RSNA Pneumonia Detection Challenge"
     ]
    }
   ],
   "source": [
    "!kaggle competitions submit -c rsna-pneumonia-detection-challenge -f submission.csv -m \"YOLO 512x512 10 epochs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "NTQ_vDaVfvZR",
    "outputId": "a9eb81fb-572d-4236-b497-6bc44130aa89"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File ID: 1GGJOHEa4uJTtlo-cvF2NLYjCbKp6hq3_\n",
      "File ID: 1C7SXJVn51_rnrx8bU_1v8k-zeFhHybkJ\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'id': '1C7SXJVn51_rnrx8bU_1v8k-zeFhHybkJ'}"
      ]
     },
     "execution_count": 20,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "save_file_to_drive(\"submission.csv\", \"submission.csv\")\n",
    "save_file_to_drive(CHECKPOINT_PATH, CHECKPOINT_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 85
    },
    "colab_type": "code",
    "id": "yf06y04TVRi2",
    "outputId": "1ca39a9a-1aa6-4e2a-ec86-39a826c676dd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated property [core/project].\n",
      "Copying file://./model7_448.h5 [Content-Type=application/octet-stream]...\n",
      "|\n",
      "Operation completed over 1 objects/93.8 MiB.                                     \n"
     ]
    }
   ],
   "source": [
    "# upload checkpoint to GCS\n",
    "project_id = 'mammography-198911'\n",
    "bucket_name = 'pneumonia'\n",
    "\n",
    "!gcloud config set project {project_id}\n",
    "!gsutil cp ./{CHECKPOINT_PATH} gs://{bucket_name}/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Updated property [core/project].\r\n"
     ]
    }
   ],
   "source": [
    "# upload checkpoint to GCS\n",
    "project_id = 'mammography-198911'\n",
    "bucket_name = 'pneumonia'\n",
    "\n",
    "!gcloud config set project {project_id}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Copying file://./yolo_labels.p [Content-Type=text/x-pascal]...\r\n",
      "/ [0 files][    0.0 B/252.7 MiB]                                                \r",
      "==> NOTE: You are uploading one or more large file(s), which would run\r\n",
      "significantly faster if you enable parallel composite uploads. This\r\n",
      "feature can be enabled by editing the\r\n",
      "\"parallel_composite_upload_threshold\" value in your .boto\r\n",
      "configuration file. However, note that if you do this large files will\r\n",
      "be uploaded as `composite objects\r\n",
      "<https://cloud.google.com/storage/docs/composite-objects>`_,which\r\n",
      "means that any user who downloads such objects will need to have a\r\n",
      "compiled crcmod installed (see \"gsutil help crcmod\"). This is because\r\n",
      "without a compiled crcmod, computing checksums on composite objects is\r\n",
      "so slow that gsutil disables downloads of composite objects.\r\n",
      "\r\n",
      "ResumableUploadAbortException: 403 Insufficient Permission\r\n"
     ]
    }
   ],
   "source": [
    "!gsutil cp ./yolo_labels.p gs://{bucket_name}/"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "best_cnn_segmentation_connected_components_384x384_2.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}