train_brats2020_V5_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "machine_shape": "hm"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install segmentation_models_3D"
      ],
      "metadata": {
        "id": "-Vk0F24WuXij"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DFx3KcgJn4b0"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import numpy as np\n",
        "#import custom_datagen\n",
        "import tensorflow\n",
        "#import keras\n",
        "from matplotlib import pyplot as plt\n",
        "import glob\n",
        "import random\n",
        "import segmentation_models_3D as sm\n",
        "from keras.metrics import MeanIoU\n",
        "from keras.models import load_model\n",
        "from matplotlib import pyplot as plt\n",
        "from keras.callbacks import BackupAndRestore, CSVLogger, ModelCheckpoint,LearningRateScheduler, ReduceLROnPlateau"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive',force_remount=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T_cqEOkfoind",
        "outputId": "524b2c5e-682d-4256-d0d6-58392919263a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_drive = '/content/gdrive/My Drive/'\n",
        "import sys\n",
        "sys.path.append(my_drive)"
      ],
      "metadata": {
        "id": "KJB9FOgzpIP0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from custom_datagen import imageLoader\n",
        "# from simple_3d_unet import simple_unet_model\n",
        "from 3d_unet_model import my_unet_model\n",
        "TEST_SAVE = '/content/gdrive/My Drive/PJ_BrainTumor_Dataset/BraTS2020_TrainingData/'"
      ],
      "metadata": {
        "id": "clE44RYl2HXJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "train_img_dir = TEST_SAVE + \"input_data_128/train/images/\"\n",
        "train_mask_dir = TEST_SAVE + \"input_data_128/train/masks/\"\n",
        "\n",
        "img_list = os.listdir(train_img_dir)\n",
        "msk_list = os.listdir(train_mask_dir)\n",
        "\n",
        "num_images = len(os.listdir(train_img_dir))\n",
        "\n",
        "img_num = random.randint(0,num_images-1)\n",
        "test_img = np.load(train_img_dir+img_list[img_num])\n",
        "test_mask = np.load(train_mask_dir+msk_list[img_num])\n",
        "test_mask = np.argmax(test_mask, axis=3)\n",
        "\n",
        "n_slice=random.randint(0, test_mask.shape[2])\n",
        "# plt.figure(figsize=(12, 8))\n",
        "\n",
        "# plt.subplot(221)\n",
        "# plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
        "# plt.title('Image flair')\n",
        "# plt.subplot(222)\n",
        "# plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
        "# plt.title('Image t1ce')\n",
        "# plt.subplot(223)\n",
        "# plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
        "# plt.title('Image t2')\n",
        "# plt.subplot(224)\n",
        "# plt.imshow(test_mask[:,:,n_slice])\n",
        "# plt.title('Mask')\n",
        "# plt.show()\n"
      ],
      "metadata": {
        "id": "Se0UxMF3qvKH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Optional step of finding the distribution of each class and calculating appropriate weights\n",
        "#Alternatively you can just assign equal weights and see how well the model performs: 0.25, 0.25, 0.25, 0.25\n",
        "\n",
        "# import pandas as pd\n",
        "# columns = ['0','1', '2', '3']\n",
        "# df = pd.DataFrame(columns=columns)\n",
        "# train_mask_list = sorted(glob.glob('BraTS2020_TrainingData/input_data_128/train/masks/*.npy'))\n",
        "# for img in range(len(train_mask_list)):\n",
        "#     print(img)\n",
        "#     temp_image=np.load(train_mask_list[img])\n",
        "#     temp_image = np.argmax(temp_image, axis=3)\n",
        "#     val, counts = np.unique(temp_image, return_counts=True)\n",
        "#     zipped = zip(columns, counts)\n",
        "#     conts_dict = dict(zipped)\n",
        "\n",
        "#     df = df.append(conts_dict, ignore_index=True)\n",
        "\n",
        "# label_0 = df['0'].sum()\n",
        "# label_1 = df['1'].sum()\n",
        "# label_2 = df['1'].sum()\n",
        "# label_3 = df['3'].sum()\n",
        "# total_labels = label_0 + label_1 + label_2 + label_3\n",
        "# n_classes = 4\n",
        "# #Class weights claculation: n_samples / (n_classes * n_samples_for_class)\n",
        "# wt0 = round((total_labels/(n_classes*label_0)), 2) #round to 2 decimals\n",
        "# wt1 = round((total_labels/(n_classes*label_1)), 2)\n",
        "# wt2 = round((total_labels/(n_classes*label_2)), 2)\n",
        "# wt3 = round((total_labels/(n_classes*label_3)), 2)\n",
        "\n",
        "#Weights are: 0.26, 22.53, 22.53, 26.21\n",
        "#wt0, wt1, wt2, wt3 = 0.26, 22.53, 22.53, 26.21\n",
        "#These weihts can be used for Dice loss"
      ],
      "metadata": {
        "id": "9ZKxBceWz8-T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Define the image generators for training and validation\n",
        "\n",
        "train_img_dir = TEST_SAVE + \"input_data_128/train/images/\"\n",
        "train_mask_dir = TEST_SAVE + \"input_data_128/train/masks/\"\n",
        "\n",
        "val_img_dir = TEST_SAVE + \"input_data_128/val/images/\"\n",
        "val_mask_dir = TEST_SAVE + \"input_data_128/val/masks/\"\n",
        "\n",
        "train_img_list=os.listdir(train_img_dir)\n",
        "train_mask_list = os.listdir(train_mask_dir)\n",
        "\n",
        "val_img_list=os.listdir(val_img_dir)\n",
        "val_mask_list = os.listdir(val_mask_dir)"
      ],
      "metadata": {
        "id": "ulv14xhYz_J1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "batch_size = 2\n",
        "\n",
        "train_img_datagen = imageLoader(train_img_dir, train_img_list,\n",
        "                                train_mask_dir, train_mask_list, batch_size)\n",
        "\n",
        "val_img_datagen = imageLoader(val_img_dir, val_img_list,\n",
        "                                val_mask_dir, val_mask_list, batch_size)\n",
        "\n",
        "#Verify generator.... In python 3 next() is renamed as __next__()\n",
        "img, msk = train_img_datagen.__next__()\n",
        "\n",
        "# img_num = random.randint(0,img.shape[0]-1)\n",
        "# test_img=img[img_num]\n",
        "# test_mask=msk[img_num]\n",
        "# test_mask=np.argmax(test_mask, axis=3)\n",
        "\n",
        "# n_slice=random.randint(0, test_mask.shape[2])\n",
        "# plt.figure(figsize=(12, 8))\n",
        "\n",
        "# plt.subplot(221)\n",
        "# plt.imshow(test_img[:,:,n_slice, 0], cmap='gray')\n",
        "# plt.title('Image flair')\n",
        "# plt.subplot(222)\n",
        "# plt.imshow(test_img[:,:,n_slice, 1], cmap='gray')\n",
        "# plt.title('Image t1ce')\n",
        "# plt.subplot(223)\n",
        "# plt.imshow(test_img[:,:,n_slice, 2], cmap='gray')\n",
        "# plt.title('Image t2')\n",
        "# plt.subplot(224)\n",
        "# plt.imshow(test_mask[:,:,n_slice])\n",
        "# plt.title('Mask')\n",
        "# plt.show()\n"
      ],
      "metadata": {
        "id": "Uk97xcQp0Wn-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Defining loss, metrics and optimizer to be used for training\n",
        "wt0, wt1, wt2, wt3 = 0.25,0.25,0.25,0.25\n",
        "# wt0, wt1, wt2, wt3 = 0.26, 22.53, 22.53, 26.21\n",
        "dice_loss = sm.losses.DiceLoss(class_weights=np.array([wt0, wt1, wt2, wt3]))\n",
        "focal_loss = sm.losses.CategoricalFocalLoss()\n",
        "total_loss = dice_loss + (1 * focal_loss)\n",
        "\n",
        "metrics = ['accuracy', sm.metrics.IOUScore(threshold=0.5)]\n",
        "\n",
        "#from keras.optimizers import Adam\n",
        "from keras.optimizers import adam_v2\n",
        "LR = 0.000003\n",
        "epochs = 100\n",
        "# optim = Adam(LR)\n",
        "\n",
        "optim = adam_v2.Adam(learning_rate=LR, decay=LR/epochs)\n"
      ],
      "metadata": {
        "id": "zm45TEdE0dxb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "steps_per_epoch = len(train_img_list)//batch_size\n",
        "val_steps_per_epoch = len(val_img_list)//batch_size\n",
        "\n",
        "\n",
        "#from  simple_3d_unet import simple_unet_model\n",
        "\n",
        "model = my_unet_model(IMG_HEIGHT=128,\n",
        "                          IMG_WIDTH=128,\n",
        "                          IMG_DEPTH=128,\n",
        "                          IMG_CHANNELS=3,\n",
        "                          num_classes=4)\n",
        "\n",
        "model.compile(optimizer = optim, loss=total_loss, metrics=metrics)\n",
        "print(model.summary())\n",
        "\n",
        "print(model.input_shape)\n",
        "print(model.output_shape)\n",
        "\n"
      ],
      "metadata": {
        "id": "a2YZobm-41cN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = 100\n",
        "\n",
        "decay_rate = LR / epochs\n",
        "\n",
        "def exp_decay(epoch):\n",
        "    lrate = LR * np.exp(-decay_rate*epoch)\n",
        "    return lrate\n",
        "\n",
        "filepath = TEST_SAVE + 'saved models/weights-improvement-{epoch:02d}-{val_iou_score:.2f}.hdf5'\n",
        "\n",
        "checkpoint = ModelCheckpoint(filepath, monitor= 'val_iou_score', verbose= 1, save_best_only_best= True, mode= 'max')\n",
        "log_csv = CSVLogger(TEST_SAVE + 'my_logs.csv', separator=',', append= True)\n",
        "backup_restore = BackupAndRestore(backup_dir= TEST_SAVE + \"saved models/backup_1\")\n",
        "lr_rate = LearningRateScheduler(exp_decay)\n",
        "\n",
        "callbacks_list = [checkpoint, log_csv, backup_restore, lr_rate]"
      ],
      "metadata": {
        "id": "WByJkmkQwSEj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "history=model.fit(train_img_datagen,\n",
        "          steps_per_epoch=steps_per_epoch,\n",
        "          epochs= epochs,\n",
        "          verbose=1,\n",
        "          validation_data=val_img_datagen,\n",
        "          validation_steps=val_steps_per_epoch,\n",
        "          callbacks= callbacks_list )\n",
        "\n",
        "model.save(TEST_SAVE + 'saved models/brats_3d_100_updated.hdf5')\n",
        "\n",
        "\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "epochs = range(1, len(loss) + 1)\n",
        "plt.plot(epochs, loss, 'y', label='Training loss')\n",
        "plt.plot(epochs, val_loss, 'r', label='Validation loss')\n",
        "plt.title('Training and validation loss to 200 epochs straight')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "\n",
        "plt.plot(epochs, acc, 'y', label='Training accuracy')\n",
        "plt.plot(epochs, val_acc, 'r', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracyto 200 epochs straight')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "iou = history.history['iou_score']\n",
        "val_iou = history.history['val_iou_score']\n",
        "\n",
        "plt.plot(epochs, iou, 'y', label='Training IoU Score')\n",
        "plt.plot(epochs, val_iou, 'r', label='Validation IoU Score')\n",
        "plt.title('Training and validation IoU Score to 200 epochs straight')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('IoU Score')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "qafOoWXw5b__"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_model = load_model(TEST_SAVE + 'saved models/brats_3d_100_updated.hdf5',\n",
        "                      custom_objects={'dice_loss_plus_1focal_loss': total_loss,\n",
        "                                      'iou_score':sm.metrics.IOUScore(threshold=0.5)})\n",
        "\n",
        "\n",
        "history2=my_model.fit(train_img_datagen,\n",
        "          steps_per_epoch=steps_per_epoch,\n",
        "          epochs=1,\n",
        "          verbose=1,\n",
        "          validation_data=val_img_datagen,\n",
        "          validation_steps=val_steps_per_epoch,\n",
        "          )\n",
        "\n",
        "\n",
        "# my_model.save(TEST_SAVE + 'saved models/brats_3d_200.hdf5')\n",
        "\n",
        "loss = history2.history['loss']\n",
        "val_loss = history2.history['val_loss']\n",
        "epochs = range(1, len(loss) + 1)\n",
        "plt.plot(epochs, loss, 'y', label='Training loss')\n",
        "plt.plot(epochs, val_loss, 'r', label='Validation loss')\n",
        "plt.title('Training and validation loss for 100 Epochs')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "acc = history2.history['accuracy']\n",
        "val_acc = history2.history['val_accuracy']\n",
        "\n",
        "plt.plot(epochs, acc, 'y', label='Training accuracy')\n",
        "plt.plot(epochs, val_acc, 'r', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracy for 100 Epochs')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Accuracy')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "iou = history2.history['iou_score']\n",
        "val_iou = history2.history['val_iou_score']\n",
        "\n",
        "plt.plot(epochs, iou, 'y', label='Training IoU Score')\n",
        "plt.plot(epochs, val_iou, 'r', label='Validation IoU Score')\n",
        "plt.title('Training and validation IoU Score for 100 Epochs')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('IoU Score')\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "cG9luo6FtYAE",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 888
        },
        "outputId": "5015b8b6-9633-4690-85d6-ff4c8057d0b9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "129/129 [==============================] - 404s 3s/step - loss: 0.7772 - accuracy: 0.9926 - iou_score: 0.8355 - val_loss: 0.8176 - val_accuracy: 0.9801 - val_iou_score: 0.6637\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEWCAYAAABxMXBSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5wU1Zn/8c/XAUQEUQGNOigYQcTAcBkxYhC8bTAaXPCKJkqMGnGNq1kTdU3UJfFnTEiirpesJl5jgpesRFfxhrCaYCKjAgqIAsEIKIsoCCLK5fn9UWfGppmBbqBnBuf7fr36RdWpU9XP6W7m6XNOdZUiAjMzs0Jt19ABmJnZtsWJw8zMiuLEYWZmRXHiMDOzojhxmJlZUZw4zMysKE4cjYSkcZLO3Np1G5KkeZKOKsFxQ9J+afnXkn5USN3NeJ7TJT21uXEaSBoq6W1JKyT1buh4GjNJIyT9uaHjKIQTxxZI/xmqH+skfZyzfnoxx4qIYyLi7q1d9/MuIs6LiB9v6XEkdUpJplnOse+LiH/a0mM3caOBCyKidUS8sqUHk3SypEmSVkqaWMv2kPRRzv/D3+Rsk6TrJC1Jj+skqY7nGZT+T6/IexyypW34PGi26SpWl4hoXb0saR5wdkQ8k19PUrOIWFOfsZnVpZ4/j/sA0zdnR0llEbE2r/h94HqgG3BEHbtWRMTsWsrPBf4ZqAACeBr4O/DrOo6zMCLKiw68CXCPowTSt5X5ki6V9C5wp6RdJP2PpMWSPkjL5Tn7TJR0dloeIenPkkanun+XdMxm1u0s6TlJyyU9I+lmSb+rI+5CYvyxpL+k4z0lqX3O9m9Keit9m7tiI6/PwZLelVSWUzZU0rS03E/SC5KWSnpH0k2SWtRxrLsk/SRn/ftpn4WSzsqre6ykVyR9mIZPrs7Z/Fz6d2n1N8v8oQNJ/SVNlrQs/du/0NemyNd5V0l3pjZ8IGlszrbjJU1JbZgjaXAqX29YUNLV1e+zPutNfVvSP4BnU/mD6X1Ylj4jB+bsv4OkX6T3c1n6jO0g6TFJ381rzzRJQ/PKtpe0AigDpkqak8oPSK/VUknTJQ3Jey9vlfS4pI+Aw/Nfu4h4JiIeABbW9tpuwpnALyJifkQsAH4BjNiM41S/39dKejG9F3+StGvO9iGpfUtT3QNytnWU9N/p/V8i6aa8Y9f1f3mEpLnp8/V3FTmqsTU5cZTOF4Bdyb5xnUv2Wt+Z1vcGPgZuqnNvOBiYBbQHfgb8Vqq9W72Jur8HXgTaAVcD39zIcxYS42nAt4DdgBbAJQCSugO3puPvmZ6v1m9rEfE34CPW/8Z4WooVYC1wcWrPIcCRwPkbiZsUw+AUz9FAFyB/fuUj4AxgZ+BYYKSkf07bDkv/7pyGVV7IO/auwGPAjaltvwQek9Qurw0bvDa12NTrfC/QCjgwHetXKYZ+wD3A91MbDgPm1fV61GIgcADw1bQ+jux12g14Gbgvp+5ooC/Qn+xz/ANgHXA38I3qSpIqgL3IXpsaEfFJTo+8IiK+KKk58CjwVHrO7wL3Sdo/Z9fTgGuANsDmjvc/lxLif0vqlFN+IDA1Z31qKttcZwBnAXsAa8g+G0jqCvwBuAjoADwOPCqphbIvS/8DvAV0InvtxuQcs9b/y5J2TMc/JiLakL0vU7Yg9i0TEX5shQfZf+Cj0vIg4FOg5Ubq9wI+yFmfSDbUBdm3oNk521qRda2/UExdsj9Ka4BWOdt/B/yuwDbVFuMPc9bPB55Iy1cCY3K27Zheg6PqOPZPgDvSchuyP+r71FH3IuDhnPUA9kvLdwE/Sct3AD/Nqdc1t24tx70e+FVa7pTqNsvZPgL4c1r+JvBi3v4vACM29doU8zqT/RFaB+xSS73/qo53Y5+/tH519fuc07Z9NxLDzqlOW7LE9jHZH/z8ei2BD4AuaX00cMtGjpv7Xg0A3gW2y9n+B+DqnPfyngJfs7OBibWUH0aWtHcmS8avVb+nZF9IuuXU7ZLiUy3HGZTeh6V5jx1z3u/cz1p3ss97GfAj4IGcbdsBC9IxDwEW537O8j5vdf1f3jE9/wnADoW8RqV8uMdROosjYlX1iqRWkv4rdf0/JBsa2Vk5wzV53q1eiIiVabF1kXX3BN7PKQN4u66AC4zx3ZzllTkx7Zl77Ij4CFhS13OR9S6GSdoeGAa8HBFvpTi6puGbd1Mc/4/sG9imrBcD2be63PYdLGlCGiJYBpxX4HGrj/1WXtlbZN8Yq9X12qxnE69zR7L37INadu0IzCkw3trUvDaSyiT9NA13fchnPZf26dGytudKn+n7gW9I2g4YTtZDKsSewNsRsS6nLP81rPPzWYiIeC4iPo2IpcC/Ap3JelkAK4CdcqrvBKyI9Fe6FgsjYue8x0d1xPoW0JzstVvvs5La+zZZOzsCb0Xdc0y1/l9Oz3sK2Wf2nTRk2K2OY5ScE0fp5H8Y/w3YHzg4Inbis6GRuoaftoZ3gF0ltcop67iR+lsS4zu5x07P2a6uyhExg+w/1zGsP0wF2ZDX62TfancC/n1zYiDrceX6PfAI0DEi2pJNilYfd1OXiV5INrSUa2+yb5LF2tjr/DbZe7ZzLfu9DXyxjmN+RPYNtdoXaqmT28bTgOPJhvPakvVKqmN4D1i1kee6GzidbAhxZeQN623EQqBjSjjV8l/DrX257uCz93g62cR4tQo2c+I+yf+srSZ77db7rKRh445k7Xwb2Fs5Z+8VKiKejIijyXqlrwO3b37oW8aJo/60Iev+L03j5VeV+gnTN/gq4Oo0vnoI8PUSxfgQcJykryibyB7Fpj9fvyf7VngY8GBeHB8CK9K3qpEFxvAAMEJS95S48uNvQ/ZtflWaLzgtZ9tisqGJfes49uNAV0mnSWom6RSy4Yn/KTC2/DhqfZ0j4h2yuYdblE2iN5dUnVh+C3xL0pGStpO0V863zinAqal+JXBiATF8QtYrbEXWq6uOYR3ZsN8vJe2ZeieHpN4hKVGsI5tcLrS3AfA3sp7YD1Kcg8g+j2M2uleOFEtLsjNCt5PUMs2dIOlASb1SndYpvgXAzLT7PcD30uu2J1kCv6uI+PN9I+ezNgp4KLKzwB4Ajk3vU/P0PJ8Ak8jmG98BfippxxT/oQW0e3dlJ0bsmI61guw9aBBOHPXnemAHsm8kfwWeqKfnPZ1sXHUJ2bzC/WQfvNpsdowRMR34F7Jk8A7ZOPj8Tez2B7IJ22cj4r2c8kvI/qgvJ/tWdX+BMYxLbXgWmJ3+zXU+MErScrI5mQdy9l1JNin7F2Vnwnw579hLgOPI/ggsIZssPi4v7kJt6nX+Jtm319eB/yOb4yEiXiSbfP8VsAz4Xz77Zvsjsh7CB8B/sH4Prjb3kPX4FgAzUhy5LgFeBSaTnQJ7Hev/vbgH6EE2Z1aQiPiULFEcQ9b2W4AzIuL1Qo9B9tp8TNYrHZCWq7957072WfkQmEvWizouIlan7f9FNjn/Ktncx2OprC57asPfcZyQs/1essTzLtnQ3oWpnbPITiD4z9TOrwNfT0Noa9P6fsA/yP6PnFJAu7cDvkfWm3mf7P9NoV+otjrVPbxnn0eS7gdej4iS93js80vSGcC5EfGVho6lISj78eHvIuI3m6r7eeQex+ecpIMkfTENbQwmG9ceu6n9zOqShmbOB25r6FisYThxfP59gezUwRVk54GPjK1w6QdrmiR9lWw+aBGbHg6zzykPVZmZWVHc4zAzs6I0iYsctm/fPjp16tTQYZiZbVNeeuml9yKiQ355k0gcnTp1oqqqqqHDMDPbpkjKv1oC4KEqMzMrkhOHmZkVxYnDzMyK0iTmOMzsM6tXr2b+/PmsWrVq05WtSWjZsiXl5eU0b968oPpOHGZNzPz582nTpg2dOnVCdd4bzJqKiGDJkiXMnz+fzp07F7SPh6rMmphVq1bRrl07Jw0DQBLt2rUrqgfqxGHWBDlpWK5iPw9OHGZmVhQnDjOrV0uWLKFXr1706tWLL3zhC+y11141659++ulG962qquLCCy/c5HP0799/a4VrtfDkuJnVq3bt2jFlyhQArr76alq3bs0ll1xSs33NmjU0a1b7n6bKykoqKys3+RyTJk3aOsHWo7Vr11JWVtbQYRTEPQ4za3AjRozgvPPO4+CDD+YHP/gBL774Iocccgi9e/emf//+zJo1C4CJEydy3HHHAVnSOeussxg0aBD77rsvN954Y83xWrduXVN/0KBBnHjiiXTr1o3TTz+d6iuCP/7443Tr1o2+ffty4YUX1hw317x58xgwYAB9+vShT58+6yWk6667jh49elBRUcFll10GwOzZsznqqKOoqKigT58+zJkzZ72YAS644ALuuusuILsc0qWXXkqfPn148MEHuf322znooIOoqKjghBNOYOXKlQAsWrSIoUOHUlFRQUVFBZMmTeLKK6/k+uuvrznuFVdcwQ033LDF70Uh3OMwa8LefPMiVqyYslWP2bp1L7p0uX7TFfPMnz+fSZMmUVZWxocffsjzzz9Ps2bNeOaZZ/j3f/93/vjHP26wz+uvv86ECRNYvnw5+++/PyNHjtzgtwivvPIK06dPZ8899+TQQw/lL3/5C5WVlXznO9/hueeeo3PnzgwfPrzWmHbbbTeefvppWrZsyZtvvsnw4cOpqqpi3Lhx/OlPf+Jvf/sbrVq14v333wfg9NNP57LLLmPo0KGsWrWKdevW8fbbb2+03e3atePll18GsmG8c845B4Af/vCH/Pa3v+W73/0uF154IQMHDuThhx9m7dq1rFixgj333JNhw4Zx0UUXsW7dOsaMGcOLL75Y9Ou+OZw4zKxROOmkk2qGapYtW8aZZ57Jm2++iSRWr15d6z7HHnss22+/Pdtvvz277bYbixYtory8fL06/fr1qynr1asX8+bNo3Xr1uy77741v1sYPnw4t9224Q0NV69ezQUXXMCUKVMoKyvjjTfeAOCZZ57hW9/6Fq1atQJg1113Zfny5SxYsIChQ4cC2Y/qCnHKKZ/dcvy1117jhz/8IUuXLmXFihV89atfBeDZZ5/lnnvuAaCsrIy2bdvStm1b2rVrxyuvvMKiRYvo3bs37dq1K+g5t5QTh1kTtjk9g1LZcccda5Z/9KMfcfjhh/Pwww8zb948Bg0aVOs+22+/fc1yWVkZa9as2aw6dfnVr37F7rvvztSpU1m3bl3BySBXs2bNWLduXc16/u8lcts9YsQIxo4dS0VFBXfddRcTJ07c6LHPPvts7rrrLt59913OOuusomPbXJ7jMLNGZ9myZey1114ANfMBW9P+++/P3LlzmTdvHgD3339/nXHssccebLfddtx7772sXbsWgKOPPpo777yzZg7i/fffp02bNpSXlzN27FgAPvnkE1auXMk+++zDjBkz+OSTT1i6dCnjx4+vM67ly5ezxx57sHr1au67776a8iOPPJJbb70VyCbRly1bBsDQoUN54oknmDx5ck3vpD6UNHFIGixplqTZki6rZfs+ksZLmiZpoqTynG3XSXotPU7JKb8vHfM1SXdIKuziKma2zfjBD37A5ZdfTu/evYvqIRRqhx124JZbbmHw4MH07duXNm3a0LZt2w3qnX/++dx9991UVFTw+uuv1/QOBg8ezJAhQ6isrKRXr16MHj0agHvvvZcbb7yRnj170r9/f9599106duzIySefzJe+9CVOPvlkevfuXWdcP/7xjzn44IM59NBD6datW035DTfcwIQJE+jRowd9+/ZlxowZALRo0YLDDz+ck08+uX7PyIqIkjyAMmAOsC/QApgKdM+r8yBwZlo+Arg3LR8LPE02lLYjMBnYKW37GqD0+AMwclOx9O3bN8wsM2PGjIYOoVFYvnx5RESsW7cuRo4cGb/85S8bOKLirV27NioqKuKNN97Y4mPV9rkAqqKWv6ml7HH0A2ZHxNyI+BQYAxyfV6c78GxanpCzvTvwXESsiYiPgGnAYICIeDynUS8C5ZiZFen222+nV69eHHjggSxbtozvfOc7DR1SUWbMmMF+++3HkUceSZcuXer1uUs5Ob4XkHse2nzg4Lw6U4FhwA3AUKCNpHap/CpJvwBaAYcDM3J3TENU3wT+tbYnl3QucC7A3nvvvaVtMbPPmYsvvpiLL764ocPYbN27d2fu3LkN8twNPTl+CTBQ0ivAQGABsDYingIeByaRDUe9AKzN2/cWsl7J87UdOCJui4jKiKjs0GGDe62bmdlmKmXiWAB0zFkvT2U1ImJhRAyLiN7AFalsafr3mojoFRFHk81nvFG9n6SrgA7A90oYv5mZ1aKUiWMy0EVSZ0ktgFOBR3IrSGovqTqGy4E7UnlZGrJCUk+gJ/BUWj8b+CowPCLWYWZm9apkiSMi1gAXAE8CM4EHImK6pFGShqRqg4BZkt4AdgeuSeXNgeclzQBuA76Rjgfw61T3BUlTJF1ZqjaYmdmGSjrHkc6A6hoRX4yIa1LZlRHxSFp+KCK6pDpnR8QnqXxVRHRPjy9HxJScYzZLx+uVHqNK2QYz27oOP/xwnnzyyfXKrr/+ekaOHFnnPoMGDaKqqgqAr33tayxdunSDOldffXXN7ynqMnbs2JrfQABceeWVPPPMM8WEbzT85LiZNTHDhw9nzJgx65WNGTOmzgsN5nv88cfZeeedN+u58xPHqFGjOOqoozbrWA2l+tfrDcmJw8zq1Yknnshjjz1Wc9OmefPmsXDhQgYMGMDIkSOprKzkwAMP5Kqrrqp1/06dOvHee+8BcM0119C1a1e+8pWv1Fx6Haj18uSTJk3ikUce4fvf/z69evVizpw5jBgxgoceegiA8ePH07t3b3r06MFZZ53FJ598UvN8V111FX369KFHjx68/vrrG8TU1C6/7oscmjVlF10EU7buZdXp1Quur/viibvuuiv9+vVj3LhxHH/88YwZM4aTTz4ZSVxzzTXsuuuurF27liOPPJJp06bRs2fPWo/z0ksvMWbMGKZMmcKaNWvo06cPffv2BWDYsGG1Xp58yJAhHHfccZx44onrHWvVqlWMGDGC8ePH07VrV8444wxuvfVWLrroIgDat2/Pyy+/zC233MLo0aP5zW9+s97+Te3y6+5xmFm9yx2uyh2meuCBB+jTpw+9e/dm+vTp6w0r5Xv++ecZOnQorVq1YqeddmLIkCE121577TUGDBhAjx49uO+++5g+ffpG45k1axadO3ema9euAJx55pk899xzNduHDRsGQN++fWsujJhr9erVnHPOOfTo0YOTTjqpJu5CL79evX1j8i+/Xlv7nn322Zq5ourLr3fq1Knm8utPPfXUVrn8unscZk3ZRnoGpXT88cdz8cUX8/LLL7Ny5Ur69u3L3//+d0aPHs3kyZPZZZddGDFixAaXIC9UsZcn35TqS7PXdVn2pnb5dfc4zKzetW7dmsMPP5yzzjqrprfx4YcfsuOOO9K2bVsWLVrEuHHjNnqMww47jLFjx/Lxxx+zfPlyHn300ZptdV2evE2bNixfvnyDY+2///7MmzeP2bNnA9lVbgcOHFhwe5ra5dedOMysQQwfPpypU6fWJI6Kigp69+5Nt27dOO200zj00EM3un+fPn045ZRTqKio4JhjjuGggw6q2VbX5clPPfVUfv7zn9O7d2/mzJlTU96yZUvuvPNOTjrpJHr06MF2223HeeedV3Bbmtrl1xXpxu2fZ5WVlVF9DrhZUzdz5kwOOOCAhg7D6tG6detqzsiq60q6tX0uJL0UEZX5dd3jMDP7HCvF5dc9OW5m9jlWisuvu8dh1gQ1hSFqK1yxnwcnDrMmpmXLlixZssTJw4AsaSxZsqSoU4g9VGXWxJSXlzN//nwWL17c0KFYI9GyZUvKywu/C7cTh1kT07x5czp37tzQYdg2zENVZmZWFCcOMzMrihOHmZkVxYnDzMyK4sRhZmZFceIwM7OiOHGYmVlRnDjMzKwoThxmZlaUkiYOSYMlzZI0W9JltWzfR9J4SdMkTZRUnrPtOkmvpccpOeWdJf0tHfN+SS1K2QYzM1tfyRKHpDLgZuAYoDswXFL3vGqjgXsioicwCrg27Xss0AfoBRwMXCJpp7TPdcCvImI/4APg26Vqg5mZbaiUPY5+wOyImBsRnwJjgOPz6nQHnk3LE3K2dweei4g1EfERMA0YLEnAEcBDqd7dwD+XsA1mZpanlIljL+DtnPX5qSzXVGBYWh4KtJHULpUPltRKUnvgcKAj0A5YGhFrNnJMACSdK6lKUpWvAmpmtvU09OT4JcBASa8AA4EFwNqIeAp4HJgE/AF4AVhbzIEj4raIqIyIyg4dOmzlsM3Mmq5SJo4FZL2EauWprEZELIyIYRHRG7gilS1N/14TEb0i4mhAwBvAEmBnSc3qOqaZmZVWKRPHZKBLOguqBXAq8EhuBUntJVXHcDlwRyovS0NWSOoJ9ASeiuyWZROAE9M+ZwJ/KmEbzMwsT8kSR5qHuAB4EpgJPBAR0yWNkjQkVRsEzJL0BrA7cE0qbw48L2kGcBvwjZx5jUuB70maTTbn8dtStcHMzDakpnDf4crKyqiqqmroMMzMtimSXoqIyvzyhp4cNzOzbYwTh5mZFcWJw8zMiuLEYWZmRXHiMDOzojhxmJlZUZw4zMysKE4cZmZWFCcOMzMrihOHmZkVxYnDzMyK4sRhZmZFceIwM7OiOHGYmVlRnDjMzKwoThxmZlYUJw4zMyuKE4eZmRXFicPMzIrixGFmZkVx4jAzs6I4cZiZWVFKmjgkDZY0S9JsSZfVsn0fSeMlTZM0UVJ5zrafSZouaaakGyUplQ+X9Gra5wlJ7UvZBjMzW1/JEoekMuBm4BigOzBcUve8aqOBeyKiJzAKuDbt2x84FOgJfAk4CBgoqRlwA3B42mcacEGp2mBmZhsqZY+jHzA7IuZGxKfAGOD4vDrdgWfT8oSc7QG0BFoA2wPNgUWA0mPH1APZCVhYwjaYmVmeUiaOvYC3c9bnp7JcU4FhaXko0EZSu4h4gSyRvJMeT0bEzIhYDYwEXiVLGN2B35auCWZmlq+hJ8cvIRuCegUYCCwA1kraDzgAKCdLNkdIGiCpOVni6A3sSTZUdXltB5Z0rqQqSVWLFy+uh6aYmTUNpUwcC4COOevlqaxGRCyMiGER0Ru4IpUtJet9/DUiVkTECmAccAjQK9WZExEBPAD0r+3JI+K2iKiMiMoOHTps5aaZmTVdpUwck4EukjpLagGcCjySW0FSe0nVMVwO3JGW/0GaDE+9jIHATLLE011SdSY4OpWbmVk9aVaqA0fEGkkXAE8CZcAdETFd0iigKiIeAQYB10oK4DngX9LuDwFHkM1lBPBERDwKIOk/gOckrQbeAkaUqg1mZrYhZSM+n2+VlZVRVVXV0GGYmW1TJL0UEZX55ZscqpL09ZzhJDMza+IKSQinAG+mX3J3K3VAZmbWuG0ycUTEN8hOf50D3CXphXSqa5uSR2dmZo1OQUNQEfEh2YT1GGAPstNlX5b03RLGZmZmjVAhcxxDJD0MTCS79Ee/iDgGqAD+rbThmZlZY1PI6bgnAL+KiOdyCyNipaRvlyYsMzNrrApJHFeTXS8KAEk7ALtHxLyIGF+qwMzMrHEqZI7jQWBdzvraVGZmZk1QIYmjWbosOgBpuUXpQjIzs8askMSxWNKQ6hVJxwPvlS4kMzNrzAqZ4zgPuE/STWQ3UXobOKOkUZmZWaO1ycQREXOAL0tqndZXlDwqMzNrtAq6Oq6kY4EDgZbZHVshIkaVMC4zM2ukCvkB4K/Jrlf1XbKhqpOAfUocl5mZNVKFTI73j4gzgA8i4j/I7sTXtbRhmZlZY1VI4liV/l0paU9gNdn1qszMrAkqZI7jUUk7Az8HXia7I9/tJY3KzMwarY0mjnQDp/ERsRT4o6T/AVpGxLJ6ic7MzBqdjQ5VRcQ64Oac9U+cNMzMmrZC5jjGSzpB1efhmplZk1ZI4vgO2UUNP5H0oaTlkj4scVxmZtZIFfLLcd8i1szMamwycUg6rLby/Bs7mZlZ01DI6bjfz1luCfQDXgKO2NSOkgYDNwBlwG8i4qd52/cB7gA6AO8D34iI+Wnbz4BjyYbTngb+NSJCUgvgJmAQ2X1CroiIPxbQDjMz2woKGar6eu66pI7A9ZvaT1IZ2RlZRwPzgcmSHomIGTnVRgP3RMTdko4ArgW+Kak/cCjQM9X7MzCQ7L7nVwD/FxFd0+nCu24qFjMz23oKushhnvnAAQXU6wfMjoi5AJLGAMcDuYmjO/C9tDwBGJuWg6x304Ls+ljNgUVp21lAN6g5Xdj3BjEzq0eFzHH8J9kfcsiGjXqR/YJ8U/Yiu3dHtfnAwXl1pgLDyIazhgJtJLWLiBckTSC717mAmyJiZvoFO8CPJQ0C5gAXRMSivOMi6VzgXIC99967gHDNzKwQhZyOW0U2p/ES8AJwaUR8Yys9/yXAQEmvkA1FLQDWStqPrFdTTpaAjpA0gCzRlQOTIqJPimd0bQeOiNsiojIiKjt06LCVwjUzs0KGqh4CVkXEWsjmLiS1ioiVm9hvAdAxZ708ldWIiIVkPQ7SjaJOiIilks4B/lp90yhJ48iuyvtnYCXw3+kQDwLfLqANZma2lRT0y3Fgh5z1HYBnCthvMtBFUud0JtSpwCO5FSS1TxPcAJeTnWEF8A+ynkgzSc3JeiMzIyKAR8nOqAI4kvXnTMzMrMQKSRwtc28Xm5ZbbWqniFgDXAA8CcwEHoiI6ZJGSRqSqg0CZkl6A9gduCaVP0Q2f/Eq2TzI1Ih4NG27FLha0jTgm8C/FdAGMzPbSgoZqvpIUp+IeBlAUl/g40IOHhGPA4/nlV2Zs/wQWZLI328t2aVOajvmW0CtP0o0M7PSKyRxXAQ8KGkh2RlOXyC7layZmTVBhfwAcLKkbsD+qWhWRKwubVhmZtZYbXKOQ9K/ADtGxGsR8RrQWtL5pQ/NzMwao0Imx89JdwAEICI+AM4pXUhmZtaYFZI4ynJv4pSuQdWidCGZmVljVsjk+BPA/ZL+K61/BxhXupDMzKwxKyRxXEp2zafz0vo0sjOrzMysCdrkUFW6Au3fgHlkV7w9guwHfWZm1gTV2eOQ1BUYnh7vARO5SkMAAAx9SURBVPcDRMTh9ROamZk1RhsbqnodeB44LiJmA0i6uF6iMjOzRmtjQ1XDyO6HMUHS7ZKOJPvluJmZNWF1Jo6IGBsRp5LdbW8C2aVHdpN0q6R/qq8AzcyscSlkcvyjiPh9uvd4OfAK2ZlWZmbWBBXyA8AaEfFBurPekaUKyMzMGreiEoeZmZkTh5mZFcWJw8zMiuLEYWZmRXHiMDOzojhxmJlZUZw4zMysKE4cZmZWFCcOMzMrSkkTh6TBkmZJmi3pslq27yNpvKRpkiZKKs/Z9jNJ0yXNlHRj7u1r0/ZHJL1WyvjNzGxDJUsc6d7kNwPHAN2B4ZK651UbDdwTET2BUcC1ad/+wKFAT+BLwEHAwJxjDwNWlCp2MzOrWyl7HP2A2RExNyI+BcYAx+fV6Q48m5Yn5GwPoCXQAtgeaA4sApDUGvge8JMSxm5mZnUoZeLYC3g7Z31+Kss1ley+HwBDgTaS2kXEC2SJ5J30eDIiqm9X+2PgF8DKjT25pHMlVUmqWrx48Za1xMzMajT05PglwEBJr5ANRS0A1kraDziA7DLuewFHSBogqRfwxYh4eFMHTlfxrYyIyg4dOpSwCWZmTcvGbh27pRYAHXPWy1NZjYhYSOpxpCGoEyJiqaRzgL9GxIq0bRxwCLAcqJQ0L8W+m6SJETGohO0wM7McpexxTAa6SOosqQVwKvBIbgVJ7SVVx3A5cEda/gdZT6SZpOZkvZGZEXFrROwZEZ2ArwBvOGmYmdWvkiWOiFgDXAA8CcwEHoiI6ZJGSRqSqg0CZkl6A9gduCaVPwTMAV4lmweZGhGPlipWMzMrnCKioWMoucrKyqiqqmroMMzMtimSXoqIyvzyhp4cNzOzbYwTh5mZFcWJw8zMiuLEYWZmRXHiMDOzojhxmJlZUZw4zMysKE4cZmZWFCcOMzMrihOHmZkVxYnDzMyK4sRhZmZFceIwM7OiOHGYmVlRnDjMzKwoThxmZlYUJw4zMyuKE4eZmRXFicPMzIrixGFmZkVx4jAzs6I4cZiZWVFKmjgkDZY0S9JsSZfVsn0fSeMlTZM0UVJ5zrafSZouaaakG5VpJekxSa+nbT8tZfxmZrahkiUOSWXAzcAxQHdguKTuedVGA/dERE9gFHBt2rc/cCjQE/gScBAwsHqfiOgG9AYOlXRMqdpgZmYbKmWPox8wOyLmRsSnwBjg+Lw63YFn0/KEnO0BtARaANsDzYFFEbEyIiYApGO+DJRjZmb1ppSJYy/g7Zz1+aks11RgWFoeCrSR1C4iXiBLJO+kx5MRMTN3R0k7A18Hxtf25JLOlVQlqWrx4sVb3BgzM8s09OT4JcBASa+QDUUtANZK2g84gKw3sRdwhKQB1TtJagb8AbgxIubWduCIuC0iKiOiskOHDqVuh5lZk9GshMdeAHTMWS9PZTUiYiGpxyGpNXBCRCyVdA7w14hYkbaNAw4Bnk+73ga8GRHXlzB+MzOrRSl7HJOBLpI6S2oBnAo8kltBUntJ1TFcDtyRlv9B1hNpJqk5WW9kZtrnJ0Bb4KISxm5mZnUoWeKIiDXABcCTZH/0H4iI6ZJGSRqSqg0CZkl6A9gduCaVPwTMAV4lmweZGhGPptN1ryCbVH9Z0hRJZ5eqDWZmtiFFREPHUHKVlZVRVVXV0GGYmW1TJL0UEZX55Q09OW5mZtsYJw4zMyuKE4eZmRXFicPMzIrixGFmZkVx4jAzs6I4cZiZWVGcOMzMrChOHGZmVhQnDjMzK4oTh5mZFcWJw8zMiuLEYWZmRXHiMDOzojhxmJlZUZw4zMysKE4cZmZWFCcOMzMrihOHmZkVxYnDzMyK4sRhZmZFceIwM7OiOHGYmVlRSpo4JA2WNEvSbEmX1bJ9H0njJU2TNFFSec62n0maLmmmpBslKZX3lfRqOmZNuZmZ1Y+SJQ5JZcDNwDFAd2C4pO551UYD90RET2AUcG3atz9wKNAT+BJwEDAw7XMrcA7QJT0Gl6oNZma2oVL2OPoBsyNibkR8CowBjs+r0x14Ni1PyNkeQEugBbA90BxYJGkPYKeI+GtEBHAP8M8lbIOZmeUpZeLYC3g7Z31+Kss1FRiWlocCbSS1i4gXyBLJO+nxZETMTPvP38QxAZB0rqQqSVWLFy/e4saYmVmmoSfHLwEGSnqFbChqAbBW0n7AAUA5WWI4QtKAYg4cEbdFRGVEVHbo0GFrx21m1mQ1K+GxFwAdc9bLU1mNiFhI6nFIag2cEBFLJZ0D/DUiVqRt44BDgHvTceo8ppmZlVYpexyTgS6SOktqAZwKPJJbQVJ7SdUxXA7ckZb/QdYTaSapOVlvZGZEvAN8KOnL6WyqM4A/lbANZmaWp2SJIyLWABcATwIzgQciYrqkUZKGpGqDgFmS3gB2B65J5Q8Bc4BXyeZBpkbEo2nb+cBvgNmpzrhStcHMzDak7OSkz7fKysqoqqpq6DDMzLYpkl6KiMr88oaeHDczs22ME4eZmRWlSQxVSVoMvNXQcRSpPfBeQwdRz9zmpsFt3nbsExEb/J6hSSSObZGkqtrGFj/P3OamwW3e9nmoyszMiuLEYWZmRXHiaLxua+gAGoDb3DS4zds4z3GYmVlR3OMwM7OiOHGYmVlRnDgawBbeUndvSU+lW+rOkNSpPmPfXKW4jXBjJukOSf8n6bU6tiu1ZXZqc5+cbWdKejM9zqy/qLfM5rZZUi9JL6T3eJqkU+o38s23Je9z2r6TpPmSbqqfiLeSiPCjHh9AGdnFGfclu8PhVKB7Xp0HgTPT8hHAvTnbJgJHp+XWQKuGblMp2wz0B/6SjlEGvAAMaug2FdDmw4A+wGt1bP8a2QU6BXwZ+Fsq3xWYm/7dJS3v0tDtKXGbuwJd0vKeZDdv27mh21PKNudsvwH4PXBTQ7elmId7HPVvs2+pm+7Z3iwingaIiBURsbJ+wt4iW/02wiWPeAtFxHPA+xupcjxwT2T+Cuycbo38VeDpiHg/Ij4AngYGlz7iLbe5bY6INyLizXSMhcD/AdvE3de24H1GUl+yq4I/VfpIty4njvq32bfUJftmtlTSf0t6RdLPJZWVPOItV4rbCG/r6npNCnmttlWbbJukfmRfEubUY1ylVGub032IfkF2F9RtjhNH41TrLXXJ7tg4IG0/iGzoZ0QDxbi1lew2wrZtSN/E7wW+FRHrGjqeEjsfeDwi5jd0IJujlLeOtdptyS115wNTImJu2jaWbNz0t/UR+BYoxW2En6+PwEuortdkAdkNznLLJ9ZbVKVV5+dA0k7AY8AVaUjn86KuNh8CDJB0PtlcZQtJKyJigxNHGiP3OOrfltxSdzLZGGn1+O8RwIx6iHlLbfXbCNdT3KX0CHBGOuvmy8CyyG6N/CTwT5J2kbQL8E+p7POg1janz8TDZHMBDzVsiFtdrW2OiNMjYu+I6ETW275nW0ka4B5HvYuINZKqb6lbBtwR6Za6QFVEPEL2jfNaSQE8B/xL2netpEuA8emU1JeA2xuiHcXYkjaT3Ub4CLLbCAfwRHx2G+FGS9IfyNrUPvUUryKb2Ccifg08TnbGzWxgJfCttO19ST8mS7YAoyJiY5Ovjcbmthk4mezspHaSRqSyERExpd6C30xb0OZtmi85YmZmRfFQlZmZFcWJw8zMiuLEYWZmRXHiMDOzojhxmJlZUZw4zDaTpLWSpuQ8ttp5+JI61XXFVbOG5t9xmG2+jyOiV0MHYVbf3OMw28okzVN2D5FXJb2YrrdV3Yt4Nt2XYbykvVP57pIeljQ1PfqnQ5VJuj3dp+IpSTuk+hcquxfLNEljGqiZ1oQ5cZhtvh3yhqpyb0C0LCJ6ADcB16ey/wTujoiewH3Ajan8RuB/I6KC7N4O01N5F+DmiDgQWAqckMovA3qn45xXqsaZ1cW/HDfbTOmidK1rKZ8HHBERc9P1td6NiHaS3gP2iIjVqfydiGgvaTFQHhGf5ByjE9l9Obqk9UuB5hHxE0lPACuAscDY6gtAmtUX9zjMSiPqWC7GJznL1ZfVBzgWuJmsdzJZkucqrV45cZiVxik5/76QlieRXRkY4HQ+uzT8eGAkgKQySW3rOmi6gnDHiJgAXAq0Jbsst1m98TcVs823g6TcK7g+kXNp7F0kTSPrNQxPZd8F7pT0fWAxn10p9V+B2yR9m6xnMZLsboe1KQN+l5KLgBsjYulWa5FZATzHYbaVpTmOyoh4r6FjMSsFD1WZmVlR3OMwM7OiuMdhZmZFceIwM7OiOHGYmVlRnDjMzKwoThxmZlaU/w+wwP3plmw6BwAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# my_model = load_model(TEST_SAVE + 'saved models/brats_3d_150.hdf5',\n",
        "#                       custom_objects={'dice_loss_plus_1focal_loss': total_loss,\n",
        "#                                       'iou_score':sm.metrics.IOUScore(threshold=0.5)},\n",
        "#                       compile=True)\n",
        "\n",
        "\n",
        "# history2=my_model.fit(train_img_datagen,\n",
        "#           steps_per_epoch=steps_per_epoch,\n",
        "#           epochs=50,\n",
        "#           verbose=1,\n",
        "#           validation_data=val_img_datagen,\n",
        "#           validation_steps=val_steps_per_epoch,\n",
        "#           )\n",
        "\n",
        "\n",
        "# my_model.save(TEST_SAVE + 'saved models/brats_3d_200.hdf5')\n",
        "\n",
        "# loss = history2.history['loss']\n",
        "# val_loss = history2.history['val_loss']\n",
        "# epochs = range(1, len(loss) + 1)\n",
        "# plt.plot(epochs, loss, 'y', label='Training loss')\n",
        "# plt.plot(epochs, val_loss, 'r', label='Validation loss')\n",
        "# plt.title('Training and validation loss for 200 Epochs')\n",
        "# plt.xlabel('Epochs')\n",
        "# plt.ylabel('Loss')\n",
        "# plt.legend()\n",
        "# plt.show()\n",
        "\n",
        "# acc = history2.history['accuracy']\n",
        "# val_acc = history2.history['val_accuracy']\n",
        "\n",
        "# plt.plot(epochs, acc, 'y', label='Training accuracy')\n",
        "# plt.plot(epochs, val_acc, 'r', label='Validation accuracy')\n",
        "# plt.title('Training and validation accuracy for 200 Epochs')\n",
        "# plt.xlabel('Epochs')\n",
        "# plt.ylabel('Accuracy')\n",
        "# plt.legend()\n",
        "# plt.show()\n",
        "\n",
        "# iou = history2.history['iou_score']\n",
        "# val_iou = history2.history['val_iou_score']\n",
        "\n",
        "# plt.plot(epochs, iou, 'y', label='Training IoU Score')\n",
        "# plt.plot(epochs, val_iou, 'r', label='Validation IoU Score')\n",
        "# plt.title('Training and validation IoU Score for 200 Epochs')\n",
        "# plt.xlabel('Epochs')\n",
        "# plt.ylabel('IoU Score')\n",
        "# plt.legend()\n",
        "# plt.show()\n"
      ],
      "metadata": {
        "id": "jqDqxkoxNTj1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_model = load_model(TEST_SAVE + 'saved models/brats_3d_100_updated.hdf5',\n",
        "                      compile=False)\n",
        "\n",
        "batch_size=8 #Check IoU for a batch of images\n",
        "test_img_datagen = imageLoader(val_img_dir, val_img_list,\n",
        "                                val_mask_dir, val_mask_list, batch_size)\n",
        "\n",
        "#Verify generator.... In python 3 next() is renamed as __next__()\n",
        "test_image_batch, test_mask_batch = test_img_datagen.__next__()\n",
        "\n",
        "test_mask_batch_argmax = np.argmax(test_mask_batch, axis=4)\n",
        "test_pred_batch = my_model.predict(test_image_batch)\n",
        "test_pred_batch_argmax = np.argmax(test_pred_batch, axis=4)\n",
        "\n",
        "n_classes = 4\n",
        "IOU_keras = MeanIoU(num_classes=n_classes)\n",
        "IOU_keras.update_state(test_pred_batch_argmax, test_mask_batch_argmax)\n",
        "print(\"Mean IoU =\", IOU_keras.result().numpy())"
      ],
      "metadata": {
        "id": "O40tyHQLS8Yq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e617ec45-9fe2-484e-ee20-4feab370dbcc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean IoU = 0.69678193\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "img_num = 359\n",
        "\n",
        "test_img = np.load(TEST_SAVE + \"input_data_128/val/images/image_\"+str(img_num)+\".npy\")\n",
        "\n",
        "test_mask = np.load(TEST_SAVE + \"input_data_128/val/masks/mask_\"+str(img_num)+\".npy\")\n",
        "test_mask_argmax=np.argmax(test_mask, axis=3)\n",
        "\n",
        "test_img_input = np.expand_dims(test_img, axis=0)\n",
        "test_prediction = my_model.predict(test_img_input)\n",
        "test_prediction_argmax=np.argmax(test_prediction, axis=4)[0,:,:,:]\n",
        "\n",
        "\n",
        "# print(test_prediction_argmax.shape)\n",
        "# print(test_mask_argmax.shape)\n",
        "# print(np.unique(test_prediction_argmax))\n",
        "\n",
        "\n",
        "#Plot individual slices from test predictions for verification\n",
        "from matplotlib import pyplot as plt\n",
        "import random\n",
        "\n",
        "#n_slice=random.randint(0, test_prediction_argmax.shape[2])\n",
        "n_slice = 55\n",
        "plt.figure(figsize=(12, 8))\n",
        "plt.subplot(231)\n",
        "plt.title('Testing Image')\n",
        "plt.imshow(test_img[:,:,n_slice,1], cmap='gray')\n",
        "plt.subplot(232)\n",
        "plt.title('Testing Label')\n",
        "plt.imshow(test_mask_argmax[:,:,n_slice])\n",
        "plt.subplot(233)\n",
        "plt.title('Prediction on test image')\n",
        "plt.imshow(test_prediction_argmax[:,:, n_slice])\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "TQcGtpy8UYjF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 261
        },
        "outputId": "0e6b696b-ac0b-46e6-d127-e4e9f518f540"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x576 with 3 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}