Presentation Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identifying Pathology in Chest X-Rays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Business Justification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Improve medical diagnostic technology and make it more accessible (less need for physicians)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style id=hide>div.input{display:none;}</style><button type=\"button\"onclick=\"var myStyle = document.getElementById('hide').sheet;myStyle.insertRule('div.input{display:inherit !important;}', 0);\">Show inputs</button>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(r\"\"\"<style id=hide>div.input{display:none;}</style><button type=\"button\"onclick=\"var myStyle = document.getElementById('hide').sheet;myStyle.insertRule('div.input{display:inherit !important;}', 0);\">Show inputs</button>\"\"\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import os\n",
    "import random\n",
    "from glob import glob\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pylab as plt\n",
    "%matplotlib inline\n",
    "from ipywidgets import widgets,interact, interactive, fixed, interact_manual\n",
    "import numpy as np\n",
    "import keras \n",
    "from keras.preprocessing.image import img_to_array\n",
    "from keras.models import model_from_json\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from ipywidgets import widgets,interact, interactive, fixed, interact_manual\n",
    "from IPython.display import display, clear_output, Markdown, Image\n",
    "from ipywidgets.widgets.interaction import show_inline_matplotlib_plots\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.utils import class_weight\n",
    "from keras import optimizers\n",
    "from keras.callbacks import ModelCheckpoint, LearningRateScheduler, TensorBoard, EarlyStopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load json and create model\n",
    "balanced_mlp = open('balanced_mlp_model.json', 'r')\n",
    "balanced_mlp_json = balanced_mlp.read()\n",
    "balanced_mlp.close()\n",
    "balanced_mlp_model = model_from_json(balanced_mlp_json)\n",
    "# load weights into new model\n",
    "balanced_mlp_model.load_weights(\"balanced_mlp_model.h5\")\n",
    "\n",
    "# load json and create model\n",
    "ros_mlp = open('ros_mlp_model.json', 'r')\n",
    "ros_mlp_json = ros_mlp.read()\n",
    "ros_mlp.close()\n",
    "ros_mlp_model = model_from_json(ros_mlp_json)\n",
    "# load weights into new model\n",
    "ros_mlp_model.load_weights(\"ros_mlp_model.h5\")\n",
    "\n",
    "# load json and create model\n",
    "ros_cnn = open('ros_cnn.json', 'r')\n",
    "ros_cnn_json = ros_cnn.read()\n",
    "ros_cnn.close()\n",
    "ros_cnn_model = model_from_json(ros_cnn_json)\n",
    "# load weights into new model\n",
    "ros_cnn_model.load_weights(\"model.h5\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load npz file containing image arrays\n",
    "x_npz = np.load(\"x_images_arrays.npz\")\n",
    "x = x_npz['arr_0']\n",
    "# Load disease labels\n",
    "y_npz = np.load(\"y_disease_labels.npz\")\n",
    "y = y_npz['arr_0']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x,y, test_size=0.2)\n",
    "X_train_reshape = X_train.reshape(X_train.shape[0], -1).astype('float32')\n",
    "X_test_reshape = X_test.reshape(X_test.shape[0], -1).astype('float32')\n",
    "#one-hot encode y_train & y_test\n",
    "y_trainHot = keras.utils.to_categorical(y_train, 8)\n",
    "y_testHot = keras.utils.to_categorical(y_test, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ../input/\n",
    "PATH = os.path.abspath(os.path.join('input'))\n",
    "\n",
    "# ../input/sample/images/\n",
    "SOURCE_IMAGES = os.path.join(PATH, \"sample\", \"images\")\n",
    "\n",
    "# ../input/sample/images/*.png\n",
    "images = glob(os.path.join(SOURCE_IMAGES, \"*.png\"))\n",
    "\n",
    "# Load labels\n",
    "labels = pd.read_csv('input/sample_labels.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Process Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Exploratory data analysis \n",
    "* Feed-forward neural networks (MLP) with class weights and random over-sampling\n",
    "* Convolutional neural networks with class weights, random over-sampling, data augmentation\n",
    "* Transfer learning (vgg19) \n",
    "\n",
    "**Meta-Analysis**\n",
    "* Binary disease classification (disease Y/N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exploratory Data Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sample X-Ray Images by Disease"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Select a pathology to see a sample representative image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "003356043c714675bed1c9dc6f19a212",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='pathology', options=('Hernia', 'Pneumonia', 'Fibrosis', 'Edema', '…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<function __main__.generate_xray(pathology)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "infiltration = cv2.imread(os.path.join(SOURCE_IMAGES,'00030209_008.png'))\n",
    "no_finding = cv2.imread(os.path.join(SOURCE_IMAGES,'00000017_001.png'))\n",
    "atelectasis = cv2.imread(os.path.join(SOURCE_IMAGES,'00000030_001.png'))\n",
    "effusion = cv2.imread(os.path.join(SOURCE_IMAGES,'00000061_002.png'))\n",
    "mass = cv2.imread(os.path.join(SOURCE_IMAGES,'00000079_000.png'))\n",
    "consolidation = cv2.imread(os.path.join(SOURCE_IMAGES,'00030636_012.png'))\n",
    "pneumothorax = cv2.imread(os.path.join(SOURCE_IMAGES,'00022668_000.png'))\n",
    "hernia = cv2.imread(os.path.join(SOURCE_IMAGES,'00007352_000.png'))\n",
    "pneumonia = cv2.imread(os.path.join(SOURCE_IMAGES,'00028924_005.png'))\n",
    "fibrosis = cv2.imread(os.path.join(SOURCE_IMAGES,'00004048_012.png'))\n",
    "edema = cv2.imread(os.path.join(SOURCE_IMAGES,'00027782_002.png'))\n",
    "emphysema = cv2.imread(os.path.join(SOURCE_IMAGES,'00029981_002.png'))\n",
    "cardiomegaly = cv2.imread(os.path.join(SOURCE_IMAGES,'00029510_000.png'))\n",
    "pleural_thickening = cv2.imread(os.path.join(SOURCE_IMAGES,'00028505_012.png'))\n",
    "nodule = cv2.imread(os.path.join(SOURCE_IMAGES,'00030301_000.png'))\n",
    "\n",
    "#Peak Active time\n",
    "def check_pathology(pathology):\n",
    "    if pathology=='Infiltration':\n",
    "        return infiltration\n",
    "    elif pathology=='No Finding':\n",
    "        return no_finding\n",
    "    elif pathology=='Atelectasis':\n",
    "        return atelectasis\n",
    "    elif pathology=='Effusion':\n",
    "        return effusion\n",
    "    elif pathology=='Mass':\n",
    "        return mass\n",
    "    elif pathology=='Consolidation':\n",
    "        return consolidation\n",
    "    elif pathology=='Hernia':\n",
    "        return hernia\n",
    "    elif pathology=='Pneumonia':\n",
    "        return pneumonia\n",
    "    elif pathology=='Fibrosis':\n",
    "        return fibrosis\n",
    "    elif pathology=='Edema':\n",
    "        return edema\n",
    "    elif pathology=='Emphysema':\n",
    "        return emphysema\n",
    "    elif pathology=='Cardiomegaly':\n",
    "        return cardiomegaly\n",
    "    elif pathology=='Pleural Thickening':\n",
    "        return pleural_thickening\n",
    "    elif pathology=='Nodule':\n",
    "        return nodule\n",
    "    elif pathology=='Pneumothorax':\n",
    "        return pneumothorax\n",
    "    \n",
    "def generate_xray(pathology):\n",
    "    xray = check_pathology(pathology)\n",
    "    return plt.imshow(xray)\n",
    "interact(generate_xray, pathology=['Hernia', 'Pneumonia', 'Fibrosis', 'Edema', 'Emphysema', 'Cardiomegaly', \n",
    "                              'Pleural Thickening','Consolidation', 'Pneumothorax', 'Mass', 'Nodule', 'Atelectasis', \n",
    "                              'Effusion', 'Infiltration','No Finding'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Cleaning Dataset\n",
    "df = labels\n",
    "single = df[df['Finding Labels'].map(lambda x: \"|\" not in str(x))]\n",
    "multiple = df[df['Finding Labels'].map(lambda x: \"|\" in str(x))]\n",
    "# len(multiple[multiple['Finding Labels']=='Infiltration'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single vs. Multiple Pathologies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a854d5f98>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABGsAAAJcCAYAAABOhimyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzs3XuYlXW9///XixmOMk5ySFSEUU4DDA4EYRh4KC3dkVnoFsIMy/MuSGOXO7+pHTQNNDe5zdAUNULsKNvzz7Zi6DaDYOQgoCYqIMlJDjIiM/P+/bHucS/HGZiBGdY9w/NxXVxzr8/xfa/6o17X576XI0IAAAAAAABIh1a5LgAAAAAAAAD/h7AGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAMgB29fY/vVezp1h+8eNXdO+st3D9nbbeY203m22v59cn2h7dWOsm6w3yvaKxloPAACgMRHWAABQT7ZX2S5PAol/2r7Ldsd6zGvUoCEXbE+wXZnc+3bbryb337d6TES8HhEdI6KyHmvN29OeEXFxRPyokeoP272z1v5LRPRrjLUBAAAaG2ENAAAN8/mI6CjpY5I+Lun/5bie/el/k3svlHSypHJJC2yXNPZGjXU6BwAAoDkirAEAYC9ExBpJj0gqkSTb59l+0fY22/+wfVHSflAy7vCsUymHJ8u0sX1PMmep7WHV69vub/sp228nfafXVYvtC2y/bHuT7TlZ68v2Z2yvsL3F9q2259o+33bbZPygrLEfTU4Odd3DvVdGxCsRcamkuZKuSeYXJSdY8pPPE5LvYltyEme87f6SbpM0Ivku3k7GzrD9C9sP235H0km1Pe5l+3u2NySnnMZntT9l+/ysz++f3rH9dNJclux5ds3TTrv7vpM6/sv2Q8m9/NV2r919RwAAAPuCsAYAgL1g+0hJ/yJpYdL0lqTRkg6WdJ6kn9n+WES8I+k0SWuTR4Q6RsTaZM7pku6T9BFJcyTdkqzdWtJ/S3pc0kclfVPSTNsfemzH9qck/UTSv0o6TNJryZqy3UXS7yT9h6TOklZIOk6SImJnMu6crOXGSXoiItY34Kv4g6RRtdR1kKRpkk6LiIJk30UR8aKki5Wc0omIj2RN+7KkayUVSKrtMalukrpIOkLSVyVNr+07qSkijk8uS5M9Z9eotT7f9zhJP5B0iKSXkzoBAACaBGENAAAN86fkNMg8ZU6VXCdJEfFQctokImKuMv/H/0MhRg3zIuLh5B0v90oqTdo/IamjpOsj4r2I+B9JDyoTGNQ0XtKdEfH3JID5D2VOrRQpEyYtjYg/RESFMuHJuqy5d0v6su3q/z3wlaSOhlgrqVMdfVWSSmy3j4g3I2LpHtZ6ICKeiYiqiHi3jjHfj4idyXf8kDIh1b6qz/f9h4h4PvkeZ0oa3Aj7AgAA1IqwBgCAhjkjIj4SET0j4tKIKJck26fZfi55tOhtZYKSLntYKzs42SGpXfII0eGS3oiIqqz+15Q5UVLT4UmfJCkitkvamIw9XNIbWX0haXXW579KekfSCbaLJfVW5oRPQxwhaVPNxuRE0dnKnKJ5M3mEqHgPa72xh/7NybrVXlPmHvdVfb7vmv9Z7fHF0gAAAHuLsAYAgH1ku62k30uaKunQ5NGehyU5GRINXHKtpCOzTrxIUg9Ja+oY2zOrloOUeeRpjaQ3JXXP6nP258TdyjwK9RVJv9vNiZa6fFHSX2rriIjHIuIUZR7PWi7p9uquOtba0/d0SHJ/1Xooc/9SJnTqkNXXbQ9rZWvI9w0AANDkCGsAANh3bSS1lbReUoXt0yR9Jqv/n5I62y6s53rVJ16+Y7u17RMlfV7Ju2hq+I2k82wPTkKj6yT9NSJWKfOY0CDbZyQndv5NHw4x7lUmcDlH0j31Kc52nu2jbP9c0onKvMul5phDbZ+ehCs7JW2XVP2T3v+U1N12m/rsV8MPbLexPUqZdwT9NmlfJOlLtjs48xPdX68x75+Sjq5jzYZ83wAAAE2OsAYAgH0UEdskTZR0v6TNyrwod05W/3JJsyT9I/m1od0+uhMR7ynz8uHTJG2QdKukc5N1ao79s6TvK3Oy501JvSSNTfo2SDpL0k+VeTRqgKT5yoQn1fNXS/q7Mqdaaj0hk2WE7e2Stkp6SpmXKX88IhbXMraVpG8rc2plk6QTJF2a9P2PpKWS1tnesIc9s61T5vtdq8x7Yy7O+k5+Juk9ZUKZu5P+bNdIujv5/j/wnpuGfN8AAAD7gzOPrwMAgJYuecxntaTxEfFkVvudyvxa1f/LWXEAAAB4X36uCwAAAE3H9meVecynXNK/K/Meneey+oskfUnSkByUBwAAgFrwGBQAAC3bCEmvKPN4z+eV+TWr6l+w+pGkJZKmRMSruSsRAAAA2XgMCgAAAAAAIEU4WQMAAAAAAJAivLOmmenSpUsUFRXlugwAAAAAyIkFCxZsiIiuua5jTxYsWPDR/Pz8OySViIMS+KAqSUsqKirOHzp06Fu1DSCsaWaKioo0f/78XJcBAAAAADlh+7Vc11Af+fn5d3Tr1q1/165dN7dq1Yr3j+B9VVVVXr9+/YB169bdIen02saQ7gEAAAAA0PhKunbtupWgBjW1atUqunbtukWZU1e1j9mP9QAAAAAAcKBoRVCDuiT/3agzk+ExqGZm9bZNmjx3Vq7LAAAAANBCTT1hXK5LAA54hDUAAAAAADSxzfdNHdqY6x0ydvKCPY2xPfQLX/jCpj/96U+vStKuXbv00Y9+tHTw4MHvPPnkky/vbm6HDh2G7NixY+GKFSvaPPnkkx0vvvjiTZL09NNPd7jzzjs7z5gx44265q5YsaLN6NGj+7z00ktL63s/eXl5Q/v06VNeWVnp3r17l99///2rCgoKquoaf8UVV3S7/vrr1+3tfmPGjCkaPXr0lvPOO29zfedUmzlzZuHSpUvbX3fddesaOre+eAwKAAAAAIAWqH379lUrVqxov337dkvSH//4x4MPPfTQXQ1Z46WXXmo7e/bsTtWfjz/++B27C2r2Vtu2bauWL1++7KWXXlraunXruPHGG3f7i1/Tpk07rLFrqK/x48dvacqgRiKsAQAAAACgxfr0pz+95be//e1HJGnWrFmdxowZs6m67/LLLz/8qquuOrT6c58+fQauWLGiTfb8K6+88oj58+d3LC4uHvCDH/zgow8++GDBSSed1Lt6/hlnnHHUJz7xib49e/YsufHGG7vU3L+iokIXXXRR95KSkv59+/YdMGXKlA+NqWnkyJHbX3755baSdPLJJ/caOHBg/969ew+cOnVqF0m69NJLj9i5c2er4uLiAaeffvpRklRZWamxY8f27N2798BPfvKTfaoDqmeffbZ9aWlpcd++fQeccsopvdavX59Xc78HHnigoH///gP69u074KyzzioqLy+3JM2ePbvwqKOOGjh06NB+EyZMOLL6vqdNm9b53HPP7SFJa9euzf/sZz/bq6SkpH9JSUn/xx9//CBJeuihhzoWFxcPKC4uHtC/f/8BmzdvblD+QlgDAAAAAEAL9ZWvfGXT7NmzD9mxY4dffPHFDiNGjHinIfOvvfbaNcOGDdu+fPnyZVdfffVbNftffPHF9k888cRLzz333PIpU6YcvmrVqtbZ/TfffHOXwsLCyiVLlrxYVlb24t133911+fLlbWquU23Xrl167LHHDh40aFC5JM2cOXPV0qVLX1y0aNGyX/7yl4euW7cu79Zbb11TfRJnzpw5r0rS66+/3m7ixIlvvfzyy0sLCwsr77nnnkMkacKECUddd911q1euXLls4MCB5d/97ncPz95vx44dvuiii46aPXv2KytXrlxWUVGhKVOmdN2xY4cnTZrU85FHHnlpwYIFKzZu3Fjra2QuuuiiIy+//PJ/Llmy5MU//vGPr1x88cVFknTjjTd2mzZt2mvLly9f9txzzy3v2LFjnY901YawBgAAAACAFurYY48tX716ddvbb7+908knn7ylsdc/7bTT3u7YsWMcdthhFSNGjNj6l7/85aDs/ieeeOLg+++/v3NxcfGAIUOG9N+8eXP+smXL2tVcp/qkzKBBgwZ07979vUmTJm2QpBtuuOHQfv36DRg6dGj/devWtV66dOmH5krSEUccsfO4444rl6QhQ4bsWLVqVduNGzfmbdu2Le9zn/vcdkm64IILNj733HMds+eVlZW16969+85jjjlmpyRNmDBh47x58woWLVrU7sgjj9xZXFz8niSNHTt2U809JemZZ545eNKkST2Ki4sHfP7zn++9ffv2vM2bN7f6xCc+sX3y5MlH/vjHP/7ohg0b8lq3bl3b9DrxgmEAAAAAAFqwU0899e2rr776yMcff3zFW2+99X4OkJ+fH1VV/3fgY+fOnW7o2rZ3+zkifOONN74+ZsyYrbtbp/qkTHbbgw8+WDB37tyC+fPnLy8oKKgaPnx4v/Ly8loPnbRp0+b9n0nPy8uLusbVFFH7r6vX1V7buPnz57/YsWPHD0y47rrr1p1xxhlbHnjggcLjjjuu/6OPPrpyyJAh79ZrUXGyBgAAAACAFu2SSy7Z8O1vf3vt8OHDy7Pbi4qKdi5atOggSZo3b16HNWvWtK05t7CwsHL79u0fes9LtUceeeQjO3bs8Lp16/Kee+65gpEjR37gMatTTjllyy9+8Yuu1UHQCy+80Hbr1q31yiLefvvtvMLCwsqCgoKqhQsXtisrK3v/1E5+fn7sKVzq3Llz5cEHH1z56KOPdpSkX/3qV51HjBixPXvM4MGD312zZk2bJUuWtJWke+65p/OoUaO2lZaWvvvGG2+0rX6HT/ZLlrONHDly6w033PDR6s/PPvtse0launRp2+HDh5dfe+216wYNGvTOkiVLaj0RVBdO1gAAAAAA0MTq81PbTaVXr167vv/973/ofTPnnnvu5pkzZ3YuLi4eMHjw4Hd69uz5oZMfw4cPL8/Pz49+/foN+PKXv7xh6NChHwh8hgwZ8s6nP/3pPmvXrm0zefLkN4uKinZlv6T4sssu27Bq1aq2gwYN6h8R7tSp066HH374lfrUPWbMmC3Tp0/v2rdv3wG9evV6t7S09P0gaPz48ev79+8/oKSkZMeUKVPW1LXGXXfd9eoll1zSc+LEia169Oixc9asWauy+zt06BC33XbbqrPOOqtXZWWlSktLd0yePHl9+/bt46abbnrt1FNP7dOpU6eKIUOG1Pqun+nTp79x/vnn9+jbt++AyspKH3vssduOO+6413/6059+9Nlnnz24VatW0bdv3/IzzzyzQY+gub5He5AO3fodHedMvzbXZQAAAABooaaeMC7XJeyW7QURMSzXdexJWVnZqtLS0g25rqMpXX755Yd37Nix8oc//OE/c11LU9iyZUurwsLCqqqqKp177rk9+vTp825tL1neW2VlZV1KS0uLauvjMSgAAAAAAIAabr755i7FxcUD+vTpM3Dr1q15l19++X4L31rEY1C2Q9JNEfHt5PNkSR0j4pp6zp8gaYqk6qNTL0TEubZ/KOnpiHiiAbWskjQsIjbYfjYijqv/nQAAAAAA0DzcdNNNa3NdQ1O6+uqr32rMkzQN0SLCGkk7JX3J9k8iYm+TrtkR8Y3shoi4al+KIqgBAAAAAAAN1VIeg6qQNF3SZTU7bPe0/WfbLyR/e9R3UdszbJ+ZXK+y/QPbf7e92HZx0t7Z9uO2F9r+pSRnzd+e/D3R9lO2f2d7ue2ZTn7PzPa/JG3zbE+z/eA+fRMAAAAAAKBZaylhjST9l6TxtgtrtN8i6Z6IOEbSTEnT6ph/tu1Fyb/z6hizISI+JukXkiYnbVdLmhcRQyTNkVRXGDRE0rckDZB0tKRP2m4n6ZeSTouIkZK61jbR9oW259uev2PLtjqWBwAAAAAALUGLCWsiYqukeyRNrNE1QtJvkut7JY2sY4nZETE4+XdXHWP+kPxdIKkouT5e0q+TGh6StLmOuc9HxOqIqJK0KJlfLOkfEfFqMmZWbRMjYnpEDIuIYR0KC+pYHgAAAAAAtAQt5Z011W6W9HdJdYUtkrQvv1W+M/lbqQ9+d/VZc2fWdfV81zEWAAAAANCCTJ47a2hjrjf1hHEL9jTmu9/9brff//73nVu1ahWtWrXSrbfe+tqnPvWpd84+++ye3/nOd/45dOjQdxu674oVK9qMHj26z0svvbS0vnPy8vKG9unTp7yystK9e/cuv//++1cVFBRU1TX+iiuu6Hb99dev29v9xowZUzR69Ogt5513Xl2HKVKvxZyskaSI2CTpfklfz2p+VtLY5Hq8pHmNvO3TybqyfZqkQxowd7mko20XJZ/PbtTKAAAAAAAHpCeeeOKgxx577COLFy9etnLlymVPPvnkyqOPPvo9SZo9e/ZrexPU7K22bdtWLV++fNlLL720tHXr1nHjjTfW+gqQatOmTTtsf9WWVi0qrEncKKlL1ueJks6z/YKkr0ia1Mj7/UDS8bb/Lukzkl6v78SIKJd0qaRHbc+T9E9JWxq5PgAAAADAAWbNmjWtO3XqVNG+ffuQpMMOO6yiqKholyQNHz6839NPP91Bkjp06DDkm9/85hH9+vUbUFpaWvzGG2/kS9LSpUvblpaWFpeUlPT/1re+dXiHDh2G1NyjoqJCF110UfeSkpL+ffv2HTBlypQuNcfUNHLkyO0vv/xyW0k6+eSTew0cOLB/7969B06dOrWLJF166aVH7Ny5s1VxcfGA008//ShJqqys1NixY3v27t174Cc/+ck+27dvtyQ9++yz7UtLS4v79u074JRTTum1fv36vJr7PfDAAwX9+/cf0Ldv3wFnnXVWUXl5uSVp9uzZhUcdddTAoUOH9pswYcKRJ510Uu/Kykr17NmzZO3atfnV+/bo0aPkzTff3O9PJbWIsCYiOmZd/zMiOkTENcnnVRHxqYg4JiI+HREfClMiYkbNn+1O2idExO+S66LqnwWPiPkRcWJyvTEiPhMRH4uIyyKiZ9a4jsnfpyJidNa634iIGcnHJyOiWNIoSe0kzW+ErwQAAAAAcAA744wztq5du7ZNUVFRyTnnnNPjoYce6ljbuPLy8lYjRozYvmLFimUjRozY/vOf/7yrJH3jG9848tJLL31ryZIlLx5++OG7apt78803dyksLKxcsmTJi2VlZS/efffdXZcvX96mrpp27dqlxx577OBBgwaVS9LMmTNXLV269MVFixYt++Uvf3nounXr8m699dY11Sdx5syZ86okvf766+0mTpz41ssvv7y0sLCw8p577jlEkiZMmHDUddddt3rlypXLBg4cWP7d73738Oz9duzY4Ysuuuio2bNnv7Jy5cplFRUVmjJlStcdO3Z40qRJPR955JGXFixYsGLjxo35kpSXl6czzzxz4x133NFJkh544IGD+/fvX37YYYdVNPw/gX3TIsKaZu4C24skLZVUqMyvQwEAAAAAsNcKCwurlixZsuyWW255rWvXrhVf/epXe02bNq1zzXGtW7eOsWPHbpGkoUOHvvPaa6+1kaSFCxd2/NrXvrZJks4///yNte3xxBNPHHz//fd3Li4uHjBkyJD+mzdvzl+2bFm7muOqT8oMGjRoQPfu3d+bNGnSBkm64YYbDu3Xr9+AoUOH9l+3bl3rpUuXfmiuJB1xxBE7jzvuuHJJGjJkyI5Vq1a13bhxY962bdvyPve5z22XpAsuuGDjc88994FAqqysrF337t13HnPMMTslacKECRvnzZtXsGjRonZHHnnkzuLi4vckaezYsZuq51xyySUb7rvvvs6SdOedd3aZMGHChj19102hpb1guNmJiJ9J+lmu6wAAAAAAtCz5+fkaPXr0ttGjR2875phjyu+9997OEydO3FhjTLRq1er98RUVFfX+IZyI8I033vj6mDFjtu5uXPVJmey2Bx98sGDu3LkF8+fPX15QUFA1fPjwfuXl5bUeKGnTps37P+qTl5cXdY2rpb4GtUtS7969d3Xp0qVizpw5BQsXLjzoT3/60z/qs1dj42QNAAAAAAAtTFlZWdvFixe3rf68cOHC9t27d3+vvvMHDx68fcaMGYdI0p133tmptjGnnHLKll/84hddd+7caUl64YUX2m7durVeOcPbb7+dV1hYWFlQUFC1cOHCdmVlZQdV9+Xn50f1mnXp3Llz5cEHH1z56KOPdpSkX/3qV51HjBixvcY9vLtmzZo2S5YsaStJ99xzT+dRo0ZtKy0tffeNN95ou2LFijaSNHv27A/c39e+9rX1559//lGnn376pvz83Jxx4WQNAAAAAABNrD4/td2Ytm7dmjdx4sQeW7duzcvLy4uioqKdd99992v1nf/zn//8jfHjxx81bdq0bp/5zGfe7tixY2XNMZdddtmGVatWtR00aFD/iHCnTp12Pfzww6/UZ/0xY8ZsmT59ete+ffsO6NWr17ulpaXvVPeNHz9+ff/+/QeUlJTsmDJlypq61rjrrrteveSSS3pOnDixVY8ePXbOmjVrVXZ/hw4d4rbbblt11lln9aqsrFRpaemOyZMnr2/fvn3cdNNNr5166ql9OnXqVDFkyJB3sueNGzduyze+8Y28Cy+8sNbHv/YH7+74D9KnW7+j45zp1+a6DAAAAAAt1NQTxuW6hN2yvSAihuW6jj0pKytbVVpampP3nTSGbdu2tTrooIOqWrVqpenTpx8ye/bsTn/+85/rFcQ0B1u2bGlVWFhYVVVVpXPPPbdHnz593r366qvfkqSnn366w2WXXXbkggULVjRlDWVlZV1KS0uLauvjZA0AAAAAAPiAZ555psOkSZN6RIQOPvjgyhkzZqzKdU2N6eabb+4ya9asLrt27fLAgQN3XH755Rsk6Xvf+163GTNmdL3rrrtezWV9nKxpZjhZAwAAAKApcbKmcTT3kzVoers7WcMLhgEAAAAAaHxVVVVV9f5lJRxYkv9uVNXVT1gDAAAAAEDjW7J+/fpCAhvUVFVV5fXr1xdKWlLXGN5Z08x0L+iU+mOJAAAAAHCgq6ioOH/dunV3rFu3rkQclMAHVUlaUlFRcX5dAwhrAAAAAABoZEOHDn1L0um5rgPNE+keAAAAAABAihDWAAAAAAAApAhhDQAAAAAAQIoQ1gAAAAAAAKQIYQ0AAAAAAECK8GtQzczqbZs0ee6sXJfRKK58c02uS0ATOGTs5FyXAAAAAADNGidrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAAAAAABSpEWENba/aDtsFyefi2x/uR7zimwv2cs9J9g+fC/nnm77ir2ZCwAAAAAAWrYWEdZIGidpnqSxyeciSXsMa/bRBEl7FdZExJyIuL5xywEAAAAAAC1Bsw9rbHeU9ElJX9f/hTXXSxple5Hty2zn2Z5i+2+2X7B9US3r1DnG9ndsL7ZdZvt622dKGiZpZrJHe9tXJXOX2J5u28ncibaXJWvel7RNsH1Lcn1WMqfM9tNN+mUBAAAAAIDUy891AY3gDEmPRsRK25tsf0zSFZImR8RoSbJ9oaQtEfFx220lPWP7cUmRtc7X6xhTnOxxbETssN0pIjbZ/kayx/xkj1si4ofJ9b2SRkv676SWoyJip+2P1FL/VZI+GxFr6uivrv9CSSo4tMu+fFcAAAAAACDlmv3JGmUegbovub4v+VzTZySda3uRpL9K6iypTz3HnCzprojYIUkRsamOOk6y/VfbiyV9StLApP0FZU7gnCOpopZ5z0iaYfsCSXm1LRwR0yNiWEQM61BYUMf2AAAAAACgJWjWJ2tsd1YmGCmxHcqEHSHp4ZpDJX0zIh6rMb+oHmNO1QdP4NRWRztJt0oaFhFv2L5GUruk+3OSjpd0uqTv2x6YPTciLrZ9bDJuke3BEbFxd/sBAAAAAICWq7mfrDlT0j0R0TMiiiLiSEmvSqqSlH0E5TFJl9huLUm2+9o+qMZadY15XNLXbHdI2jsl47dl7VEdzGxI3qFzZjK2laQjI+JJSd+R9BFJHbM3td0rIv4aEVdJ2iDpyH34PgAAAAAAQDPXrE/WKPPIU81fVfq9Mi8arrBdJmmGpP9U5hei/p68+He9Mu+hyXZHbWMi4lHbgyXNt/2eMqd2vpese5vtckkjJN0uabGkVZL+lqyZJ+nXtguVObnzs4h4O3n3cLUptvsk/X+WVLaX3wUAAAAAAGgBHLHbJ3yQMt36HR3nTL8212U0iivfXJPrEtAEDhk7OdclAAAAoAWzvSAihuW6DqApNffHoAAAAAAAAFoUwhoAAAAAAIAUIawBAAAAAABIEcIaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUyc91AWiY7gWdNPWEcbkuAwAAAAAANBFO1gAAAAAAAKQIYQ0AAAAAAECKENYAAAAAAACkCGENAAAAAABAihDWAAAAAAAApAhhDQAAAAAAQIrw093NzOptmzR57qxcl9GornxzTa5LaNYOGTs51yUAAAAAABoRJ2sAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFLkgA1rbFfaXpT174qkfZTtpUlbe9tTks9T9mKPh21/pPGrBwAAAAAALVV+rgvIofKIGFxL+3hJUyPiLkmyfZGkrhGxs6EbRMS/7GONAAAAAADgAHPAnqypje3zJf2rpKtsz7Q9R9JBkv5q+2zbM2yfmTV+e/L3MNtPJ6dxltgelbSvst0lub486Vti+1tJW5HtF23fnpzeedx2+/193wAAAAAAID0O5JM17W0vyvr8k4i4w/ZISQ9GxO+kTCBTfQLH9ml1rPVlSY9FxLW28yR1yO60PVTSeZKOlWRlwp+5kjZL6iNpXERcYPt+SWMk/brG/AslXShJBYd22aebBgAAAAAA6XYLm6HOAAAgAElEQVQghzV1PQa1N/4m6U7brSX9KSIW1egfKemPEfGOJNn+g6RRkuZIejVr/AJJRTUXj4jpkqZLUrd+R0cj1QwAAAAAAFKIx6AapkLJd2bbktpIUkQ8Lel4SWsk3Wv73BrzvJs1s9+FU6kDO0ADAAAAAOCAR1jTMKskDU2uvyCptSTZ7inprYi4XdKvJH2sxrynJZ1hu4PtgyR9UdJf9kvFAAAAAACgWTmQT3HUfGfNoxFxxR7m3C7pAdvPS/qzpHeS9hMl/bvtXZK2S/rAyZqI+LvtGZKeT5ruiIiFtov26Q4AAAAAAECL4whegdKcdOt3dJwz/dpcl9GornxzTa5LaNYOGTs51yUAAAAA+43tBRExLNd1AE2Jx6AAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAAAAAABShLAGAAAAAAAgRfJzXQAapntBJ009YVyuywAAAAAAAE2EkzUAAAAAAAApQlgDAAAAAACQIoQ1AAAAAAAAKUJYAwAAAAAAkCKENQAAAAAAAClCWAMAAAAAAJAihDUAAAAAAAApkp/rAtAwq7dt0uS5s5p8nyvfXNPke+TSIWMn57oEAAAAAABqxckaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUIawBAAAAAABIEcIaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwpq9YDts35v1Od/2etsP5rIuAAAAAADQ/BHW7J13JJXYbp98PkXSmhzWAwAAAAAAWgjCmr33iKTPJdfjJM2q7rA93Pazthcmf/sl7QNtP297ke0XbPexfZDth2yX2V5i++wc3AsAAAAAAEgJwpq9d5+ksbbbSTpG0l+z+pZLOj4ihki6StJ1SfvFkv4zIgZLGiZptaRTJa2NiNKIKJH0aM2NbF9oe77t+Tu2bGu6OwIAAAAAADlHWLOXIuIFSUXKnKp5uEZ3oaTf2l4i6WeSBibt/yvpe7a/K6lnRJRLWizpZNs32B4VEVtq2Wt6RAyLiGEdCgua6I4AAAAAAEAaENbsmzmSpirrEajEjyQ9mZyU+bykdpIUEb+RdLqkckmP2f5URKyUNFSZ0OYntq/aX8UDAAAAAID0yc91Ac3cnZK2RMRi2ydmtRfq/144PKG60fbRkv4REdOS62NsL5e0KSJ+bXt79ngAAAAAAHDgIazZBxGxWtJ/1tL1U0l3275c0v9ktZ8t6RzbuyStk/RDSR+XNMV2laRdki5p2qoBAAAAAECaEdbshYjoWEvbU5KeSq7/V1LfrO7vJ+0/kfSTGlMfS/4BAAAAAADwzhoAAAAAAIA0IawBAAAAAABIEcIaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUIawBAAAAAABIEcIaAAAAAACAFMnPdQFomO4FnTT1hHG5LgMAAAAAADQRTtYAAAAAAACkCGENAAAAAABAihDWAAAAAAAApAhhDQAAAAAAQIoQ1gAAAAAAAKQIYQ0AAAAAAECK8NPdzczqbZs0ee6sRlnryjfXNMo6aXXI2Mm5LgEAAAAAgAbjZA0AAAAAAECKENYAAAAAAACkCGENAAAAAABAihDWAAAAAAAApAhhDQAAAAAAQIoQ1gAAAAAAAKQIYQ0AAAAAAECKENYAAAAAAACkCGENAAAAAABAihDWAAAAAAAApEiqwhrb3WzfZ/sV28tsP2y7bxPveY3tycn1D22fXMuYE20/uId1Btv+l6zPp9u+ovErBgAAAAAALVl+rguoZtuS/ijp7ogYm7QNlnSopJX7o4aIuGofpg+WNEzSw8lacyTNaYy6AAAAAADAgSNNJ2tOkrQrIm6rboiIRZLm2Z5ie4ntxbbPlt4/7fKU7d/ZXm57ZhL4yPb1ycmcF2xPTdp62v5z0vZn2z1qFmB7hu0zk+tTk3XnSfpS1pjhtp+1vTD52892G0k/lHS27UW2z7Y9wfYtu9s72W9ass4/qvcGAAAAAAAHrjSFNSWSFtTS/iVlTq2USjpZ0hTbhyV9QyR9S9IASUdL+qTtTpK+KGlgRBwj6cfJ2Fsk3ZO0zZQ0ra5CbLeTdLukz0saJalbVvdyScdHxBBJV0m6LiLeS65nR8TgiJhdY8nd7X2YpJGSRku6vo56LrQ93/b8HVu21VU2AAAAAABoAdIU1tRlpKRZEVEZEf+UNFfSx5O+5yNidURUSVokqUjSVknvSrrD9pck7UjGjpD0m+T63mTduhRLejUiXoqIkPTrrL5CSb+1vUTSzyQNrMc97G7vP0VEVUQsU+aRrw+JiOkRMSwihnUoLKjHdgAAAAAAoLlKU1izVNLQWtq9mzk7s64rJeVHRIWk4ZJ+L+kMSY/WMTf2UE9d/T+S9GRElChz8qbdHtbZ09rZ97C7ewUAAAAAAAeANIU1/yOpre0Lqhtsf1zSZmXeBZNnu6uk4yU9X9citjtKKoyIh5V5RGpw0vWspLHJ9XhJ83ZTy3JJR9nulXwel9VXKGlNcj0hq32bpLqOvTRkbwAAAAAAcABLTViTPG70RUmnJD/dvVTSNco8PvSCpDJlAp3vRMS63SxVIOlB2y8o88jUZUn7REnnJe1fkTRpN7W8K+lCSQ8lLxh+Lav7p5J+YvsZSXlZ7U9KGlD9guEaS9Z7bwAAAAAAcGBzJiNBc9Gt39FxzvRrG2WtK99cs+dBzdghYyfnugQAAAAAjcz2gogYlus6gKaUmpM1AAAAAAAAIKwBAAAAAABIFcIaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUIawBAAAAAABIEcIaAAAAAACAFMnPdQFomO4FnTT1hHG5LgMAAAAAADQRTtYAAAAAAACkCGENAAAAAABAihDWAAAAAAAApAhhDQAAAAAAQIoQ1gAAAAAAAKQIYQ0AAAAAAECK8NPdzczqbZs0ee6s/b7vlW+u2e97NtQhYyfnugQAAAAAAPYZJ2sAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFIkJ2GN7Urbi2wvsf1b2x1yUUddbJ9he0DW56dsD8tlTQAAAAAA4MCQq5M15RExOCJKJL0n6eIc1VGXMyQN2OOoerCd3xjrAAAAAACAA0MaHoP6i6Tetotsv2j7dttLbT9uu70k2e5l+1HbC2z/xXZx0j7D9pnVC9nenvw90fZc2/fbXmn7etvjbT9ve7HtXsm4nrb/bPuF5G8P28dJOl3SlOT0T69k+bOS+Sttj0rmt7N9V7LmQtsnJe0TkhND/y3pcdsdk/X/noz9QjLu48ne7WwflNx3yX751gEAAAAAQCrlNKxJTp2cJmlx0tRH0n9FxEBJb0sak7RPl/TNiBgqabKkW+uxfKmkSZIGSfqKpL4RMVzSHZK+mYy5RdI9EXGMpJmSpkXEs5LmSPr35PTPK8nY/GT+tyRdnbT9myRFxCBJ4yTdbbtd0jdC0lcj4lOS3pX0xYj4mKSTJN1o2xHxt2SvH0v6qaRfR8SSWr6nC23Ptz1/x5Zt9bh1AAAAAADQXOXqEZ32thcl13+R9CtJh0t6NSKq2xdIKrLdUdJxkn5ru3p+23rs8beIeFOSbL8i6fGkfbEygYmUCVS+lFzfq0xgUpc/ZNeVXI+U9HNJiojltl+T1Dfp+/8iYlNybUnX2T5eUpWkIyQdKmmdpB9K+psygc7E2jaOiOnKBFbq1u/o2N1NAwAAAACA5i1XYU15RAzObkiCmJ1ZTZWS2itz+uftmuMTFUm/nFmgTVZf9lpVWZ+rVPd97y4IqZ5fmTXfdYyVpHeyrsdL6ippaETssr1KUvUJnE6SOkpqnbRlzwMAAAAAAAeYNLyzZrciYqukV22fJWVCGdulSfcqSUOT6y8oE3g0xLOSxibX4yXNS663SSqox/ynk3my3VdSD0krahlXKOmtJKg5SVLPrL7pkr6vzGNYNzSwfgAAAAAA0MKkPqxJjJf0ddtlkpYqE8xI0u2STrD9vKRj1fBTKRMlnWf7BWXeazMpab9P0r8nLw3uVefszLtz8mwvljRb0oSI2FnLuJmShtmen9zLckmyfa6kioj4jaTrJX3c9qcaeA8AAAAAAKAFcQSvQGlOuvU7Os6Zfu1+3/fKN9fs9z0b6pCxk3NdAgAAAIAmZntBRAzLdR1AU2ouJ2sAAAAAAAAOCIQ1AAAAAAAAKUJYAwAAAAAAkCKENQAAAAAAAClCWAMAAAAAAJAihDUAAAAAAAApQlgDAAAAAACQIoQ1AAAAAAAAKZKf6wLQMN0LOmnqCeNyXQYAAAAAAGginKwBAAAAAABIEcIaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAU4ae7m5nV2zZp8txZexx35Ztr9kM1Te+QsZNzXQIAAAAAAPsVJ2sAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFLkgA9rbFfaXpT1r8j2MNvTkv5rbE9ugn3vsD2gsdcFAAAAAADNW36uC0iB8ogYXKNtlaT59V3Adl5EVDZk04g4vyHjAQAAAADAgeGAP1lTG9sn2n4wq6nU9v/Yfsn2BVljnrT9G0mLk7bLbS9J/n0raTvI9kO2y5L2s5P2p5ITPHm2ZyR9i21ftr/vFwAAAAAApAcna6T2thcl169GxBdrGXOMpE9IOkjSQtsPJe3DJZVExKu2h0o6T9Kxkizpr7bnSjpa0tqI+Jwk2S6ssfZgSUdEREnS/5Gam9u+UNKFklRwaJe9v1MAAAAAAJB6nKxJHoNK/tUW1EjSAxFRHhEbJD2pTEgjSc9HxKvJ9UhJf4yIdyJiu6Q/SBqlzKmbk23fYHtURGypsfY/JB1t++e2T5W0tebmETE9IoZFxLAOhQX7eLsAAAAAACDNCGvqJ+r4/E5Wm2udGLFS0lBlQpuf2L6qRv9mSaWSnpL0b5LuaIR6AQAAAABAM0VYUz9fsN3OdmdJJ0r6Wy1jnpZ0hu0Otg+S9EVJf7F9uKQdEfFrSVMlfSx7ku0uklpFxO8lfb9mPwAAAAAAOLDwzpr6eV7SQ5J6SPpRRKy13Td7QET83faMZKwk3RERC21/VtIU21WSdkm6pMbaR0i6y3Z1cPYfTXUTAAAAAAAg/Q74sCYiOtbS9pQyjyUpIq6pY977Y7LabpJ0U422xyQ9Vsv8E7M+cpoGAAAAAABI4jEoAAAAAACAVCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUIawBAAAAAABIEcIaAAAAAACAFCGsAQAAAAAASJH8XBeAhule0ElTTxiX6zIAAAAAAEAT4WQNAAAAAABAihDWAAAAAAAApAhhDQAAAAAAQIoQ1gAAAAAAAKQIYQ0AAAAAAECKENYAAAAAAACkCGENAAAAAABAiuTnugA0zOptmzR57qxcl4GUmHrCuFyXAAAAAABoZJysAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUIawBAAAAAABIEcIaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUaTFhje3t9RgzyvZS24tsH2H7d0n7ibYfzLo+bi/2H2z7X7I+n277ioauAwAAAAAADmwtJqypp/GSpkbE4IhYExFn1jLmREm1hjW283ez9mBJ74c1ETEnIq7fl2IBAAAAAMCBZ3fhQ7Nk+0RJ10jaIKlE0gJJ50j6uqR/lfRZ2ydLulLSgxFRkjW3SNLFkiptnyPpm8m8TZKGSPq77dmSbpbUXlK5pPMkvSrph5La2x4p6SdJ/7CI+IbtnpLulNRV0npJ50XE67ZnSNoqaZikbpK+ExG/a4rvBQAAAAAANA8tLqxJDJE0UNJaSc9I+mRE3JEEKQ9GxO+SYOYDImKV7dskbY+IqZJk++uS+ko6OSIqbR8s6fiIqEhCn+siYoztq5SEM8m8CVlL3yLpnoi42/bXJE2TdEbSd5ikkZKKJc2R9KGwxvaFki6UpIJDu+zL9wIAAAAAAFKupT4G9XxErI6IKkmLJBXt43q/jYjK5LpQ0m9tL5H0M2VCoT0ZIek3yfW9yoQz1f4UEVURsUzSobVNjojpETEsIoZ1KCzYuzsAAAAAAADNQksNa3ZmXVdq308QvZN1/SNJTyaPT31eUru9WC+yrrNr9V6sBQAAAAAAWpCWGtbsi22Sdnd8pVDSmuR6Qj3nPStpbHI9XtK8fagPAAAAAAC0YIQ1H/bfkr6Y/Lz3qFr6fyrpJ7afkZSX1f6kpAHJvLNrzJko6TzbL0j6iqRJTVE4AAAAAABo/hwRex6F1OjW7+g4Z/q1uS4DKTH1hHG5LgEAAADYr2wviIhhua4DaEqcrAEAAAAAAEgRwhoAAAAAAIAUIawBAAAAAABIEcIaAAAAAACAFCGsAQAAAAAASBHCGgAAAAAAgBQhrAEAAAAAAEgRwhoAAAAAAIAUyc91AWiY7gWdNPWEcbkuAwAAAAAANBFO1gAAAAAAAKQIYQ0AAAAAAECKENYAAAAAAACkCGENAAAAAABAihDWAAAAAAAApAhhDQAAAAAAQIoQ1gAAAAAAAKRIfq4LQMOs3rZJk+fOqtfYK99c08TVZBwydvJ+2QcAAAAAgAMBJ2sAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEUIawAAAAAAAFKEsAYAAAAAACBFCGsAAAAAAABShLAGAAAAAAAgRQhrAAAAAAAAUoSwBgAAAAAAIEXyc11AfdiulLQ4q+m+iLi+EdbdHhEd93UdAAAAAACAxtIswhpJ5RExONdFAAAAAAAANLVm/RiU7VW2r7P9v7bn2/6Y7cdsv2L74mTMibaftv1H28ts32a7VdYa19ous/2c7UNtF/j/b+/ewywryzth/57QKCAdDtGIBhU1ihIPjTQEoxFMjBNNMoyGfEDwgOMn8RuPyfQ4zpBMMMaMk+A4UaIGE4NkFBUVo35eilFBMHKUtjmo0QiZQBiNg5I2IAo888dehZuiqqmiq6lVVfd9XXXttd71rrWeVft1V/PzXWtXXVVVOw/bf3Q4z85V9fLhGFuq6j3D9vtU1Tuq6qKqurSqjhjaj6uqD1XVR4bjvbSqfmvoc35V7T30e9Gw7xer6gNVtds9/5sEAAAAxmKlhDW7VtXmqZ+jprb9Q3c/Mcm5SU5NcmSSQ5P83lSfQ5L8+ySPTfLwJM8e2u+T5PzufnySzyZ5UXdvTXJ2kl8a+hyd5APd/YMkr05yYHc/LsmLh+0nJPl0dx+c5KlJ/qiq7jNse0ySXx/O/7okN3b3gUk+n+R5Q58PdvfBQw1fSvLC2RdfVccPYdTFN96wdeG/NQAAAGDFWSlhzU3dvWHq571T2z48vF6W5ILu3trd/5Tke1W157Dtwu7+enffmuT0JE8e2r+f5KPD8iVJ9huW/yzJC4blFyT5i2F5S5J3VdVzktwytD09yauranMmIc8uSR48bPvMVD03JPnIVK0z53pMVZ1bVZclOTbJT82++O4+pbs3dvfG3fZYv+3fFAAAALCirZSwZltuHl5vm1qeWZ95Jk/P2mdm/QfdPbN860z/7v5ckv2q6rAkO3X35UOfX0ryJ0kOSnJJVa1LUkl+dSpIenB3f2lWbbPrm67t1CQv7e7HJnlNJmEPAAAAsEathrBmIQ6pqocOz6o5Ksl5C9jntExm4fxFkgz7Pqi7P5PkVUn2TLJ7kk8keVlV1dDvwEXWtj7JdcMzco5d5L4AAADAKrNSwprZz6xZ7Nd2fz7J65NcnuSqJGcuYJ93Jdkrk8AmSXZK8j+H25UuTfLG7v5Oktcm2TnJlqq6fFhfjN9JckGSTyb58iL3BQAAAFaZ+uFdQKtTVR2eZFN3//Ii9zsyyRHd/dwdUtjdtM/+D+vnnPK6BfU94bprd3A1E3sdvekeOQ8AAEBVXdLdG5e7DtiR1t11l7Wnqt6c5BlJnrnctQAAAABry6oPa7r77Ey+pWkx+7xshxQDAAAAcBdWyjNrAAAAANYEYQ0AAADAiAhrAAAAAEZEWAMAAAAwIsIaAAAAgBER1gAAAACMiLAGAAAAYETWLXcBLM6+6/fOSYcds9xlAAAAADuImTUAAAAAIyKsAQAAABgRYQ0AAADAiAhrAAAAAEZEWAMAAAAwIsIaAAAAgBHx1d0rzDVbr8+mc05f7jLuxNeJAwAAwNIwswYAAABgRIQ1AAAAACMirAEAAAAYEWENAAAAwIgIawAAAABGRFgDAAAAMCLCGgAAAIAREdYAAAAAjIiwBgAAAGBEhDUAAAAAIyKsmVJVXVVvmFrfVFUnLvIY311An7OrauPdKBEAAABY5YQ1d3RzkmdX1X2XuxAAAABgbRLW3NEtSU5J8puzN1TVQ6rqU1W1ZXh98ND+0Kr6fFVdVFWvnep/eFV9dGr95Ko6bo7jPn3Y/wtVdUZV7b5DrgwAAABYEYQ1d/YnSY6tqj1mtZ+c5LTuflySdyV509D+x0ne2t0HJ/nfiznRMIPnt5M8rbufkOTiJL81R7/jq+riqrr4xhu2Lu5qAAAAgBVFWDNLd/9zktOSvHzWpicmefew/JdJnjwsPynJ6VPti3FokgOSfK6qNid5fpKHzFHTKd29sbs37rbH+kWeAgAAAFhJ1i13ASP1P5J8IclfbKNPz7M845bcMQzbZY4+leST3X3MoisEAAAAViUza+bQ3dcneV+SF041/02So4flY5OcNyx/blb7jL9PckBV3Xu4pern5zjV+UmeVFU/mSRVtVtVPXJprgIAAABYiYQ183tDkulvhXp5khdU1ZYkz03yiqH9FUleUlUXJbn9OTfd/Q+ZBD5bMnnGzaWzT9Dd/5TkuCSnD8c9P8mjlvxKAAAAgBXDbVBTunv3qeVvJNltav3qJD83xz5XZfI8mxmvn9r2qiSvmmOfw6eWP53k4O2rHAAAAFgtzKwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAiwhoAAACAERHWAAAAAIyIsAYAAABgRIQ1AAAAACMirAEAAAAYkXXLXQCLs+/6vXPSYccsdxkAAADADmJmDQAAAMCICGsAAAAARkRYAwAAADAiwhoAAACAERHWAAAAAIyIsAYAAABgRHx19wpzzdbrs+mc07frGCdcd+3d2m+vozdt13kBAACAu2ZmDQAAAMCICGsAAAAARkRYAwAAADAiwhoAAACAERHWAAAAAIyIsAYAAABgRIQ1AAAAACMirAEAAAAYEWENAAAAwIgIawAAAABGRFgDAAAAMCLCGgAAAIARucuwpqpurarNVXV5VZ1RVbsN7d/d0cVV1XFVdfI8204Y6to8VePmqnp5VZ1aVUfOsc8Dq+r9d3HOq6vqvktQ+4ur6nnbexwAAABgbVnIzJqbuntDdz8myfeTvHgpC6iqdXdnv+5+3VDXhqkaN3T3m7axzz92951CnB2hu9/W3afdE+cCAAAAVo/F3gZ1bpKfnN1YVf+hqi6qqi1V9Zqhbb+qunyqz6aqOnFYPruq/qCqzknyiqr6laq6oKouraq/rqr73/1Lut1TqupvqurrM7Nspmuqqp2q6qSqumyo+2WzrmnXqvp4Vb1oWH9OVV04zN7506raaWj/blW9rqq+WFXnz9ReVSdW1aap6/1vw/5/W1U/O7TvVlXvG87/3uF3sHGO3+/xVXVxVV184w1bl+BXAwAAAIzVgsOaYQbMM5JcNqv96UkekeSQJBuSHFRVT1nAIffs7sO6+w1JzktyaHcfmOQ9SV610Lq24QFJnpzkl5O8fo7txyd5aJIDu/txSd41tW33JB9J8u7ufntVPTrJUUmeNMzkuTXJsUPf+yQ5v7sfn+SzSV40Tz3ruvuQJK9M8rtD279L8u3h/K9NctBcO3b3Kd29sbs37rbH+gVcOgAAALBSLeQWpF2ravOwfG6SP5+1/enDz6XD+u6ZhDf/6y6O+96p5X2TvLeqHpDkXkmuWkBdd+VD3X1bkivnmanztCRv6+5bkqS7r5/a9ldJ/rC7ZwKcn88kSLmoqpJk1yTfHLZ9P8lHh+VLkvzCPPV8cKrPfsPyk5P88XD+y6tqy4KvDgAAAFiVFhLW3DTMJplPJfmv3f2nd2is2jd3nLmzy6z9/mVq+c1J/nt3f7iqDk9y4gLquis3z6pxtkrS8+z7uSTPqKp3d3cPfd/Z3f9pjr4/GPokkxk38/1Ob56jz1x1AQAAAGvYUnx19yeS/Nuq2j1JquonqurHk3wjyY9X1Y9V1b0zuR1pPnskuXZYfv4S1LQQZyV58cwDjqtq76lt/yXJ/0nylmH9U0mOHK4rVbV3VT1kCWo4L8n/MxzzgCSPXYJjAgAAACvYdoc13X1Wkncn+XxVXZbk/UnWd/cPkvxekgsyuU3oy9s4zIlJzqiqc5N8a3trWqA/y+RWrS1V9cUkvz5r+yuT7FJVf9jdVyb57SRnDbcqfTKTZ+Jsr7ckud9wzP+YZEuSG5bguAAAAMAKVT+8g4d72vCNUjt39/eq6uGZzOB5ZHd/f7599tn/Yf2cU163Xec94bpr77rTHPY6etN2nRcAAGB7VdUl3X2nb9GF1WQhz6xhx9ktyWeqaudMnl/z/zfjriUAABXiSURBVG0rqAEAAABWvxUR1lTVCUl+bVbzGd29fVNMlll3b00iEQYAAAButyLCmiGUWdHBDAAAAMBCLMW3QQEAAACwRIQ1AAAAACMirAEAAAAYEWENAAAAwIisiAcM80P7rt87Jx12zHKXAQAAAOwgZtYAAAAAjIiwBgAAAGBEhDUAAAAAIyKsAQAAABgRYQ0AAADAiAhrAAAAAEbEV3evMNdsvT6bzjl9QX1PuO7aBR93r6M33d2SAAAAgCVkZg0AAADAiAhrAAAAAEZEWAMAAAAwIsIaAAAAgBER1gAAAACMiLAGAAAAYESENQAAAAAjIqwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAiwppZqurWqto89fPqOfocXlUfXY76AAAAgNVt3XIXMEI3dfeG5S4CAAAAWJvMrFmgqvrFqvpyVZ2X5NlT7fepqndU1UVVdWlVHTG0H1dVH6qqj1TVVVX10qr6raHP+VW199DvRcO+X6yqD1TVbst0iQAAAMAICGvubNdZt0EdVVW7JHl7kl9J8rNJ9pnqf0KST3f3wUmemuSPquo+w7bHJPn1JIckeV2SG7v7wCSfT/K8oc8Hu/vg7n58ki8leeHsgqrq+Kq6uKouvvGGrUt/xQAAAMBouA3qzu50G1RVbUhyVXd/dVj/n0mOHzY/Pcm/rqpNw/ouSR48LH+mu7cm2VpVNyT5yNB+WZLHDcuPqarfT7Jnkt2TfGJ2Qd19SpJTkmSf/R/W23+JAAAAwFgJaxZuvpCkkvxqd3/lDo1VP53k5qmm26bWb8sPf/enJvk33f3FqjouyeFLVC8AAACwArkNamG+nOShVfXwYf2YqW2fSPKyqqokqaoDF3ns9Umuq6qdkxy73ZUCAAAAK5qw5s5mP7Pm9d39vUxue/r/hwcM//1U/9cm2TnJlqq6fFhfjN9JckGST2YSCgEAAABrmNugZununeZp/3iSR83RflOS35ij/dRMbnGaWd9vrm3d/dYkb92emgEAAIDVw8waAAAAgBER1gAAAACMiLAGAAAAYESENQAAAAAjIqwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAi65a7ABZn3/V756TDjlnuMgAAAIAdxMwaAAAAgBER1gAAAACMiLAGAAAAYESENQAAAAAjIqwBAAAAGBFhDQAAAMCICGsAAAAARmTdchfA4lyz9fpsOuf0Re1zwnXX3mF9r6M3LWVJAAAAwBIyswYAAABgRIQ1AAAAACMirAEAAAAYEWENAAAAwIgIawAAAABGRFgDAAAAMCLCGgAAAIAREdYAAAAAjIiwBgAAAGBEhDUAAAAAIzKKsKaq9qmq91TV31XVlVX1sap65N081nFVdfKw/OKqet7SVrt9pusDAAAAmG3dchdQVZXkzCTv7O6jh7YNSe6f5G8XsG91921zbe/uty1xuQAAAAA71Bhm1jw1yQ+mg5Xu3pzk0qr6VFV9oaouq6ojkqSq9quqL1XVW5J8IcmDquoFVfW3VXVOkifNHKeqTqyqTcPyhqo6v6q2VNWZVbXX0H52Vb2xqj47HPfgqvpgVX21qn5/6ljPqaoLq2pzVf1pVe00tL9wOPfZVfX2qVk9v1JVF1TVpVX111V1/+mLrqr1VXVVVe08rP9oVV09sw4AAACsTWMIax6T5JI52r+X5Fnd/YRMAp03DDNpkmT/JKd194FJvp/kNZmENL+Q5IB5znNakv/Y3Y9LclmS353a9v3ufkqStyX5qyQvGeo6rqp+rKoeneSoJE/q7g1Jbk1ybFU9MMnvJDl0OPejpo55XpJDhxrfk+RV08V099YkZyf5paHp6CQf6O4fzC68qo6vqour6uIbb9g6z+UBAAAAq8Gy3wa1DZXkD6rqKUluS/ITmdwalSR/393nD8s/neTs7v6nJKmq9ya5w/NuqmqPJHt29zlD0zuTnDHV5cPD62VJruju64b9vp7kQUmenOSgJBcNedGuSb6Z5JAk53T39UP/M6bOvW+S91bVA5LcK8lVc1zjn2US4nwoyQuSvGiuX0R3n5LklCTZZ/+H9Vx9AAAAgNVhDDNrrsgkCJnt2CT3S3LQMJvlG0l2Gbb9y6y+2xtg3Dy83ja1PLO+LpPg6J3dvWH42b+7Txza5/PmJCd392OT/MZU7T8suvtzSfarqsOS7NTdl2/ndQAAAAAr3BjCmk8nuXdV3T6rpKoOTvKQJN/s7h9U1VOH9blckOTw4XalnZP82uwO3X1Dkm9X1c8OTc9Ncs7sftvwqSRHVtWPD/XtXVUPSXJhksOqaq+qWpfkV6f22SPJtcPy87dx7NOSnJ7kLxZRDwAAALBKLXtY092d5FlJfmH46u4rkpyY5GNJNlbVxZnMsvnyPPtfN/T/fJK/zuShw3N5fpI/qqotSTYk+b1F1Hhlkt9Octaw/yeTPKC7r03yB5kERn+d5MokNwy7nZjkjKo6N8m3tnH4dyXZK5PABgAAAFjjapKVcHdV1e7d/d1hZs2ZSd7R3WcuYv8jkxzR3c9dSP999n9YP+eU1y2qxhOuu/YO63sdvWlR+wMAAIxFVV3S3RuXuw7Ykcb8gOGV4sSqelomz6Q5K5OHBS9IVb05yTOSPHMH1QYAAACsMMKa7dTdd3uaSne/bClrAQAAAFa+ZX9mDQAAAAA/JKwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAiwhoAAACAERHWAAAAAIzIuuUugMXZd/3eOemwY5a7DAAAAGAHMbMGAAAAYESENQAAAAAjIqwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAivrp7hblm6/XZdM7pOeG6a5Mkex29aZkrAgAAAJaSmTUAAAAAIyKsAQAAABgRYQ0AAADAiAhrAAAAAEZEWAMAAAAwIsIaAAAAgBER1gAAAACMiLAGAAAAYESENQAAAAAjIqwBAAAAGBFhzRyq6ruz1o+rqpOX8Pgfq6o9l+p4AAAAwOqxbrkLWI2qal133zLf9u5+5j1ZDwAAALByCGsWqarul+RtSR48NL2yuz9XVScmeWCS/ZJ8q6rOSvKvk+yW5OFJzuzuVw3HuDrJxu7+VlV9KMmDkuyS5I+7+5R78HIAAACAkRHWzG3Xqto8tb53kg8Py3+c5I3dfV5VPTjJJ5I8eth2UJInd/dNVXVckg1JDkxyc5KvVNWbu/sfZp3r33b39VW1a5KLquoD3f1/pjtU1fFJjk+S9fe/79JdJQAAADA6wpq53dTdG2ZWhuBl47D6tCQHVNXM5h+tqvXD8oe7+6ap43yqu28YjnFlkockmR3WvLyqnjUsPyjJI5LcIawZZtuckiT77P+w3o7rAgAAAEZOWLN4P5LkibNCmQzhzb/M6nvz1PKtmfX7rqrDMwl/ntjdN1bV2ZncDgUAAACsUb4NavHOSvLSmZWq2rCNvndljyTfHoKaRyU5dHuLAwAAAFY2Yc3ivTzJxqraMtza9OLtONbHk6yrqi1JXpvk/KUoEAAAAFi53AY1h+7efdb6qUlOHZa/leSoOfY5cb59hvVfnlreb6rrM7a3XgAAAGD1MLMGAAAAYESENQAAAAAjIqwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAiwhoAAACAERHWAAAAAIyIsAYAAABgRNYtdwEszr7r985Jhx2z3GUAAAAAO4iZNQAAAAAjIqwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAiwhoAAACAEfHV3SvMNVuvz6ZzTr993dd4AwAAwOpiZg0AAADAiAhrAAAAAEZEWAMAAAAwIsIaAAAAgBER1gAAAACMiLAGAAAAYESENQAAAAAjIqwBAAAAGBFhDQAAAMCICGsAAAAARkRYAwAAADAiKzasqapbq2pzVV1eVWdU1W7LXdNCVNUDq+r9y10HAAAAME4rNqxJclN3b+juxyT5fpIXL3dBC9Hd/9jdRy53HQAAAMA4reSwZtq5SX6yqvarqi9V1dur6oqqOquqdk2Sqnp4VX28qi6pqnOr6lFD+6lVdXt4UlXfHV4Pr6pzqup9VfW3VfX6qjq2qi6sqsuq6uFDv4dU1aeqasvw+uCp476pqv6mqr4+c46hxsunls+tqi8MPz9zj/7WAAAAgNFZ8WFNVa1L8owklw1Nj0jyJ939U0m+k+RXh/ZTkrysuw9KsinJWxZw+McneUWSxyZ5bpJHdvchSf4sycuGPicnOa27H5fkXUneNLX/A5I8OckvJ3n9HMf/ZpJf6O4nJDlq1r7T13h8VV1cVRffeMPWBZQNAAAArFTrlruA7bBrVW0els9N8udJHpjkqu6eab8kyX5VtXuSn0lyRlXN7H/vBZzjou6+Lkmq6u+SnDW0X5bkqcPyE5M8e1j+yyR/OLX/h7r7tiRXVtX95zj+zklOrqoNSW5N8si5iujuUzIJm7LP/g/rBdQNAAAArFArOay5qbs3TDcMQczNU023Jtk1kxlE35ndf3DLsD01OcC9prZNH+u2qfXbMv/vbjpMmd6/ZndM8ptJvpHJDJ4fSfK9eY4JAAAArBEr/jaohejuf05yVVX9WjIJZarq8cPmq5McNCwfkclsl8X4myRHD8vHJjlvEfvukeS6YfbNc5PstMhzAwAAAKvMmghrBscmeWFVfTHJFZkEM0ny9iSHVdWFSX46yb8s8rgvT/KCqtqSSeDyikXs+5Ykz6+q8zO5BWqx5wYAAABWmer2CJSVZJ/9H9bPOeV1t6+fdNgxy1gNAADAPauqLunujctdB+xIa2lmDQAAAMDoCWsAAAAARkRYAwAAADAiwhoAAACAERHWAAAAAIyIsAYAAABgRIQ1AAAAACMirAEAAAAYkXXLXQCLs+/6vXPSYccsdxkAAADADmJmDQAAAMCICGsAAAAARkRYAwAAADAi1d3LXQOLUFVbk3xluetgFO6b5FvLXQSjYCwww1hghrHADGOBGatpLDyku++33EXAjuQBwyvPV7p743IXwfKrqouNBRJjgR8yFphhLDDDWGCGsQAri9ugAAAAAEZEWAMAAAAwIsKaleeU5S6A0TAWmGEsMMNYYIaxwAxjgRnGAqwgHjAMAAAAMCJm1gAAAACMiLAGAAAAYESENStIVf1iVX2lqr5WVa9e7nrY8arq6qq6rKo2V9XFQ9veVfXJqvrq8LrX0F5V9aZhfGypqicsb/Vsj6p6R1V9s6oun2pb9HtfVc8f+n+1qp6/HNfC9plnLJxYVdcOnw2bq+qZU9v+0zAWvlJV/2qq3d+QFayqHlRVn6mqL1XVFVX1iqHd58Ias42x4HNhjamqXarqwqr64jAWXjO0P7SqLhj+N/7eqrrX0H7vYf1rw/b9po415xgBlo+wZoWoqp2S/EmSZyQ5IMkxVXXA8lbFPeSp3b2huzcO669O8qnufkSSTw3ryWRsPGL4OT7JW+/xSllKpyb5xVlti3rvq2rvJL+b5KeTHJLkd2f+Q44V5dTceSwkyRuHz4YN3f2xJBn+Lhyd5KeGfd5SVTv5G7Iq3JLk33f3o5McmuQlw3voc2HtmW8sJD4X1pqbk/xcdz8+yYYkv1hVhyb5b5mMhUck+XaSFw79X5jk2939k0neOPSbd4zco1cC3ImwZuU4JMnXuvvr3f39JO9JcsQy18TyOCLJO4fldyb5N1Ptp/XE+Un2rKoHLEeBbL/u/myS62c1L/a9/1dJPtnd13f3t5N8MnP/Rz8jNs9YmM8RSd7T3Td391VJvpbJ3w9/Q1a47r6uu78wLG9N8qUkPxGfC2vONsbCfHwurFLD/76/O6zuPPx0kp9L8v6hffbnwsznxfuT/HxVVeYfI8AyEtasHD+R5B+m1q/Jtv8wszp0krOq6pKqOn5ou393X5dM/sGW5MeHdmNk9Vvse29MrG4vHW5vecfUzAhjYQ0Ybl04MMkF8bmwps0aC4nPhTVnmCW1Ock3Mwlf/y7Jd7r7lqHL9Pt6+3s+bL8hyY/FWIBREtasHDVHm+9dX/2e1N1PyGSK8kuq6inb6GuMrF3zvffGxOr11iQPz2Ta+3VJ3jC0GwurXFXtnuQDSV7Z3f+8ra5ztBkLq8gcY8HnwhrU3bd294Yk+2YyG+bRc3UbXo0FWEGENSvHNUkeNLW+b5J/XKZauId09z8Or99McmYmf4S/MXN70/D6zaG7MbL6Lfa9NyZWqe7+xvAP9NuSvD0/nK5uLKxiVbVzJv9x/q7u/uDQ7HNhDZprLPhcWNu6+ztJzs7kOUZ7VtW6YdP0+3r7ez5s3yOT22yNBRghYc3KcVGSRwxPd79XJg8B+/Ay18QOVFX3qar1M8tJnp7k8kze95lv73h+kr8alj+c5HnDN4AcmuSGmanxrBqLfe8/keTpVbXXMB3+6UMbK9ys51E9K5PPhmQyFo4evvHjoZk8XPbC+Buy4g3PlfjzJF/q7v8+tcnnwhoz31jwubD2VNX9qmrPYXnXJE/L5BlGn0ly5NBt9ufCzOfFkUk+3d2d+ccIsIzW3XUXxqC7b6mql2byD6qdkryju69Y5rLYse6f5MzJv8myLsm7u/vjVXVRkvdV1QuT/K8kvzb0/1iSZ2byULgbk7zgni+ZpVJVpyc5PMl9q+qaTL695fVZxHvf3ddX1Wsz+Qd5kvxedy/0QbWMxDxj4fCq2pDJNPWrk/xGknT3FVX1viRXZvKNMS/p7luH4/gbsrI9Kclzk1w2PJ8iSf5zfC6sRfONhWN8Lqw5D0jyzuGbm34kyfu6+6NVdWWS91TV7ye5NJNwL8PrX1bV1zKZUXN0su0xAiyfmoSpAAAAAIyB26AAAAAARkRYAwAAADAiwhoAAACAERHWAAAAAIyIsAYAAABgRIQ1ALCGVdU+VfWeqvq7qrqyqj5WVY9cwuMfXlU/s1THAwBYC4Q1ALBGVVUlOTPJ2d398O4+IMl/TnL/JTzN4UmENQAAiyCsAYC166lJftDdb5tp6O7NSc6rqj+qqsur6rKqOiq5fZbMR2f6VtXJVXXcsHx1Vb2mqr4w7POoqtovyYuT/GZVba6qn70Hrw0AYMVat9wFAADL5jFJLpmj/dlJNiR5fJL7Jrmoqj67gON9q7ufUFX/Lsmm7v5/q+ptSb7b3SctWdUAAKucmTUAwGxPTnJ6d9/a3d9Ick6Sgxew3weH10uS7LeDagMAWPWENQCwdl2R5KA52mue/rfkjv922GXW9puH11tj9i4AwN0mrAGAtevTSe5dVS+aaaiqg5N8O8lRVbVTVd0vyVOSXJjk75McUFX3rqo9kvz8As6xNcn6pS8dAGD18v96AcAa1d1dVc9K8j+q6tVJvpfk6iSvTLJ7ki8m6SSv6u7/nSRV9b4kW5J8NcmlCzjNR5K8v6qOSPKy7j53yS8EAGCVqe5e7hoAAAAAGLgNCgAAAGBEhDUAAAAAIyKsAQAAABgRYQ0AAADAiAhrAAAAAEZEWAMAAAAwIsIaAAAAgBH5v/WJCY386QBqAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def path_count(pathology):\n",
    "    if \"|\" not in pathology:\n",
    "        return 0\n",
    "    else:\n",
    "        return 1\n",
    "\n",
    "def multiple_count(pathology_column):\n",
    "    return pathology_column.map(lambda x: path_count(x))\n",
    "\n",
    "df['Multiple'] = multiple_count(df['Finding Labels'])\n",
    "\n",
    "pathology_list = ['Cardiomegaly','Emphysema','Effusion','Hernia','Nodule','Pneumothorax','Atelectasis',\n",
    "                  'Pleural_Thickening','Mass','Edema','Consolidation','Infiltration','Fibrosis','Pneumonia']\n",
    "for pathology in pathology_list:\n",
    "    df[pathology] = df['Finding Labels'].apply(lambda x: 1 if pathology in x else 0)\n",
    "    \n",
    "data1 = pd.melt(df,\n",
    "             id_vars=['Multiple'],\n",
    "             value_vars = list(pathology_list),\n",
    "             var_name = 'Category',\n",
    "             value_name = 'Count')\n",
    "data1 = data1.loc[data1.Count>0]\n",
    "\n",
    "f, ax = plt.subplots(sharex=True,figsize=(15, 10))\n",
    "p=sns.countplot(y='Category',data=data1, \n",
    "                order = data1['Category'].value_counts().index,ax=ax,color='lightsalmon',label=\"Multiple Pathologies\")\n",
    "p=sns.countplot(y='Finding Labels',data=single, ax=ax, color=\"mediumaquamarine\",label=\"Single Pathology\")\n",
    "ax.set_title('Pathology Distribution')\n",
    "ax.set_ylabel('')\n",
    "ax.set_xlabel('Count')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single Pathology Distribution by Gender "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:12: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  if sys.path[0] == '':\n"
     ]
    }
   ],
   "source": [
    "def clean_age(age):\n",
    "    if 'Y' not in age:\n",
    "        age = '0'\n",
    "    else:\n",
    "        age = age\n",
    "    clean_age = ''.join(i for i in age if i.isdigit())\n",
    "    return int(clean_age)\n",
    "\n",
    "def clean_all_ages(age_column):\n",
    "    return age_column.map(lambda x: clean_age(x))\n",
    "\n",
    "single['Patient Age'] = clean_all_ages(single['Patient Age'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a85484438>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "ax = sns.countplot(y=\"Finding Labels\", hue=\"Patient Gender\", data=single, palette='seismic')\n",
    "ax.set_title('Pathology Distribution')\n",
    "ax.set_ylabel('')\n",
    "ax.set_xlabel('Count')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Single Pathology Distribution, by Patient Age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "f, ax = plt.subplots(figsize=(10, 10))\n",
    "plt.xlim(0, 100)\n",
    "ax = sns.boxplot(y='Finding Labels',x='Patient Age',data=single,palette='winter')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Cleaning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Images resized from 1024x1024 to 128x128\n",
    "* Eliminate x-rays with multiple pathologies\n",
    "* Rare diseases grouped together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  after removing the cwd from sys.path.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5,1,'Pathology Distribution')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "clean_df = single\n",
    "RareClass = [\"Edema\", \"Emphysema\", \"Fibrosis\", \"Pneumonia\", \"Pleural_Thickening\", \"Cardiomegaly\",\"Hernia\"] #7\n",
    "\n",
    "clean_df['Finding Labels'] = clean_df['Finding Labels'].apply(lambda x: 'Rare Diseases' if x in RareClass else x)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(10, 10))\n",
    "ax = sns.countplot(y=\"Finding Labels\", data=clean_df, palette='rainbow')\n",
    "ax.set_ylabel('')\n",
    "ax.set_xlabel('Count')\n",
    "ax.set_title('Pathology Distribution')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3044"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = clean_df[clean_df['Finding Labels']=='No Finding']\n",
    "len(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Imbalance Solutions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Class Weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Class weights were passed into model.fit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0.1858984888304862,\n",
       " 1: 7.859375,\n",
       " 2: 1.125,\n",
       " 3: 4.963815789473684,\n",
       " 4: 2.7875615763546797,\n",
       " 5: 3.9296875,\n",
       " 6: 2.947265625,\n",
       " 7: 2.2191176470588236}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class_weights = class_weight.compute_class_weight('balanced', np.unique(y), y)\n",
    "class_weights = dict(enumerate(class_weights))\n",
    "class_weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Over-Sampling\n",
    "* Randomly oversampled data to increase sample size\n",
    "\n",
    "#### Data Augmentation\n",
    "* Horizontally flipped images and rotated by 30 degrees to add more images to sample"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs=5\n",
    "optimizer=optimizers.Adam(lr=0.000001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0000001)\n",
    "batch_size=32\n",
    "loss='categorical_crossentropy'\n",
    "activation='relu'\n",
    "out_activation='softmax'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Optimizer: Adam (learning rate: 0.000001, decay=0.0000001)\n",
    "* Batch Size = 32 \n",
    "* Loss = Categorical Cross-Entropy\n",
    "* Activation = relu\n",
    "* Output Activation = Softmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multilayer Perceptron"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Balanced Class Weights"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 150)               7372950   \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 150)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 125)               18875     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 125)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 100)               12600     \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 75)                7575      \n",
      "_________________________________________________________________\n",
      "dropout_4 (Dropout)          (None, 75)                0         \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 50)                3800      \n",
      "_________________________________________________________________\n",
      "dropout_5 (Dropout)          (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 8)                 408       \n",
      "=================================================================\n",
      "Total params: 7,416,208\n",
      "Trainable params: 7,416,208\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "#architecture and hyperparameters\n",
    "balanced_mlp_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Balanced Accuracy Diagram](balanced_mlp.png \"Balanced MLP Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random Oversampling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_7 (Dense)              (None, 100)               4915300   \n",
      "_________________________________________________________________\n",
      "dropout_6 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_8 (Dense)              (None, 25)                2525      \n",
      "_________________________________________________________________\n",
      "dropout_7 (Dropout)          (None, 25)                0         \n",
      "_________________________________________________________________\n",
      "dense_9 (Dense)              (None, 25)                650       \n",
      "_________________________________________________________________\n",
      "dropout_8 (Dropout)          (None, 25)                0         \n",
      "_________________________________________________________________\n",
      "dense_10 (Dense)             (None, 25)                650       \n",
      "_________________________________________________________________\n",
      "dropout_9 (Dropout)          (None, 25)                0         \n",
      "_________________________________________________________________\n",
      "dense_11 (Dense)             (None, 75)                1950      \n",
      "_________________________________________________________________\n",
      "dropout_10 (Dropout)         (None, 75)                0         \n",
      "_________________________________________________________________\n",
      "dense_12 (Dense)             (None, 10)                760       \n",
      "_________________________________________________________________\n",
      "dropout_11 (Dropout)         (None, 10)                0         \n",
      "_________________________________________________________________\n",
      "dense_13 (Dense)             (None, 8)                 88        \n",
      "=================================================================\n",
      "Total params: 4,921,923\n",
      "Trainable params: 4,921,923\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "ros_mlp_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ROS Accuracy Diagram](ros_mlp.png \"ROS MLP Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convolutional Neural Networks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Architecture "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_23 (Conv2D)           (None, 126, 126, 32)      896       \n",
      "_________________________________________________________________\n",
      "max_pooling2d_22 (MaxPooling (None, 63, 63, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_24 (Conv2D)           (None, 61, 61, 64)        18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_23 (MaxPooling (None, 30, 30, 64)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_25 (Conv2D)           (None, 28, 28, 128)       73856     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_24 (MaxPooling (None, 14, 14, 128)       0         \n",
      "_________________________________________________________________\n",
      "flatten_9 (Flatten)          (None, 25088)             0         \n",
      "_________________________________________________________________\n",
      "dropout_3 (Dropout)          (None, 25088)             0         \n",
      "_________________________________________________________________\n",
      "dense_35 (Dense)             (None, 64)                1605696   \n",
      "_________________________________________________________________\n",
      "dropout_4 (Dropout)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_36 (Dense)             (None, 8)                 520       \n",
      "=================================================================\n",
      "Total params: 1,699,464\n",
      "Trainable params: 1,699,464\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "ros_cnn_model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ROS Accuracy Diagram](ros_cnn.png \"ROS MLP Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Limitations "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Label Accuracy \n",
    "*Source: https://lukeoakdenrayner.wordpress.com/2017/12/18/the-chestxray14-dataset-problems/*\n",
    "* Labels were produced, using text mining (from clinical reports connected with the images)\n",
    "* Cross-validation of labels based on two annotators who looked at the reports (but not the images)\n",
    "* Based on this process, label accuracy was >90%\n",
    "* Actual label accuracy, based on the images alone (radiologist-labeled), was much lower"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Label Accuracy Diagram](label_accuracy.png \"Label Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![False Atelectasis Diagram](false_atelectasis.png \"Label Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Treated Pneumothorax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Label Accuracy Diagram](treated_pneumothorax.png \"Label Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### With a pre-trained model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**True Positives**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Label Accuracy Diagram](true_pos.png \"Label Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**False Negatives**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Label Accuracy Diagram](false_neg.png \"Label Accuracy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Data flawed, with internally inconsistent labels \n",
    "* Models only trained to fit on these images so they're essentially fitting on noise -- any predictions would be nonsensical\n",
    "* Because data is flawed with lots of noise, we had many issues with validation loss and accuracy in spite of hyperparameter tuning (this persisted even with binary classification -- disease Y/N)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next Steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ALWAYS CHECK DATA QUALITY\n",
    "* Work with better datasets\n",
    "* Include other parameters (patient age, gender)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Image Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ddde994e9b1d4c54a26942ce71d84d61",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), Button(description='Generate X-Ray!', style=ButtonStyle())))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# produce random image, prediction, and actual label \n",
    "\n",
    "def pathology_label(val):\n",
    "    pathology_dict = {0: 'No Finding', 1: 'Consolidation', 2: 'Infiltration', 3: 'Pneumothorax', \n",
    "                      4:'Effusion', 5: 'Nodule Mass', 6: 'Atelectasis', 7: \"Other Rare Classes\"}\n",
    "    return [v for k, v in pathology_dict.items() if k==val][0]\n",
    "\n",
    "def make_prediction():\n",
    "    rand_image = single.sample(1)\n",
    "    img_index = rand_image['Image Index'].tolist()[0]\n",
    "    img = cv2.imread(os.path.join(SOURCE_IMAGES, img_index))\n",
    "    img_pathology = rand_image['Finding Labels'].tolist()[0]\n",
    "    img = cv2.resize(img, (128,128), interpolation=cv2.INTER_CUBIC)\n",
    "    test_img = img_to_array(img)\n",
    "    test_img = test_img.reshape(-1).astype('float32')\n",
    "    test_img = np.expand_dims(test_img, axis = 0)\n",
    "    y_prob = ros_mlp_model.predict(test_img)\n",
    "    y_classes = y_prob.argmax(axis=-1)[0]\n",
    "    prediction = pathology_label(y_classes)\n",
    "    print(\"Randomly generated image is labeled as: \" + img_pathology + \n",
    "          \". The model has predicted the pathology to be: \" + prediction + \".\")\n",
    "    return img\n",
    "    \n",
    "out=widgets.Output()\n",
    "button=widgets.Button(description='Generate X-Ray!')\n",
    "vbox=widgets.VBox(children=(out,button))\n",
    "display(vbox)\n",
    "\n",
    "def on_button_clicked(b):\n",
    "    with out:\n",
    "        clear_output(wait=True)\n",
    "        img = make_prediction()\n",
    "        plt.imshow(img)\n",
    "        show_inline_matplotlib_plots()\n",
    "\n",
    "button.on_click(on_button_clicked)"
   ]
  }
 ],
 "metadata": {
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}