Segment_Anything_Model.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Imports "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import os\n",
    "import numpy as np\n",
    "import PIL\n",
    "from datasets import Image, Dataset\n",
    "from datasets import load_dataset   \n",
    "import pandas as pd\n",
    "import os\n",
    "import winsound\n",
    "from transformers import SamProcessor\n",
    "import chime\n",
    "from tqdm import tqdm\n",
    "from statistics import mean\n",
    "import torch\n",
    "from torch.nn.functional import threshold, normalize\n",
    "from torch.utils.data import Dataset\n",
    "from transformers import SamProcessor\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.optim import Adam\n",
    "import monai\n",
    "from transformers import SamModel \n",
    "import json\n",
    "import torch\n",
    "import os\n",
    "import shutil\n",
    "import functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.11.3 | packaged by Anaconda, Inc. | (main, Apr 19 2023, 23:46:34) [MSC v.1916 64 bit (AMD64)]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Checking Gpu"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pytorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(torch.cuda.is_available())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The provided segmentation labels have values of:\n",
    "\n",
    "    1 for NCR\n",
    "    2 for ED\n",
    "    3 for ET\n",
    "    0 for everything else.\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TRANSFORMES"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the attention mechanism was introduced to improve the performance of the encoder-decoder model for machine translation.  \n",
    "The idea behind the attention mechanism was to **permit the decoder** to utilize the most relevant parts of the input sequence in a flexible manner, by a weighted combination of all the encoded input vectors, with the most relevant vectors being attributed the <mark>highest weights</mark>. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this project we are going to use transformers instead of fully convolutional networks or a mixture of the two architectures."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Segment anything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 23.1.2 -> 23.2.1\n",
      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "%pip install -q git+https://github.com/huggingface/transformers.git"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 23.1.2 -> 23.2.1\n",
      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "%pip install -q datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "[notice] A new release of pip is available: 23.1.2 -> 23.2.1\n",
      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
     ]
    }
   ],
   "source": [
    "%pip install -q monai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>image_name</th>\n",
       "      <th>patient_id</th>\n",
       "      <th>time_stamp</th>\n",
       "      <th>scan_type</th>\n",
       "      <th>split</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Slice_dim0_118.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>seg</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Slice_dim1_113.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>t1c</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Slice_dim1_112.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>t1c</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Slice_dim1_111.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>t1c</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Slice_dim1_110.png</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>t1c</td>\n",
       "      <td>train</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1677973</th>\n",
       "      <td>Slice_dim2_98.png</td>\n",
       "      <td>1790</td>\n",
       "      <td>0</td>\n",
       "      <td>t1c</td>\n",
       "      <td>test</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1677974</th>\n",
       "      <td>Slice_dim2_97.png</td>\n",
       "      <td>1790</td>\n",
       "      <td>0</td>\n",
       "      <td>t1c</td>\n",
       "      <td>test</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1677975</th>\n",
       "      <td>Slice_dim2_96.png</td>\n",
       "      <td>1790</td>\n",
       "      <td>0</td>\n",
       "      <td>t1c</td>\n",
       "      <td>test</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1677976</th>\n",
       "      <td>Slice_dim0_103.png</td>\n",
       "      <td>1790</td>\n",
       "      <td>0</td>\n",
       "      <td>t1n</td>\n",
       "      <td>test</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1677977</th>\n",
       "      <td>Slice_dim2_99.png</td>\n",
       "      <td>1790</td>\n",
       "      <td>0</td>\n",
       "      <td>t2w</td>\n",
       "      <td>test</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1677978 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                 image_name  patient_id  time_stamp scan_type  split\n",
       "0        Slice_dim0_118.png           0           0       seg  train\n",
       "1        Slice_dim1_113.png           0           0       t1c  train\n",
       "2        Slice_dim1_112.png           0           0       t1c  train\n",
       "3        Slice_dim1_111.png           0           0       t1c  train\n",
       "4        Slice_dim1_110.png           0           0       t1c  train\n",
       "...                     ...         ...         ...       ...    ...\n",
       "1677973   Slice_dim2_98.png        1790           0       t1c   test\n",
       "1677974   Slice_dim2_97.png        1790           0       t1c   test\n",
       "1677975   Slice_dim2_96.png        1790           0       t1c   test\n",
       "1677976  Slice_dim0_103.png        1790           0       t1n   test\n",
       "1677977   Slice_dim2_99.png        1790           0       t2w   test\n",
       "\n",
       "[1677978 rows x 5 columns]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read the csv file\n",
    "data = pd.read_csv(r'C:\\Users\\bouhe\\OneDrive\\Bureau\\pfe\\dataset\\png_format\\metadata.csv')\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method NDFrame.sample of                  image_name  patient_id  time_stamp scan_type  split\n",
       "0        Slice_dim0_118.png           0           0       seg  train\n",
       "677       Slice_dim1_62.png           0           0       seg  train\n",
       "678       Slice_dim1_87.png           0           0       seg  train\n",
       "679       Slice_dim1_88.png           0           0       seg  train\n",
       "680       Slice_dim1_89.png           0           0       seg  train\n",
       "...                     ...         ...         ...       ...    ...\n",
       "1477663   Slice_dim2_94.png        1666           0       seg  train\n",
       "1477683  Slice_dim1_107.png        1666           0       seg  train\n",
       "1477684  Slice_dim1_103.png        1666           0       seg  train\n",
       "1477685   Slice_dim1_93.png        1666           0       seg  train\n",
       "1477741  Slice_dim1_108.png        1666           0       seg  train\n",
       "\n",
       "[257445 rows x 5 columns]>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_t_gt = data.loc[(data['split'] == 'train') & (data['scan_type'] == 'seg')]\n",
    "d_t_gt.sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method NDFrame.sample of                  image_name  patient_id  time_stamp scan_type  split\n",
       "0        Slice_dim0_118.png           0           0       seg  train\n",
       "677       Slice_dim1_62.png           0           0       seg  train\n",
       "678       Slice_dim1_87.png           0           0       seg  train\n",
       "679       Slice_dim1_88.png           0           0       seg  train\n",
       "680       Slice_dim1_89.png           0           0       seg  train\n",
       "...                     ...         ...         ...       ...    ...\n",
       "1090495  Slice_dim0_147.png        1173           0       seg  train\n",
       "1090496  Slice_dim0_146.png        1173           0       seg  train\n",
       "1090497  Slice_dim0_145.png        1173           0       seg  train\n",
       "1090498  Slice_dim0_144.png        1173           0       seg  train\n",
       "1090519  Slice_dim0_160.png        1173           0       seg  train\n",
       "\n",
       "[180094 rows x 5 columns]>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_t_gt = d_t_gt[d_t_gt['patient_id'] <= 1173]\n",
    "d_t_gt.sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method NDFrame.sample of                  image_name  patient_id  time_stamp scan_type  split\n",
       "1        Slice_dim1_113.png           0           0       t1c  train\n",
       "2        Slice_dim1_112.png           0           0       t1c  train\n",
       "3        Slice_dim1_111.png           0           0       t1c  train\n",
       "4        Slice_dim1_110.png           0           0       t1c  train\n",
       "5        Slice_dim1_109.png           0           0       t1c  train\n",
       "...                     ...         ...         ...       ...    ...\n",
       "1091089  Slice_dim0_157.png        1173           0       t2f  train\n",
       "1091090  Slice_dim0_160.png        1173           0       t2f  train\n",
       "1091091  Slice_dim0_159.png        1173           0       t2f  train\n",
       "1091092  Slice_dim0_158.png        1173           0       t2f  train\n",
       "1091093  Slice_dim0_165.png        1173           0       t2f  train\n",
       "\n",
       "[720375 rows x 5 columns]>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_t_im = data.loc[(data['split'] == 'train') & ((data['scan_type'] == 't1c') | ( data['scan_type'] == 't1n') | (data['scan_type'] == 't2f') | (data['scan_type'] == 't2w'))]\n",
    "d_t_im = d_t_im[d_t_im['patient_id'] <= 1173]\n",
    "d_t_im.sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method NDFrame.sample of Empty DataFrame\n",
       "Columns: [image_name, patient_id, time_stamp, scan_type, split]\n",
       "Index: []>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_test_gt = d_t_gt[d_t_gt['patient_id'] > 1173]\n",
    "d_test_gt.sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method NDFrame.sample of                  image_name  patient_id  time_stamp scan_type  split\n",
       "1091094  Slice_dim0_164.png        1174           0       t1c  train\n",
       "1091095  Slice_dim0_163.png        1174           0       t1c  train\n",
       "1091096  Slice_dim0_162.png        1174           0       t1c  train\n",
       "1091097  Slice_dim0_161.png        1174           0       t1c  train\n",
       "1091098  Slice_dim0_157.png        1174           0       t1c  train\n",
       "...                     ...         ...         ...       ...    ...\n",
       "1477840   Slice_dim1_92.png        1666           0       t1n  train\n",
       "1477841  Slice_dim2_105.png        1666           0       t1n  train\n",
       "1477842   Slice_dim1_94.png        1666           0       t1n  train\n",
       "1477843   Slice_dim1_95.png        1666           0       t1n  train\n",
       "1477844   Slice_dim1_93.png        1666           0       t1n  train\n",
       "\n",
       "[309400 rows x 5 columns]>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_test_im = data.loc[(data['split'] == 'train') & ((data['scan_type'] == 't1c') | ( data['scan_type'] == 't1n') | (data['scan_type'] == 't2f') | (data['scan_type'] == 't2w'))]\n",
    "d_test_im = d_test_im[d_test_im['patient_id'] > 1173]\n",
    "d_test_im.sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training cases: 758 Testing cases: 375\n"
     ]
    }
   ],
   "source": [
    "print('Training cases:',len(set(d_t_im['patient_id'])),'Testing cases:',len(set(d_test_im['patient_id'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "parent_dir = r\"C:\\Users\\bouhe\\OneDrive\\Bureau\\pfe\\dataset\\png_format\"\n",
    "images_train = []\n",
    "for i in range(len(d_t_im)):\n",
    "    temp = d_t_im.iloc[i]\n",
    "    folder = '-'.join([\"BraTS-GLI\",str(temp['patient_id']).zfill(5), str(temp['time_stamp']).zfill(3)])\n",
    "    res = os.path.join(*[parent_dir,temp['split'],folder,temp['scan_type'],temp['image_name']])\n",
    "    images_train.append(res)\n",
    "    \n",
    "gt_train = images_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp = []\n",
    "for string in gt_train:\n",
    "    tm = ' '.join(string.split('\\\\'))\n",
    "    r = tm.replace(\"t1c\",\"seg\")\n",
    "    r = r.replace(\"t1n\",\"seg\")\n",
    "    r = r.replace(\"t2f\",\"seg\")\n",
    "    r = r.replace(\"t2w\",\"seg\")\n",
    "    f ='\\\\'.join(r.split(' '))\n",
    "    tmp.append(f)\n",
    "gt_train = tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "parent_dir = r\"C:\\Users\\bouhe\\OneDrive\\Bureau\\pfe\\dataset\\png_format\"\n",
    "images_test = []\n",
    "for i in range(len(d_test_im)):\n",
    "    temp = d_test_im.iloc[i]\n",
    "    folder = '-'.join([\"BraTS-GLI\",str(temp['patient_id']).zfill(5), str(temp['time_stamp']).zfill(3)])\n",
    "    res = os.path.join(*[parent_dir,temp['split'],folder,temp['scan_type'],temp['image_name']])\n",
    "    images_test.append(res)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "309400"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(images_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "Dir = 'C:\\\\Users\\\\bouhe\\\\OneDrive\\\\Bureau\\\\pfe\\\\dataset\\\\png_format\\\\train\\\\'\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t2w\\\\Slice_dim1_50.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1n\\\\Slice_dim1_50.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1c\\\\Slice_dim1_50.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t2w\\\\Slice_dim1_49.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1n\\\\Slice_dim1_49.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1c\\\\Slice_dim1_49.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t2w\\\\Slice_dim1_48.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1n\\\\Slice_dim1_48.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1c\\\\Slice_dim1_48.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t2w\\\\Slice_dim1_47.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1n\\\\Slice_dim1_47.png')\n",
    "images_test.remove(Dir +'BraTS-GLI-01432-000\\\\t1c\\\\Slice_dim1_47.png')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "tmp = []\n",
    "for string in images_test:\n",
    "    tm = ' '.join(string.split('\\\\'))\n",
    "    r = tm.replace(\"t1c\",\"seg\")\n",
    "    r = r.replace(\"t1n\",\"seg\")\n",
    "    r = r.replace(\"t2f\",\"seg\")\n",
    "    r = r.replace(\"t2w\",\"seg\")\n",
    "    f ='\\\\'.join(r.split(' '))\n",
    "    tmp.append(f)\n",
    "gt_test = tmp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1c,t1n,t2f,t2w = [], [], [], []\n",
    "for image, mask in zip(images_test, gt_test):\n",
    "    if 't1c' in image :\n",
    "        t1c.append((image,mask))\n",
    "    elif 't1n'in image :\n",
    "        t1n.append((image,mask))\n",
    "    elif 't2f'in image :\n",
    "        t2f.append((image,mask))    \n",
    "    elif 't2w'in image  :\n",
    "        t2w.append((image,mask))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "final_t = []\n",
    "for path_seg in gt_train :\n",
    "    tmp_list = path_seg.split('\\\\')\n",
    "    tmp_list.pop(-2)\n",
    "    final_t.append('C:\\\\'+os.path.join(*(tmp_list[1:8] + ['train_fused'] + tmp_list[9:])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "uni_g = []\n",
    "for path_name in gt_train:\n",
    "    new_path = path_name.split('\\\\')\n",
    "    uni_g.append(('\\\\').join(new_path[0:8]+['train']+new_path[9::]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_list = gt_train\n",
    "\n",
    "file_exist = [os.path.exists(file) for file in file_list]\n",
    "\n",
    "all_exist = all(file_exist)\n",
    "\n",
    "if all_exist:\n",
    "    print(\"All files exist.\")\n",
    "else:\n",
    "    print(\"Some files do not exist.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "missing_indices = [index for index, file in enumerate(file_list) if not os.path.exists(file)]\n",
    "\n",
    "if len(missing_indices) == 0:\n",
    "    print(\"All files exist.\")\n",
    "else:\n",
    "    print(\"Missing files at indices:\", missing_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "metadata = d_t_im.to_dict('list')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the csv file\n",
    "data = pd.read_csv(r\"C:\\Users\\bouhe\\OneDrive\\Documents\\Python Scripts\\work_internship mitacs_backup\\project_TransUNet\\test.csv\")\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all([os.path.exists(name) for name in images_test])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "exists = []\n",
    "problem = []\n",
    "c = 0\n",
    "for image in images_test :\n",
    "    c+=1\n",
    "    exists.append(os.path.exists(image))\n",
    "    if os.path.exists(image) == False :\n",
    "        problem.append((c,image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DATASET"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datasets\n",
    "dataset_tmp = datasets.Dataset.from_dict({\"image\": images_train,\"label\":uni_g}).cast_column(\"image\", Image())\n",
    "dataset = dataset_tmp.cast_column(\"label\", Image())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1n_filtered = [\n",
    "    (image_path, seg_path) for image_path, seg_path in t1n if 'dim0' not in image_path and 'dim1' not in image_path\n",
    "]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datasets\n",
    "dataset_tmp = datasets.Dataset.from_dict({\"image\": [t1n_filtered[i][0] for i in range(len(t1n_filtered))],\"label\":[t1n_filtered[i][1] for i in range(len(t1n_filtered))]}).cast_column(\"image\", Image())\n",
    "dataset_test = dataset_tmp.cast_column(\"label\", Image())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('C:\\\\Users\\\\bouhe\\\\OneDrive\\\\Bureau\\\\pfe\\\\dataset\\\\png_format\\\\train\\\\BraTS-GLI-01174-000\\\\t1n\\\\Slice_dim2_100.png',\n",
       " 'C:\\\\Users\\\\bouhe\\\\OneDrive\\\\Bureau\\\\pfe\\\\dataset\\\\png_format\\\\train\\\\BraTS-GLI-01174-000\\\\seg\\\\Slice_dim2_100.png')"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1n_filtered[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Padding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image as I, ImageOps\n",
    "\n",
    "# Define the target shape for padding\n",
    "target_shape = (256, 256)  # Specify the desired shape (width, height)\n",
    "\n",
    "# List of image paths\n",
    "\n",
    "# Iterate through the image paths\n",
    "for path in images_train:\n",
    "    # Open the image\n",
    "    image = I.open(path)\n",
    "\n",
    "    # Pad the image with zeros to the target shape\n",
    "    padded_image = ImageOps.expand(image, border=(0, 0, target_shape[0] - image.width, target_shape[1] - image.height), fill=0)\n",
    "\n",
    "    # Save the padded image\n",
    "    padded_image.save(path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the target shape for padding\n",
    "target_shape = (256, 256)  # Specify the desired shape (width, height)\n",
    "\n",
    "# Iterate through the image paths\n",
    "for path in set(image_paths):\n",
    "    # Open the image\n",
    "    image = I.open(path)\n",
    "\n",
    "    # Pad the image with zeros to the target shape\n",
    "    padded_image = ImageOps.expand(image, border=(0, 0, target_shape[0] - image.width, target_shape[1] - image.height), fill=0)\n",
    "\n",
    "    # Save the padded image\n",
    "    padded_image.save(path)\n",
    "    print(path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chime.success()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the image\n",
    "image = I.open(meta['image'][0])\n",
    "\n",
    "# Define the target shape for padding\n",
    "target_shape = (256, 256)  # Specify the desired shape (width, height)\n",
    "\n",
    "# Pad the image with zeros to the target shape\n",
    "padded_image = ImageOps.expand(image, border=(0, 0, target_shape[0] - image.width, target_shape[1] - image.height), fill=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=I size=256x256>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image = dataset[40][\"image\"]\n",
    "image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAEAAAAAApiSv5AAABgElEQVR4nO3bzW6DMBCFUVL1/V85XXRRWuVvUfyNwjmrRIrEiLnGjoFtAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOCJS13ATd9VXeMqTmFeAPYVicDhPuoC/pgXyDc36YTfqsU14GBTAnC/DhE41Gd4bEu9Abo1wOXO50e/499NWARqcWhCAAj1ATD+U30ASM0PgH8Jh5oeAO0/WBeAV1qr/YebsQ9wm/YvUK3Bnx1X8xdpAmDnf4xJVwDND5Q3g/Y0P9Luw7kfCAAAAOdx8TxQrX8eQAhSfQC2rd6PPLU2AD+bwCIQ6U+8t4FT/RSwb3ofx9PpA2DcpyYEwLgPTQjAnjAsNi0ApoPFpgXAFWCxPgBanuoD8JspYLFpAWCxOgAmgFgdAGJ1AK4PvgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8E6+AIhiF0q4vmq6AAAAAElFTkSuQmCC",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=I size=256x256>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = dataset[40][\"label\"]\n",
    "mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_b = dataset[50][\"label\"]\n",
    "\n",
    "# Convert the image to a NumPy array\n",
    "mask_array = np.array(mask_b)\n",
    "\n",
    "# Get the unique pixel values\n",
    "unique_values = np.unique(mask_array)\n",
    "\n",
    "print(\"Unique pixel values:\", unique_values)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    0         -- > 0\n",
    "    21845     -- > 1\n",
    "    43690     -- > 2\n",
    "    65535     -- > 3\n",
    "\n",
    "    1 for NCR\n",
    "    2 for ED\n",
    "    3 for ET\n",
    "    0 for everything else."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_array = np.array(mask)\n",
    "image_array = np.array(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new array for the masked image\n",
    "masked_image_array = np.zeros_like(image_array)\n",
    "\n",
    "# Apply the mask to the masked image array\n",
    "masked_image_array[...] = np.where(mask_array > 0, mask_array, image_array[...])\n",
    "\n",
    "# Create a new PIL image from the masked array\n",
    "masked_image = PIL.Image.fromarray(masked_image_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAEAAAAAApiSv5AAABoklEQVR4nO3YwVaDMBQE0ODx/39ZF7WeUitQQkomvXfF8sEMCaEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKDWdPYAjc3v7+ukKTr2efYATYxe6wON9qjW7scacGecFWC0Kr/IGAUQ/m75BRB+lY+zB6gyVcWvOiW7AHsCnB5cvbXcAgjwEKkF2Bv/9RioPj8yC1Abn/h/5Z0C6sMT/420h3HkvP4KlrQtIK2uAZIKIP4Gcgog/iZyCkATKQXw/jeSUQDxN5NQgDbxOwSWUhIKIP6m8v4E1hP+jd5XgOPff/HP9P15dfR0wv/jfbYA4T/U+xZwFPH/4x1WAOEvGH8FEP+i0Qsg/hV9F6A2PvGv6rsAImyu7/8AV/unVKAVGQW42DOrAqzofQuoI/5VSQV4Nk7xb5BUgOciFf8mSd8Ac8uTi3+j3AJc3M8veAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4iW/Y0Bpcy3OhmQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=I size=256x256>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[60][\"label\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testing visual representation of input_boxees on the mri\n",
    "#functions.show_boxes_on_image(dataset[50][\"image\"], [input_box])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CUSTOM DATA LOADER"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "\n",
    "def pad_tensor(tensor, target_size):\n",
    "    # Compute the padding for each dimension\n",
    "    padding = []\n",
    "    for i in range(tensor.dim()):\n",
    "        pad = max(0, target_size[i] - tensor.size(i))\n",
    "        padding.extend([0, pad])\n",
    "    \n",
    "    # Pad the tensor\n",
    "    padded_tensor = F.pad(tensor, padding, 'constant', 0)\n",
    "    \n",
    "    return padded_tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_bounding_box(ground_truth_map,num):\n",
    "  # get bounding box from mask\n",
    "  y_indices, x_indices = np.where(ground_truth_map == num)\n",
    "  x_min, x_max = np.min(x_indices), np.max(x_indices)\n",
    "  y_min, y_max = np.min(y_indices), np.max(y_indices)\n",
    "  # add perturbation to bounding box coordinates\n",
    "  H, W = ground_truth_map.shape\n",
    "  x_min = max(0, x_min - np.random.randint(0, 5))\n",
    "  x_max = min(W, x_max + np.random.randint(0, 5))\n",
    "  y_min = max(0, y_min - np.random.randint(0, 5))\n",
    "  y_max = min(H, y_max + np.random.randint(0, 5))\n",
    "  bbox = [x_min, y_min, x_max, y_max]\n",
    "  return bbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SAMDataset(Dataset):\n",
    "  def __init__(self, dataset, processor):\n",
    "    self.dataset = dataset\n",
    "    self.processor = processor\n",
    "\n",
    "  def __len__(self):\n",
    "    return len(self.dataset)\n",
    "\n",
    "  def __getitem__(self, idx):\n",
    "    item = self.dataset[idx]\n",
    "    image = item[\"image\"]\n",
    "    ground_truth_mask = np.array(item[\"label\"])\n",
    "\n",
    "    # get bounding box prompt\n",
    "    prompt = functions.get_bounding_box(ground_truth_mask,1)\n",
    "\n",
    "    # prepare image and prompt for the model\n",
    "    inputs = self.processor(image, input_boxes=[[prompt]], return_tensors=\"pt\")\n",
    "\n",
    "    # remove batch dimension which the processor adds by default\n",
    "    inputs = {k:v.squeeze(0) for k,v in inputs.items()}\n",
    "\n",
    "    # add ground truth segmentation\n",
    "    inputs[\"ground_truth_mask\"] = ground_truth_mask\n",
    "\n",
    "    return inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We're creating a processor using the pre-trained SAM model from Facebook.\n",
    "processor = SamProcessor.from_pretrained(\"facebook/sam-vit-base\")\n",
    "\n",
    "# Now, we're setting up a training dataset using the SAMDataset class.\n",
    "train_dataset = SAMDataset(dataset=dataset, processor=processor)\n",
    "\n",
    "# We're creating a DataLoader for the training dataset.\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=2, shuffle=True)\n",
    "\n",
    "# make sure we only compute gradients for mask decoder\n",
    "# We're going through each named parameter in the model and checking its name.\n",
    "# If the name starts with \"vision_encoder\" or \"prompt_encoder\", we set requires_grad to False.\n",
    "# This prevents these parts of the model from being updated during training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pixel_values torch.Size([2, 3, 1024, 1024])\n",
      "original_sizes torch.Size([2, 2])\n",
      "reshaped_input_sizes torch.Size([2, 2])\n",
      "input_boxes torch.Size([2, 1, 4])\n",
      "ground_truth_mask torch.Size([2, 256, 256])\n"
     ]
    }
   ],
   "source": [
    "# We're creating a DataLoader for the training dataset.\n",
    "train_dataloader = DataLoader(train_dataset, batch_size=2, shuffle=True)\n",
    "\n",
    "batch = next(iter(train_dataloader))\n",
    "for k,v in batch.items():\n",
    "  print(k,v.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We're creating a model using the pre-trained \"facebook/sam-vit-base\" model.\n",
    "model = SamModel.from_pretrained(\"facebook/sam-vit-base\")\n",
    "# make sure we only compute gradients for mask decoder\n",
    "# We're going through each named parameter in the model and checking its name.\n",
    "# If the name starts with \"vision_encoder\" or \"prompt_encoder\", we set requires_grad to False.\n",
    "# This prevents these parts of the model from being updated during training.\n",
    "for name, param in model.named_parameters():\n",
    "  if name.startswith(\"vision_encoder\") or name.startswith(\"prompt_encoder\"):\n",
    "    param.requires_grad_(False)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note: Hyperparameter tuning could improve performance here\n",
    "# We're defining an optimizer for the parameters of the mask decoder in the model.\n",
    "# The Adam optimizer is being used with a learning rate of 1e-5 and weight decay of 0.\n",
    "optimizer = Adam(model.mask_decoder.parameters(), lr=1e-5, weight_decay=0)\n",
    "\n",
    "# We're defining a segmentation loss function.\n",
    "seg_loss = monai.losses.DiceCELoss(sigmoid=True, squared_pred=True, reduction='mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA IS ENABLED : True\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "SamModel(\n",
       "  (shared_image_embedding): SamPositionalEmbedding()\n",
       "  (vision_encoder): SamVisionEncoder(\n",
       "    (patch_embed): SamPatchEmbeddings(\n",
       "      (projection): Conv2d(3, 768, kernel_size=(16, 16), stride=(16, 16))\n",
       "    )\n",
       "    (layers): ModuleList(\n",
       "      (0-11): 12 x SamVisionLayer(\n",
       "        (layer_norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n",
       "        (attn): SamVisionAttention(\n",
       "          (qkv): Linear(in_features=768, out_features=2304, bias=True)\n",
       "          (proj): Linear(in_features=768, out_features=768, bias=True)\n",
       "        )\n",
       "        (layer_norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n",
       "        (mlp): SamMLPBlock(\n",
       "          (lin1): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          (lin2): Linear(in_features=3072, out_features=768, bias=True)\n",
       "          (act): GELUActivation()\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (neck): SamVisionNeck(\n",
       "      (conv1): Conv2d(768, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (layer_norm1): SamLayerNorm()\n",
       "      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (layer_norm2): SamLayerNorm()\n",
       "    )\n",
       "  )\n",
       "  (prompt_encoder): SamPromptEncoder(\n",
       "    (shared_embedding): SamPositionalEmbedding()\n",
       "    (mask_embed): SamMaskEmbedding(\n",
       "      (activation): GELUActivation()\n",
       "      (conv1): Conv2d(1, 4, kernel_size=(2, 2), stride=(2, 2))\n",
       "      (conv2): Conv2d(4, 16, kernel_size=(2, 2), stride=(2, 2))\n",
       "      (conv3): Conv2d(16, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "      (layer_norm1): SamLayerNorm()\n",
       "      (layer_norm2): SamLayerNorm()\n",
       "    )\n",
       "    (no_mask_embed): Embedding(1, 256)\n",
       "    (point_embed): ModuleList(\n",
       "      (0-3): 4 x Embedding(1, 256)\n",
       "    )\n",
       "    (not_a_point_embed): Embedding(1, 256)\n",
       "  )\n",
       "  (mask_decoder): SamMaskDecoder(\n",
       "    (iou_token): Embedding(1, 256)\n",
       "    (mask_tokens): Embedding(4, 256)\n",
       "    (transformer): SamTwoWayTransformer(\n",
       "      (layers): ModuleList(\n",
       "        (0-1): 2 x SamTwoWayAttentionBlock(\n",
       "          (self_attn): SamAttention(\n",
       "            (q_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "            (k_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "            (v_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "            (out_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "          )\n",
       "          (layer_norm1): LayerNorm((256,), eps=1e-06, elementwise_affine=True)\n",
       "          (cross_attn_token_to_image): SamAttention(\n",
       "            (q_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (k_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (v_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (out_proj): Linear(in_features=128, out_features=256, bias=True)\n",
       "          )\n",
       "          (layer_norm2): LayerNorm((256,), eps=1e-06, elementwise_affine=True)\n",
       "          (mlp): SamMLPBlock(\n",
       "            (lin1): Linear(in_features=256, out_features=2048, bias=True)\n",
       "            (lin2): Linear(in_features=2048, out_features=256, bias=True)\n",
       "            (act): ReLU()\n",
       "          )\n",
       "          (layer_norm3): LayerNorm((256,), eps=1e-06, elementwise_affine=True)\n",
       "          (layer_norm4): LayerNorm((256,), eps=1e-06, elementwise_affine=True)\n",
       "          (cross_attn_image_to_token): SamAttention(\n",
       "            (q_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (k_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (v_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (out_proj): Linear(in_features=128, out_features=256, bias=True)\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "      (final_attn_token_to_image): SamAttention(\n",
       "        (q_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "        (k_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "        (v_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "        (out_proj): Linear(in_features=128, out_features=256, bias=True)\n",
       "      )\n",
       "      (layer_norm_final_attn): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "    )\n",
       "    (upscale_conv1): ConvTranspose2d(256, 64, kernel_size=(2, 2), stride=(2, 2))\n",
       "    (upscale_conv2): ConvTranspose2d(64, 32, kernel_size=(2, 2), stride=(2, 2))\n",
       "    (upscale_layer_norm): SamLayerNorm()\n",
       "    (activation): GELU(approximate='none')\n",
       "    (output_hypernetworks_mlps): ModuleList(\n",
       "      (0-3): 4 x SamFeedForward(\n",
       "        (activation): ReLU()\n",
       "        (proj_in): Linear(in_features=256, out_features=256, bias=True)\n",
       "        (proj_out): Linear(in_features=256, out_features=32, bias=True)\n",
       "        (layers): ModuleList(\n",
       "          (0): Linear(in_features=256, out_features=256, bias=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (iou_prediction_head): SamFeedForward(\n",
       "      (activation): ReLU()\n",
       "      (proj_in): Linear(in_features=256, out_features=256, bias=True)\n",
       "      (proj_out): Linear(in_features=256, out_features=4, bias=True)\n",
       "      (layers): ModuleList(\n",
       "        (0): Linear(in_features=256, out_features=256, bias=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print('CUDA IS ENABLED :',torch.cuda.is_available())\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 3\n",
    "model.train()\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    epoch_losses = []\n",
    "    for batch in tqdm(train_dataloader):\n",
    "      # forward pass\n",
    "      outputs = model(pixel_values=batch[\"pixel_values\"].to(device),\n",
    "                      input_boxes=batch[\"input_boxes\"].to(device),\n",
    "                      multimask_output=False)\n",
    "      # compute loss\n",
    "      predicted_masks = outputs.pred_masks.squeeze(1)\n",
    "      ground_truth_masks = batch[\"ground_truth_mask\"].float().to(device)\n",
    "      loss = seg_loss(predicted_masks, ground_truth_masks.unsqueeze(1))\n",
    "      \n",
    "      # backward pass (compute gradients of parameters w.r.t. loss)\n",
    "      optimizer.zero_grad()\n",
    "      loss.backward()\n",
    "\n",
    "      # optimize\n",
    "      optimizer.step()\n",
    "      epoch_losses.append(loss.item())\n",
    "\n",
    "    print(f'EPOCH: {epoch}')\n",
    "    print(f'Mean loss: {mean(epoch_losses)}')\n",
    "    \n",
    "    # Save the model's state dictionary\n",
    "    torch.save(model.state_dict(), f\"C:\\\\Users\\\\bouhe\\\\Documents\\\\model_{epoch}.pth\")\n",
    "\n",
    "    # If you want to save additional information like optimizer state\n",
    "    # and training history, you can create a dictionary\n",
    "    checkpoint = {\n",
    "        'model_state_dict': model.state_dict(),\n",
    "        'optimizer_state_dict': optimizer.state_dict(),\n",
    "        'epoch': epoch,  # Example: current training epoch\n",
    "    }\n",
    "    torch.save(checkpoint, 'checkpoint_.pth')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=I size=256x256>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's take a random training example\n",
    "idx = 20\n",
    "\n",
    "# load image\n",
    "image = dataset_test[idx][\"image\"]\n",
    "image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAEAAAAAApiSv5AAABNUlEQVR4nO3aQQ6CMBBA0cH737kuXGAEKoUapvjeUlw00582IUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQ2BTT1Uv4hcfVCxjKDRMQwJ8TwF4lIupnwJDnw5CLvsxrWqXyLKLEtPmfhATQ5n1epTq9Us0lDQG0ap9Y6gQEcEzb3BInIICz9k4waQQC6GFtimXxe8oEBNDH1lanT0AAPcxTXG5x8gS8COop3fZ+J4Dz5ldAa5JH4Qo4bv/hXrsiLiaAoz4nl25r93EF9DHo9nPeTT8UAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABjOE1KqFxrQ/VAGAAAAAElFTkSuQmCC",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=I size=256x256>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset_test[idx][\"label\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('C:\\\\Users\\\\bouhe\\\\OneDrive\\\\Bureau\\\\pfe\\\\dataset\\\\png_format\\\\train\\\\BraTS-GLI-01174-000\\\\t1n\\\\Slice_dim2_70.png',\n",
       " 'C:\\\\Users\\\\bouhe\\\\OneDrive\\\\Bureau\\\\pfe\\\\dataset\\\\png_format\\\\train\\\\BraTS-GLI-01174-000\\\\seg\\\\Slice_dim2_70.png')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "t1n_filtered[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = dataset_test[idx][\"image\"]\n",
    "mask = dataset_test[idx][\"label\"]\n",
    "image_array = np.array(image)\n",
    "mask_array = np.array(mask)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### FUSION MODEL "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the model 0\n",
    "model = SamModel.from_pretrained(\"facebook/sam-vit-base\")\n",
    "model.load_state_dict(torch.load(r\"C:\\Users\\bouhe\\Documents\\TRAINED FUSION\\model_0.pth\"))\n",
    "model.to(\"cuda\")\n",
    "# We're creating a processor using the pre-trained SAM model from Facebook.\n",
    "processor = SamProcessor.from_pretrained(\"facebook/sam-vit-base\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the model 1\n",
    "model = SamModel.from_pretrained(\"facebook/sam-vit-base\")\n",
    "model.load_state_dict(torch.load('C:\\\\Users\\\\bouhe\\\\Documents\\\\TRAINED FUSION\\\\model_1.pth'))\n",
    "model.to(\"cuda\")\n",
    "# We're creating a processor using the pre-trained SAM model from Facebook.\n",
    "processor = SamProcessor.from_pretrained(\"facebook/sam-vit-base\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### NON FUSION MODEL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the model 0\n",
    "model = SamModel.from_pretrained(\"facebook/sam-vit-base\")\n",
    "model.load_state_dict(torch.load(r\"C:\\Users\\bouhe\\Documents\\TRAINED NORMAL\\model_non_fusion_0.pth\"))\n",
    "model.to(\"cuda\")\n",
    "# We're creating a processor using the pre-trained SAM model from Facebook.\n",
    "processor = SamProcessor.from_pretrained(\"facebook/sam-vit-base\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Processing images: 100%|██████████| 24523/24523 [2:05:55<00:00,  3.25image/s]  \n"
     ]
    }
   ],
   "source": [
    "# All predictions :\n",
    "predicted_masks_non_f_1 = []\n",
    "\n",
    "for element in tqdm(dataset_test, desc=\"Processing images\", unit=\"image\"):\n",
    "    \n",
    "    mask_array = np.array(element['label'])\n",
    "    image = element['image']\n",
    "    \n",
    "    # get box prompt based on ground truth segmentation map\n",
    "    prompt = get_bounding_box(mask_array,1)\n",
    "\n",
    "    # prepare image + box prompt for the model\n",
    "    inputs = processor(image, input_boxes=[[prompt]], return_tensors=\"pt\").to('cuda')\n",
    "    model.eval()\n",
    "\n",
    "    # forward pass\n",
    "    with torch.no_grad():\n",
    "        outputs = model(**inputs, multimask_output=False)\n",
    "    \n",
    "    # apply sigmoid\n",
    "    medsam_seg_prob = torch.sigmoid(outputs.pred_masks.squeeze(1))\n",
    "\n",
    "    # convert soft mask to hard mask\n",
    "    medsam_seg_prob = medsam_seg_prob.cpu().numpy().squeeze()\n",
    "    medsam_seg = (medsam_seg_prob > 0.5).astype(np.uint8)\n",
    "    predicted_masks_non_f_1.append(medsam_seg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the model\n",
    "model = SamModel.from_pretrained(\"facebook/sam-vit-base\")\n",
    "model.load_state_dict(torch.load(r\"C:\\Users\\bouhe\\Documents\\TRAINED NORMAL\\model_non_fusion_1.pth\"))\n",
    "model.to(\"cuda\")\n",
    "# We're creating a processor using the pre-trained SAM model from Facebook.\n",
    "processor = SamProcessor.from_pretrained(\"facebook/sam-vit-base\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Processing images: 100%|██████████| 24523/24523 [2:03:04<00:00,  3.32image/s]  \n"
     ]
    }
   ],
   "source": [
    "# All predictions :\n",
    "predicted_masks_non_f_2 = []\n",
    "\n",
    "for element in tqdm(dataset_test, desc=\"Processing images\", unit=\"image\"):\n",
    "    \n",
    "    mask_array = np.array(element['label'])\n",
    "    image = element['image']\n",
    "    \n",
    "    # get box prompt based on ground truth segmentation map\n",
    "    prompt = get_bounding_box(mask_array,1)\n",
    "\n",
    "    # prepare image + box prompt for the model\n",
    "    inputs = processor(image, input_boxes=[[prompt]], return_tensors=\"pt\").to('cuda')\n",
    "    model.eval()\n",
    "\n",
    "    # forward pass\n",
    "    with torch.no_grad():\n",
    "        outputs = model(**inputs, multimask_output=False)\n",
    "    \n",
    "    # apply sigmoid\n",
    "    medsam_seg_prob = torch.sigmoid(outputs.pred_masks.squeeze(1))\n",
    "\n",
    "    # convert soft mask to hard mask\n",
    "    medsam_seg_prob = medsam_seg_prob.cpu().numpy().squeeze()\n",
    "    medsam_seg = (medsam_seg_prob > 0.5).astype(np.uint8)\n",
    "    predicted_masks_non_f_2.append(medsam_seg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get box prompt based on ground truth segmentation map\n",
    "prompt = get_bounding_box(mask_array,1)\n",
    "\n",
    "# prepare image + box prompt for the model\n",
    "inputs = processor(image, input_boxes=[[prompt]], return_tensors=\"pt\").to('cuda')\n",
    "model.eval()\n",
    "\n",
    "# forward pass\n",
    "with torch.no_grad():\n",
    "  outputs = model(**inputs, multimask_output=False)\n",
    "  \n",
    "# apply sigmoid\n",
    "medsam_seg_prob = torch.sigmoid(outputs.pred_masks.squeeze(1))\n",
    "\n",
    "# convert soft mask to hard mask\n",
    "medsam_seg_prob = medsam_seg_prob.cpu().numpy().squeeze()\n",
    "medsam_seg = (medsam_seg_prob > 0.5).astype(np.uint8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#0 normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dice Score : 0.8640076886112446\n",
      "Jaccard Index : 0.760575296108291\n",
      "SSIM : 0.9997354457648868\n",
      "Specificity : 0.9975972344944116\n",
      "Sensitivty : 0.875365141187926\n",
      "raTS-GLI-01489-000\\t1n\\Slice_dim2_120.png\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bouhe\\AppData\\Local\\Temp\\ipykernel_9400\\2740733576.py:29: UserWarning: Inputs have mismatched dtypes. Setting data_range based on im1.dtype.\n",
      "  sim1 = compare_ssim(medsam_seg,mask_array)\n"
     ]
    }
   ],
   "source": [
    "# Create a figure with subplots\n",
    "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n",
    "\n",
    "# Display the original image\n",
    "axes[0].imshow(np.array(image),cmap='gray')\n",
    "axes[0].set_title(\"Original Image\")\n",
    "axes[0].axis(\"off\")\n",
    "\n",
    "# Display the predicted mask\n",
    "axes[1].imshow(np.array(image))\n",
    "axes[1].imshow(medsam_seg, cmap=\"gray\")\n",
    "axes[1].set_title(\"Predicted Mask\")\n",
    "axes[1].axis(\"off\")\n",
    "\n",
    "# Display the ground truth mask\n",
    "axes[2].imshow(np.array(image))\n",
    "axes[2].imshow(mask_array, cmap=\"gray\")\n",
    "axes[2].set_title(\"Ground Truth Mask\")\n",
    "axes[2].axis(\"off\")\n",
    "\n",
    "# Adjust spacing between subplots\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plots\n",
    "plt.show()\n",
    "\n",
    "score_dice1 = dice(medsam_seg,mask_array)\n",
    "jaccard1 = Jaccard(medsam_seg,mask_array)\n",
    "sim1 = compare_ssim(medsam_seg,mask_array)\n",
    "true_positives1, false_negatives1, true_negatives1, false_positives1 = confusion_matrix(medsam_seg,mask_array)\n",
    "sensi1 = sens(true_positives1, false_negatives1)\n",
    "speci1 = spec(true_negatives1, false_positives1)\n",
    "    \n",
    "print('Dice Score :' , score_dice1)\n",
    "print('Jaccard Index :' , jaccard1)\n",
    "print('SSIM :' , sim1)\n",
    "print('Specificity :' , speci1)\n",
    "print('Sensitivty :' , sensi1)\n",
    "\n",
    "#File path\n",
    "print(t1n_filtered[idx][0][-42:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('C:\\\\Users\\\\bouhe\\\\OneDrive\\\\Bureau\\\\pfe\\\\dataset\\\\png_format\\\\train\\\\BraTS-GLI-01175-000\\\\t1n\\\\Slice_dim2_95.png',\n",
       " 'C:\\\\Users\\\\bouhe\\\\OneDrive\\\\Bureau\\\\pfe\\\\dataset\\\\png_format\\\\train\\\\BraTS-GLI-01175-000\\\\seg\\\\Slice_dim2_95.png')"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx = 100\n",
    "t1n_filtered[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "image = dataset_test[idx][\"image\"]\n",
    "mask = dataset_test[idx][\"label\"]\n",
    "image_array = np.array(image)\n",
    "mask_array = np.array(mask)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the model\n",
    "model = SamModel.from_pretrained(\"facebook/sam-vit-base\")\n",
    "\n",
    "model.load_state_dict(torch.load(r\"C:\\Users\\bouhe\\Documents\\TRAINED NORMAL\\model_non_fusion_1.pth\"))\n",
    "\n",
    "model.to(\"cuda\")\n",
    "# We're creating a processor using the pre-trained SAM model from Facebook.\n",
    "processor = SamProcessor.from_pretrained(\"facebook/sam-vit-base\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get box prompt based on ground truth segmentation map\n",
    "prompt = get_bounding_box(mask_array,1)\n",
    "\n",
    "# prepare image + box prompt for the model\n",
    "inputs = processor(image, input_boxes=[[prompt]], return_tensors=\"pt\").to('cuda')\n",
    "model.eval()\n",
    "\n",
    "# forward pass\n",
    "with torch.no_grad():\n",
    "  outputs = model(**inputs, multimask_output=False)\n",
    "  \n",
    "# apply sigmoid\n",
    "medsam_seg_prob = torch.sigmoid(outputs.pred_masks.squeeze(1))\n",
    "\n",
    "# convert soft mask to hard mask\n",
    "medsam_seg_prob = medsam_seg_prob.cpu().numpy().squeeze()\n",
    "medsam_seg = (medsam_seg_prob > 0.5).astype(np.uint8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#epoch 1 normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dice Score : 0.8365098272781417\n",
      "Jaccard Index : 0.7189659585359611\n",
      "Specificity : 0.9930551079600387\n",
      "Sensitivty : 0.8081127733026467\n",
      "BraTS-GLI-01175-000\\t1n\\Slice_dim2_95.png\n"
     ]
    }
   ],
   "source": [
    "# Create a figure with subplots\n",
    "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n",
    "\n",
    "# Display the original image\n",
    "axes[0].imshow(np.array(image),cmap='gray')\n",
    "axes[0].set_title(\"Original Image\")\n",
    "axes[0].axis(\"off\")\n",
    "\n",
    "# Display the predicted mask\n",
    "axes[1].imshow(np.array(image))\n",
    "axes[1].imshow(medsam_seg, cmap=\"gray\")\n",
    "axes[1].set_title(\"Predicted Mask\")\n",
    "axes[1].axis(\"off\")\n",
    "\n",
    "# Display the ground truth mask\n",
    "axes[2].imshow(np.array(image))\n",
    "axes[2].imshow(mask_array, cmap=\"gray\")\n",
    "axes[2].set_title(\"Ground Truth Mask\")\n",
    "axes[2].axis(\"off\")\n",
    "\n",
    "# Adjust spacing between subplots\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plots\n",
    "plt.show()\n",
    "\n",
    "score_dice1 = dice(medsam_seg,mask_array)\n",
    "jaccard1 = Jaccard(medsam_seg,mask_array)\n",
    "#sim1 = compare_ssim(medsam_seg,mask_array)\n",
    "true_positives1, false_negatives1, true_negatives1, false_positives1 = confusion_matrix(medsam_seg,mask_array)\n",
    "sensi1 = sens(true_positives1, false_negatives1)\n",
    "speci1 = spec(true_negatives1, false_positives1)\n",
    "    \n",
    "print('Dice Score :' , score_dice1)\n",
    "print('Jaccard Index :' , jaccard1)\n",
    "#print('SSIM :' , sim1)\n",
    "print('Specificity :' , speci1)\n",
    "print('Sensitivty :' , sensi1)\n",
    "\n",
    "#File path\n",
    "print(t1n_filtered[idx][0][-41:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dice Score : 0.5598885793871866\n",
      "Jaccard Index : 0.38878143133462284\n",
      "SSIM : 0.9990284637685053\n",
      "Specificity : 0.9998914880094251\n",
      "Sensitivty : 0.3914313534566699\n",
      "raTS-GLI-01489-000\\t1n\\Slice_dim2_120.png\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bouhe\\AppData\\Local\\Temp\\ipykernel_22348\\2740733576.py:29: UserWarning: Inputs have mismatched dtypes. Setting data_range based on im1.dtype.\n",
      "  sim1 = compare_ssim(medsam_seg,mask_array)\n"
     ]
    }
   ],
   "source": [
    "# Create a figure with subplots\n",
    "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n",
    "\n",
    "# Display the original image\n",
    "axes[0].imshow(np.array(image),cmap='gray')\n",
    "axes[0].set_title(\"Original Image\")\n",
    "axes[0].axis(\"off\")\n",
    "\n",
    "# Display the predicted mask\n",
    "axes[1].imshow(np.array(image))\n",
    "axes[1].imshow(medsam_seg, cmap=\"gray\")\n",
    "axes[1].set_title(\"Predicted Mask\")\n",
    "axes[1].axis(\"off\")\n",
    "\n",
    "# Display the ground truth mask\n",
    "axes[2].imshow(np.array(image))\n",
    "axes[2].imshow(mask_array, cmap=\"gray\")\n",
    "axes[2].set_title(\"Ground Truth Mask\")\n",
    "axes[2].axis(\"off\")\n",
    "\n",
    "# Adjust spacing between subplots\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plots\n",
    "plt.show()\n",
    "\n",
    "score_dice1 = dice(medsam_seg,mask_array)\n",
    "jaccard1 = Jaccard(medsam_seg,mask_array)\n",
    "sim1 = compare_ssim(medsam_seg,mask_array)\n",
    "true_positives1, false_negatives1, true_negatives1, false_positives1 = confusion_matrix(medsam_seg,mask_array)\n",
    "sensi1 = sens(true_positives1, false_negatives1)\n",
    "speci1 = spec(true_negatives1, false_positives1)\n",
    "    \n",
    "print('Dice Score :' , score_dice1)\n",
    "print('Jaccard Index :' , jaccard1)\n",
    "print('SSIM :' , sim1)\n",
    "print('Specificity :' , speci1)\n",
    "print('Sensitivty :' , sensi1)\n",
    "\n",
    "#File path\n",
    "print(t1n_filtered[idx][0][-41:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABCYAAAFtCAYAAADbDGs3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAB2OklEQVR4nO3deZhlZXnv/d+z511VPQDN0NhII/OgICIaBSVBQUVDDlGjLwqemCMqynVMkIMejR41ip4oySE4G8XXYxyIMiUSwYgDMkmLr4goosjUTN1d3V1Ve97r/WPXvepeT+2C7qa7V3XX93NddXXVHta0i009v30/9xOSJBEAAAAAAEAeCnkfAAAAAAAAWLgIJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJvCkhRDeHUL4/NZ+7CZsKwkhHLA1tgUAC0UI4UshhA9Nf398COHX22m/ub1n+3MGgPkuhLBy+j2zlMO+7wkhvGh773eYEMIJIYT78z4ObB8EE8gIIbwhhPCLEMJUCOGhEMKnQghLH+85SZJ8OEmSv9qU7W/OY5+MEMJ1IYRtvh8A2Bam/zBshBAmQggPhxC+GEIY29r7SZLkR0mSHLwJx/OGEMKPt/b+3favm/4j/Mjo9sumbz9hW+0bwMIUQnhNCOGmEMJkCOGR6e/fGkIIeR/b45n+/4J99d3/KyZCCKdv5raeVGg7/f+GJITwiej2P5u+/Utbum0sPAQTSIUQ/kbSRyW9U9ISSc+VtK+ka0IIlTmes92TXABYIF6RJMmYpKMlPVvSe+IH7GTvwb+RdIb9EELYTYP/Dz2a2xEB2ClN/837j5L+t6S9JO0p6c2Sni9prr95i9vtAB9HkiRj9iXpXk3/v2L66//a47bj/x/ulvQX0f7O0OA9HdhkBBOQJIUQFkv6X5LeniTJ1UmSdJIkuUfSqzUIJ143/bj3hxAuDSF8JYSwQdIbpm/7itvWGSGEP4QQ1oQQ3utLwvxjXZnamSGEe0MIj4UQ/qfbzrEhhBtCCOMhhNUhhH+aKyB5gnM7IYRwfwjhvOlEfPV0kvuyEMJvQghrQwjv3tT9hhBOCiH8OoSwPoTwyRDCD3x1RgjhL0MIvwohrAsh/EcIYd/NPWYAMEmSPCDpO5KOkNIpEWeHEO6SdNf0bS8PIdw2/b71kxDCM+z5IYRnhhBWhRA2hhC+Lqnm7suUyYYQ9gkhfCuE8Oj0e/g/hRAOlfRpSX80/Ync+PRjqyGEv59+/344hPDpEELdbeud0++hD4YQ/nITTvX/avDHrf3x/1pJ35bUdtuc8/05DFw4/T6/PoTw/4UQjoh3EkJYFEL4fgjh/4Qwvz8ZBbD1hRCWSPqApLcmSXJpkiQbk4GfJUlyepIkrenHfSkMKof/PYQwKemPQwiHhkGF13gI4ZchhD91281U64ao0mz6vfvNIYS7pv9GvNjeg0IIxen308dCCL+TdMoWnJf9vfs/QggPSfpifAzuOA4IIbxJ0umSzpt+b7/SPeyo6ffQ9SGEr4cQaprbQ5J+Ienk6e3vKul5kq6I9vvNMKjGXh9C+GEI4XB338tCCHdM/3/qgRDCuXOc4znTj1uxGZcGOwiCCZjnafDH6rf8jUmSTGjwB/GL3c2nSrpU0lIN/pBMhRAOk/RJDd7olmtQefGUJ9j3cZIOlnSipL+d/iNYknqS3iFpmaQ/mr7/rZt3Wqm9NDi/p0j6W0mf0yBseZak46f3+7Qn2m8IYZkG5/4uSbtJ+rUG107T9/+ZpHdLOk3S7pJ+JOlftvCYAUAhhH0kvUzSz9zNfybpOZIOCyEcLemfJZ2lwfvSZyRdMR0cVCRdJun/lbSrpG9K+vM59lOUdJWkP0haqcH75deSJPmVBp8k3jD9idzS6ad8VNJBko6SdIBm3l8VQniJpHM1+H/HgZI2Zb7yg5LukHTS9M9nSPpy9JjH+//CSZJeMH1MSyX9haQ10TnuJul7kq5PkuScJEmSTTguADuXP5JUlXT5Jjz2/5H0d5IWSbpJ0pWSvitpD0lvl/R/QwhPOB3OebkGFXBHavDh38nTt/+36fueKekYSa/cjG16e2nwXr+vpDc93gOTJPmsBn/Hf2z6vf0V7u5XS3qJpP0kPUPSG55gv1/WTMXbazS4tq3oMd/R4P8He0hapewY4guSzkqSZJEGIfx/xjsIIbx3+jhemCQJfSd2QgQTMMskPZYkSXfIfaun7zc3JElyWZIk/SRJGtFjXynpyiRJfpwkSVuDP1Kf6A+//5UkSSNJkp9L+rkGb9ZKkuTWJEluTJKkO1298RlJL9z8U5MkdST9XZIkHUlfmz6ff5xOyX8p6ZcavPE+0X5fJumXSZJ8a/pa/R8NkmJzlqSPJEnyq+n7P6xB6kzVBIDNddl0dcKPJf1Ag/cT85EkSdZOvwf/N0mfSZLkpiRJekmSXKLBH4TPnf4qS/qH6Uq4SyXdMsf+jpW0t6R3JkkymSRJM0mSoX0lpj/l+2+S3jF9HBunj+810w95taQvJklye5Ikk5Lev4nn/GVJZ0z/ob80SZIb/J1P8P7c0WDwcIikMP0+vNo9fW8NruM3kySZNS0GwIIx62/e6Uqz8TDo1/AC99jLkyS5PkmSvgYh7JikC5IkaSdJ8p8ahLmv3Yx9X5AkyXiSJPdK+v70NqXBe+Y/JElyX5IkayV9ZAvPrS/pfUmStIb8jb45/k+SJA9OH8uV7jjn8m1JJ0xXowwLlZUkyT9P/93d0uD/CUdOP14avH8fFkJYnCTJuiRJVrmnhjDoYXGypD9OkoTpfTspggmYxyQtC8Pnoy2fvt/c9zjb2dvfnyTJlKJPrIbwA/spDd70FUI4KIRw1XTZ1wYN/uhdNmwDm2BNkiS96e/tjfphd39jE/cbn18iyae2+0r6x+n/uY1LWisp6ImrRgAg9mdJkixNkmTfJEneGv2R6d+H95X0N/a+M/3es48G71d7S3ogqgz4wxz720fSH+YIqGO7SxqRdKvb59XTt0vRe+Xj7DP2LUl/osEnkf9vfOfjvT9PDxL+SdLFkh4OIXw2DKYpmlMk1TWYlgJg4Vqj6G/eJEmeN10NtkbZ8ZF/H9tb0n3TIYX5gzbvb7yhf/Nqy98zY48mSdLcwud6cx3nUNP/f/o3DXohLUuS5Hp///RUlQtCCHdPv3ffM32X/X395xp8+PeHMJgi/Ufu6Us1qP74SJIk67fwfLADIJiAuUGDT9hO8zeGEEYlvVSD0lfzeBUQqyWl877CYL7xblt4TJ+SdKekA5MkWazBFIntMR/48fYbn1/wP2vwP5WzpgcT9lVPkuQn2+G4ASwc/n34Pg0qwvz7zkiSJP+iwXvWU6JeCk+dY5v3SXrqHAF1/L7/mAaB7uFun0uSQTM2Te93n03YZ3YngzD7O5LeoiHBhJ7g/wtJkvyfJEmeJelwDaZ0vNM993MahCf/Pv3/NgALk/3Ne+omPNa/9z0oaZ8Qgh8/PVXSA9PfT2oQ2Jq9NuOYtug9c4j4vTpzTCGE+Ji25nS2L0v6Gw1/7/5/NLjeL9JgmvdKOyRJSpLkliRJTtVgmsdlkr7hnrtOg2kuXwwhPH8rHi/mGYIJSJKmE8j/JemiEMJLQgjlEMJKDeYj36/hbzLDXCrpFSGE503Pbf5f2vIwYZGkDZImQgiHaPCH6vbwePv9N0lPD4PmmSVJZyv7P55PS3qXNfQJISwJIbxqOx03gIXpc5LeHEJ4ThgYDSGcEkJYpMEf4F1J54QQSiGE0zSYsjHMzRr8cXzB9DZq7o/AhyWtmH5f1/Qnhp+TdGEIYQ9JCiE8JYRg86W/oUFz5MNCCCOS3rcZ5/NuDeYQ3zPkvjnfn0MIz56+BmUN/hhvatCTwnubBr2BrgquUSeAhSNJknEN/j79ZAjhlSGEsRBCIYRwlKTHCy1v0uC95bzpv5NPkPQKDaYIS9Jtkk4LIYyEEA6Q9MbNOKxvaPA+vSKEsIuk8zfjuY/n55IODyEcFQYNLN8f3f+wpKfNetaW+YEGfYUuGnLfIg3CoDUaBCXp1MQQQiWEcHoIYcn0lOsNit67kyS5ToP+dd8OITxnKx0v5hmCCaSSJPmYBn8Q/r0Gbwo3afAJ2onT88E2ZRu/1KAE92sa/IG7UdIjmt0AZ1Ocq0HCulGDP4C/vgXb2BJz7jdJksckvUrSxzR4cz1M0k81fX5Jknxbg4ZwX5suVbtdg4oTANgmkiT5qQb9Hv5Jg0+WfqvpRmXTvX5Om/55nQYNIb81x3Z6GvyRfYAGS9DdP/14adCI7JeSHgoh2NS+/zG9rxun3++u1aCRsZIk+Y6kf5h+3m81pJHZ45zPg3P1ttDj/39h8fRt6zQog16jwf/P/LYTDUqC75N0eXj8TvMAdlLTf/P+taTzNPg79WENetb8D0lDq1yn30//VIO/6x7ToNn7GUmS3Dn9kAs1WEXoYUmXKGoQ/wQ+J+k/NAgSVmmO9+nNlSTJbzRYgeRaDVZxit9bv6BBb4fxEMJlT3JfSZIk35vuSxH7sgbvyw9o0OT4xuj+10u6Z/r/JW/W9GqA0favkfRfNWju/Kwnc6yYn0JCQ2psQyGEMUnjGpTd/j7nw9nqpsv57pd0epIk38/7eAAAAABgR0PFBLa6EMIrpsvYRjX4tOoXmmlys8MLIZwcQlgaQqhqZn5znPwCAAAAADYBwQS2hVM1aBD0oAbrFb8m2blKc/5I0t0alPG9QoPO+U9mSSYAAAAAWLCYygEAAAAAAHJDxQQAAAAAAMgNwQQAAAAAAMhN6fHuDCEwzwMAtkCSJGFrb5P3ZADYMlv7PZn3YwDYMnO9H1MxAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAckMwAQAAAAAAclPK+wCA+aBYLKpWqw29L0kSSVIIQSGE9Hb/fbPZVKfT2bYHCQAAAAA7IYIJQNIhhxyic845R9VqVdIgdCgUBgVFExMTkqRKpaKxsTFVq1UVi8X0/kKhoE9+8pO68sor8zl4AAAAANiBBfs0eOidIcx9J7CDeulLX6pjjjlG3W5XpVJJSZJoZGREe+21l8rlsqrVqgqFgpIkUQhBjUZD0qCqYnR0VIVCQYVCIa2YKBaLeuSRRzQ+Pq4kSdTr9XTJJZfotttuy/EskbckScITP2rz8J4MAFtma78n834MAFtmrvdjggns1J7//OdrbGxMktTv95UkiY455hgdeOCB6vV6qtVqmYChWCymFRH9fl+S1Ol01O/3VSgUVK/XM1M4kiRRqVRSsVhUCEFJkqjb7eraa6/VXXfdpV6vp3//939Pt4WFg2ACAOYPggkAmB8IJrAgLF68WKXSzAyl//k//6f22GMPSYNgotfrpQFFoVDQyMiIyuVyWgVRKBRUqVTSiglJarfb6vf7CiGkQYZto9frqVQqpeGE3dbv99Xv99VqtfSWt7wl7T/R7/e1Zs2a7X9hsN0RTADA/EEwAQDzA8EEFoQPfvCDOuCAA9JpGF632838bFMzKpWKSqVSJpSw5xYKBTWbzTSYCCGoWCxKmgk6ut1u2pPCqibsK66uGB8f11/8xV9QQbEAEEwAwPxBMAEA8wPBBLa5k046Sccee6zq9Xq6wsWvfvUrff7zn9/kbbzgBS/QC17wApXLZdXrdV122WX6yU9+MufjX//61+uggw5SqVRSuVzW3nvvrUqlIkkql8uZyoZOp6NisZhWN9hKHOVyOQ0byuVyGjLYdI5Op5NWWCRJklZG2Habzaa63a76/X5aPTFsJQ+roFi9erU+8IEP6J577tmSy4wdBMEEAMwfBBMAMD/M9X7MqhzYanbZZRftu+++GhsbU7lcVrfbVZIkevnLX54O1u+77z6tWrUqfc7++++vZzzjGWmAcNBBB2mfffZRqVRSpVLRcccdpxUrViiEoG9961uzluRctmyZnvKUp6hcLmcqH0IIqlQq6ZSKQqGgXq+nYrGocrmchhPlcjkNJmylDauKKJVKarfbaQgRBxNWRWEBSK/XS6d2+IoLXzVRqVS033776dRTT9WPf/xj3XrrrdvnxQEAAACAeYpgAltk1113TXszmKVLl6pWq2l0dFTSYOrCnnvuqZe//OWq1+vq9/u67bbb9PDDD6fPOfroo3XKKadkBvp+MP/MZz5Tz372sxVC0M9+9jNNTU2lIUCSJKrVammVgoUNVu1gYYhVNnS73TSUsGO3x9ttkjLP7/V66blIM8uI2jQNC0AslPD9K+x+H1LYvyeffLIKhYJWr16tBx98cBu/WgAAAAAwfzGVA1vkHe94h/bdd990ykahUEiX2lyyZIkKhYLa7bba7XYaCFj40Ov10kG6PWbx4sVqtVqZAMCqGHzY0Ol0NDU1pTVr1qjdbmuXXXbR6OhoOiXDekTY9m1qRpIkmpqaSkOIQqGgfr+vYrGoSqWiSqWSrsZh0zokpRUXFjjYbaZQKKjb7abnMTU1lZkqYqFE/N9Zu91Wr9fTQw89pDPPPHMbvUrIE1M5AGD+YCoHAMwPTOXAVjUyMqJ6va5yuaxer5eGErVaLQ0rbDDv+y5YZYE1jLRpDzbYt4oEX9FgQYIPFGq1mgqFgqrVajodw0/nKBaLmeVArfLB77Pb7abH0+l00jDDqhys8sH2aVNCWq2WpJkwxk/9CCGo0+lkqiQsvPDhhm1/yZIl+sIXvqBer6crrrhCV1111XZ9HQEAAAAgbwQT2GTWD6JUKmnZsmWzpk5YMGD9JYaxgbr1abDpEzbwt8dYMOGnadhgv9vtppURFkj4qRz2s23fpl1YfwofeNhtPhyxx/sGmH5qhq+o8FM5LACx720bth3PgopCoaA99thD3W5XIyMjW/HVAgAAAIAdA8EENslee+2lI444Qscff7yq1arq9XoaSvgeDRYgxAN7aWZ6Rjy9wUIDCzP8yhm2TWtkaRUYlUol87i4b4QFHrYvO574WOw2P03DV05YPwm/Ld8rIu6JUS6XM1NSfCgRn7fvcdHv97Xbbrtp5cqVrNYBAAAAYEEhmMDjspDhNa95jVauXJlZycIG5KVSKW1CaYP2YrGoarWaNpC0QMEP7q0xpa10YctyWt8HXy1hVQmS1Ov1NDIyom63m07lsMdYSOIH/KZSqajZbKbBgAUa0kzFhvW/8A0u/bH6IMLO1W63a+OrLOz4fcBhU18ssLCpJCeddJIOPfRQ/ff//t8zxw0AAAAAOzOaX2JORx55pF75yleqXq+nIUOhUFCtVksrForFomq1WmYagl8Nw9hA3QcX1gzTrFu3Lm1IuWjRojQ48EFDp9NRs9nUxo0b1W63094W1WpVIyMjmWkafpqIhSNTU1Np7wibdmL9Hrrdrrrdbnpetg2731YNsR4SVv0Rr9wxOTmZTueoVCrpY33zT2t+addpYmIivX98fFxnn3221q1bt81fY2w7NL8EgPmD5pcAMD/Q/BKb5cQTT9QRRxyhxYsXq1qtZqZmWEDhV+IolUqzPuWPp1FYpYGfAmKD8X6/r0qlkvZ8kJSZHmLPkZQ20ZSyPSt8xcZcS3aWSiV1u91Zy3/64/XHZNux+33A4rfpm2v6KS3WhNMfg6RMZYUte2pNQRctWpR5LAAAAADszAgmkBFCSJtcrly5MjMVwVcw2M9+OkRcDWHbs/uGBRTSoKKh0+mkAYgN1n0PiUqlkqnA8OGBDyDikCG+zYICvy0fGtgKGrZ9X/kRr9Rhx+r7V1hYYyGN358/FgtybB+VSkXtdjvTAwMAAAAAFgKCCaRCCKrVajrjjDM0OjqaaWrpV7/w/RNs1QtJaVDhmz36AbYPEKznhDQTTNRqNRWLxbQJpoUf1m/CQgA/wG+32+m+LEyw6grfw8IfjwUKvuml8WFEt9tNp4P4MCKuwvCrifjpKrZP31/Cro0FFr1eT/1+Pz2/Xq+XnnPcIwMAAAAAdkYEE0jtv//+OvPMM7VkyZK0/0KlUtHo6GimUsKmW1g1g5+e4XsvWMWDnwIhzQ4skiRRu91O92G9HuIBvlUixNUKVo1gP0vKBAT2rz8GX3Hhp2dYtYd9dTqdNJyQZqpB/NQNm6rxRFNC7LqUy+X0+bbNeGWRT33qU/rMZz6j73znO1vxFQYAAACA+YdgApIGPSWOPvpo7bbbbhodHU0rJKrVatro0gIFCwjsZz8lI15Vww/4jT3GBvK2SoUN4m2lD/9439PB9mmDeZsqYStqWKhg1RM+rLAwxa+k4ashKpWKJKnb7aaVHLYNH2z40MQHF/aYeBpI3OjTtuEDDd/gc2xsLLNdAAAAANhZEUxARx11lI466ijtv//+GhkZ0cjISKa3g32K78OBeJqEDfTjigVfueCX3PQDch9y+NvjbcR9GnyFg02J8Ctf+OoNe7xfVlSaqVawx9jPfnu+IiLumeHPx4cP/jr5n/1tPpjwt1UqFXW7XR1yyCG6//77tWrVqq34agMAAADA/EIwsYAVCgWNjo7qda97nZYuXapqtarR0dF0lQ0bsNv3vrrA+iP4KQk+NPD7sNusqaQPIeIeD74Cw/essMfafb1eL9Pvwo4jPh6rgPAhhU2/sN4OPjjx52ChRLfbzQQTcUhhz7P9+HDCjtl6R/jH+34cNj2mWCyqWq2q2+3qpJNO0h577EEwAQAAAGCnRjCxgK1cuVLvfve70z4SVklQqVQyK2SUSqU0rLCgodlsZnot+H4PxWJRnU4nswqH9Y2QstMg7DGlUkmtVmvWChj2s03tiKsUbHt+NQ2bhmG3WdNOe1ypVEofJ80EBRZ0FIvFtKmnbdOCEGmmz4QFFnEViO8r4Y/Ri6tJ4iVNbelUpnMAAAAA2NkRTCxQL37xi3XcccelFRK1Wk3lclnFYlG1Wi2tkvADaN8Xol6vp4+xIKDb7aZ9Hmzwb7fbAN9ui5tklsvlTAhgj7FpJL4ppTQTVJTL5cyg3i/16XtESMOX4PQVG74HhC376as6rCGnn3rht+l7ZBj//LjawleSNBqNNOSx61wul/W0pz1Nf/d3f6fx8fFMBUmxWNSXv/xl3X333Vv8OwAAAAAA8wHBxAJ03HHH6VnPepae9rSnqVqtql6vZ5pV1mq1zFSDeBUN31SyUCio1Wql4YRVEhSLxcxA3YcSktKGlb6BpoUZvpGln+4Q92aw47D7rBeEPc4vB+qnjthx+O0Za7RpQYi/3Y7ZzimezmH/+iVJTRzw+OPpdrtpBYoPHsrlspYsWaKDDz5Ya9euTa+RBT9//Md/rIMOOkjdblfXXHPNVvwNAQAAAIDth2BiASkUClqyZIlOO+007bnnnmmVhFVI2NKeNn3APrX3A3kboNvAOZ5qYNUO/ssG4n7ah69+sH1ZMCHNBAR2XP42CwUs/PC9IeJGm8P4iophfR58U07/r2+0Gfem8PuMe1T4pVbjJqJWUWJTX3xVil1fe41suom9Ri996UuVJIkmJyd12223qd/vq9FoaGpqanN/NQAAAAAgNwQTC8iee+6p97///VqyZEmmwWW1Ws2sTGH9GWyA3G63JSnTV0FS2ruhVqtJUtrk0QcIvseC3W/b9pUHvv+DPc++t237KRS2/xBCeky2GsdcS3WGENLwwe7zQYCvZrAKEB9+zBU82PXy01Pa7bba7bZ6vZ6WLl2auZ52DWwbhUJBIyMjs5YOtSDHAiI7Pr/kaZIkWrx4sT796U+r1+vp3//93/WlL31p6/3SAAAAAMA2RjCxALz5zW/W7rvvni79aYGCfe+nVVjDyEqlklnK0k+R8EtySkqbYxYKBXU6HSVJkgYWFi7YPuz50uxlQv3APu5rYUFGu91Wp9NRv99PG3Ra1YP1lPANJf3qIbZ6h19W1B5n/G12XhZoWLNM34jT2DWyc2o2m2o0GmmIIGVXDPHPk7LTSWz7vj+HnW+1WlW5XM5Uc/jVUYb10QAAAACA+YxgYidWq9X04he/WAcddJCWLFmSmX5hX5VKJR04m2ED9XiVCbstDg7scTZ9waYw+EoH31vBL53pqyPseX6p0F6vp06no3a7nQkJ4moCXw1hx+fDD0nptmxaiq/siKs4/P6lQbNKP5XD+CoNCwtsKkwcysTTQOy62PH6KTHWO8OmdFijUHsN7HtJOvTQQ3Xqqafq8ssv36TfEQAAAADIG8HETmi33XZLGye+/OUvV71eT6skisVipnKiUqlkGkT6AbnvLeEbOcaVAvZYP73AQgEbwNsUCuO35wMEv3SnDxRsgG79GKwng29CGa94Ea8k4o+53++r1WqlYY0de7zKhz9f39zT7yeuUrBAwc7NN9r0U0Hs52GrePiqFAuAbPWUeNqN//eQQw7RHnvsoVWrVmn16tWZ0AIAAAAA5iOCiZ3QX/7lX2q//fZLezaMjo6mq25YIGF9C6rVavqJvK86sDDApjD4pSwrlUomsPA9HHxzRj+AtmoAY9uzSgRf9eAf66sw7F+rRrDj880srWIibmRpt1mVhP/eP8b32yiVSpkpEr4qxK7FsGDBX4tyuZxOPfGVJX71Dx8y2HQV63NhIU+lUklfQ/uy6+Cvf7/f1+67766LL75Yb3nLW/TAAw9sm18yAAAAANhKCCZ2IvV6Xe9+97u1bNmytLnlokWLNDIykg6Aa7WaKpWKpJlmj756QZqpEPBLZPrpCFYxYNUDrVYrU6EgKQ0mpJleEr4KIB7k28DdD/R9jwt7jDQIBGy/PrDwfSrs2KxiwLbRaDQyTSxtKoQ9v9lspiGABQK2D1994I8tXhZ0cnIyDSakmdU+7Bx9lYq/DtZLwleGhBA0MjKSVrfY462yw47bVkfxwcgHPvABfetb39K//du/PZlfKwAAAADYpggmdhL77ruvjj/+eO2xxx6q1+tp5UO9Xk8HtFZB4ZtD+k/vfSBhg2Xfe8H3T/Diiot4qoKffmEhgFUw2GNbrVamr4TvFzFsKkmxWExXvfD9I+zxvimmPy/P7vcNN237kjLnb7fH0zbi2+z8a7Vaeszdbjfdh9+mP1a/vWGrj1hQ4sMX/1pZgGSvTa/X05IlS1Sv14f8tgAAAECSTjnlFL3kJS953Mfccccd+tSnPrWdjghYmAgmdgJ77rmnnv70p+v444/PTNewT/z9EpNxo8t4YC8pM9CVZgbqcXDh+z/Y/TZFxPdUsMqFeEUMCyb8Mp6+2aUFBb5Hg29I6Y/f7vMD+vix8SocNu0k7lHhB/3+X9u+P65SqTSrYiOusvDTVvyyofFt8XKqdqzWB8P3/7BjtH3a9bNzs2qLZcuWaeXKlbrnnns24TcJwPayYsUKrVixYrOf1+129dOf/lRHHHGExsbG0ttvu+02LVu2LLPN3//+95qcnNQRRxyhW265JbME8bOf/WzdeeedWr9+/ZM/GQDYgR177LF629ve9riPufHGG3XrrbfqlltumfVBF4Ctg2BiBxdC0Ctf+UodccQR6UDbSvvr9Xpm0G4VCD6MkGYG6MZ6MNjz/JQBWzEibpjpP8mvVCpqt9uZAMJXVfipCr7ppT9+e64PFmzaiQUMFgq02+30/Hzw4qegWEBit9ux+FU8QgjpFBgfHtj+fPDhp7b4VTSsWsKeZ/0ifPDie1P4ig2rKul0OunKG36VEx98+NVOqtWqWq1WJoCxczvppJN0yCGH6K//+q9nTdkBsP34qixJOuuss/Se97xns7ezbt067bXXXvrnf/5nPfvZz05vP/zww/Xa1742s81zzjlHq1at0g9+8APtueeeWrt2bfqecd111+m//Jf/ou9+97u8NwBYUPzfo/EHRnN57nOfq+uuu0677rqrms3mdjhKYOEJj5f6hRCIBOexUqmkD3zgA2kfiZGREXW7XY2MjGhsbCz9NM0+2feDWV8lUSqV0gaN8dKYfgqCvXm3Wq20x0GhUEhXi4g/+feBgFUP2HKfktL/Idigu1KpqFqtZlYNkWYaVxYKBXW7XbXbbTWbzTT0sD+qfV8LaaZ/g7FAxI7Tr8bhKxP8iiCdTketVkvtdjuzvKgdo28UaucYhx2lUknj4+PpfWNjY5nXwKoh7PrY/vyyqDYdp1QqpdfJB0T+uY1GQ1NTU+lUl1arpbVr1+pd73qXxsfHt+FvJLwkScITP2rz8J684zrrrLN0wQUXpD/XarU0xNwcSZJo/fr1WrRoUeb9bsOGDapUKpltNhoN9Xo9jY2Naf369XrjG9+of/3Xf1W9XtfatWvV7Xb11a9+VWedddaTOzlgB7C135N5P95xnXXWWXrb296mpz/96br55pv19Kc/fZPejxuNBsEEsBXM9X5MxcQO6ilPeYpOOukkLVq0KB20SoPBea1WSwe7Ni3DKhPiQXM8DSKevuGnbPhmmPFymXHDTL+ahr/NVyv4L1thwr780qMWKJTL5cx2/fQLSZmBui396RtnxlMzLDTw/TfiaS3tdnvWkqlWmeGvgW03voZ2X7VazazI4ftLWOhjgwyrWIlX7fDXS1LmGsVTdew6WrAxOjo6qz8GgG1rdHRUn/70p1UsFnXwwQdr6dKlT3qbIYSh21m8ePGs23yPmSVLlqSNj83Y2JhGRkae9DEBwI7k+9//vtrttr761a/qkEMO2eSQuFKp6JJLLtEHP/hB3X777dv4KIGFh2BiB7R8+XIdfvjhOvroo2c1rYwrI/yAXJoJIOJBqt3uG1v6gbwFGr5ywvdwGLZNe66FIz5QsBUrbN+2X3usDar9OVjFQhww+AG+/ex7QcSPN74nhg3s/fKgdjzDVv2wYMJff3ueD27sPgtJWq1Wpopj2LH5wCUOOeL+E3E/jhBCWiURL9d62GGH6c4779SaNWtmvU4Atq69995bxx13nE4//fR5EwoeddRRGh8fT3sPAcBC9Jvf/EaNRkP//M//vFnPKxaLevWrX60vfOELBBPANkAwsYMplUo64YQThoYSSZJkmkda48X4ccP+SPZhgQ3+bUBug3AbUFuFht3u/8C1qQk2XcNXPMTn4Y/JN5S0ioFut5tpsOkbXdoA3PdhiM/TGkDOdd5WJeHDHH/+cbBh5+uDDKtasOf4igt/PBYo2GN980rbp38d7T4LbeIgxF8HX3Vi00ys74Tvv/HmN79Zl1xyia699trH/R0DsOVqtZpCCDr55JM3+4/ebe28887Tueeeq3a7nU6VA4Cdlb0fD1OtVrfz0QB4IgQTO5AQgt7xjndo8eLFaXBgPRmq1Wra68E3XSyVSmmJWqfTSYMGYxUQ0sxg3m731Q22DevR4Jeu9D0ZbD+NRiMdZMdLZEqDEmOrRuj1emkjSx+K+CoAu832ZSXJfppIvV7PBDFWYWHbiKdt2LXzYY7fV6/XU7lczlRz1Ov1TMDgKzXiSgZTLpfVbDbToMiHFr7hkgUt1hvCwhHrtzHXKiOS0moPu9blclnVajV9jAUUm9LgCcCWqdVqeuihh1StVudtRcK1116rv/iLv0iPEwB2Rv79eJj5UskGYAbBxA5i2bJletnLXqZFixalTRt9A0dbEtQG5pLmDAZsioSf8uCnePgpAHZ/v99PP423gCCuDLB92eDaV0FI2U/3pZmBvF/RwsIKXwVgy43aPuJtWqWHH4jb9v3qIr6xpV9KNR7s2/e2X18x4c/dHu+ny8T9NuwxfgWPeCqI7cvO1U+nsf365/hVPvwqJf562/nG00YIJoBtJ0yv7LMlTS23l6OPPlqXXnopFRMAdlrHHHOMLrjgAi1atIi/e4AdCMHEDqJer+uAAw7INLH0Uwqk7HQFP3DudruZ1TXs33jpS18B4ZNkCxxs1Qo/ZcQ/zveSsJ/9vz7I6Pf76coew5aq88dmPSds5Qrbpj9XCxx8c09/bSxw8dM24oaf0sw0DrvNqkx8eBGHN/Gx2G32PF8pYec81+tk5+pDI6vcsFDDN+L0PTl83w47f1+V4qfCANh6jjvuOK1cuXLWykDz0bJly3TiiSfmfRgAsE0cd9xxOvXUU7fp+9yJJ56oyclJXX/99dtsH8BCRDCxA7CyfPvE3gKCer2uWq2WDmQ7nY4qlcqswMBP4bBAwAxb8SEu+ffTOuIlNiWlfR78oNpXP9gxx5UJfhWJRqOR7s+HET7UsG35igS/FGoIgyVH7fnlcjmtLPDX0o7Fr/rhV+GQZla1aLVaqlQqacjhG4z6gCce9PseHb5qxQKGuHGnVWdYbw27hj6EsNfFV3HY/XaeVlViIYyfltJut1Wr1VSv1zPXG8CT89a3vlWvfe1r8z4MAFjwtsf78Xnnnae9996bYALYyggmdgAvetGL9Ed/9EdpCFGr1TQyMqJ6vZ5ZgcMqB/yn9cViMe1ZYI+1Sot4EOuX7bTtFQqFtH9FpVJJB/Z+ysawFTP8Khy+YaPv72BL2dltfoqJr/SwKgPfT8KmpNixl8vlTL8IO0c/5cSW4PTH46di2PlIM30ybFBvxzgyMjJ0ZQzPHmvX0lddWBhjlR9JkqRhSrfbVbPZVKPRUKFQUL1eT/tLWIBjAUetVlOn0xm64omvjPHXp1Qq6YwzztDRRx+t9773vdvldxcAAAAAnggTr+a5008/XUcffbRGR0c1MjKSrjtvFRTx4NMqFTqdTjog9qFAuVxOB8W+AaPvU2H/ViqVNIyw2y288AN6P/XA92PwUyfs+1qtprGxMdVqtcw2/TQHSZl/7Ryr1Wr6GDs/PxC3fVqFybDVSHwoEa+qYYP5brerVqulbrebGdT7FTfi/hy+usF6RNhr4Rte+tVMfKARTxWxQKJarWpkZGRWLxF7re25vnzcV7tYSOL3vXLlSn3gAx+Y1/PggfnuiCOO0E033aSbbrpJJ598ct6Hs8luuOEGHX/88WkICwA7snPPPVef//znt/t+X/rSl+qaa66hhwWwFVExMU/VajU94xnP0H777aelS5emAYE00zvBD5Sl7OoVkjKfmvvBsG8wKWUDivjLT7ewwbhfotP2Hfc+8M+zbVlVg1UI2DFbmGArfsRNOONVLOLwwp+rP25bPtP3kPDBhA9T4nDFjskHCZLSkCGukvC32bWNl/60+/1KIXF1g73GtVotDWL8ihz+fO3Y7LoNW63DXxOrShkbG9OBBx447+fCA/PVCSecoFNPPVXHHnts3oey2cbHx3XrrbcO7e0DADuSN77xjfrTP/1T7bPPPjrnnHMkSQcffPB22fduu+2m5z3veTrnnHPmfD9du3atvvKVr6Q/77XXXnr1q18tSbr66qv1m9/8ZrscK7CjIJiYp8bGxnTyySdrbGws7fJun9r76RvSzADdf4rvV7aIV8PwAUb8Cb5vkmmDWWPb95UYxh5n0zHioMNCCT9lxAbkVkkxMTGRWWXD/vVTQHxlhF8NxB4XBzU+VPHnL2VXy/DXxY7XhyW2DZsO4ptfxk097drGq3HYa9bpdDKhi1WwFItF1Wo1VSoV1ev1zGocfn/GV1DYNfc9PeLKDqu0sL4cu+yyizqdDp+cApth+fLlesMb3qAzzzwz70PZIvV6XU95ylNohAtgh1UqlbR8+XJ96EMf0l577SVJ+sd//MftfhwjIyO68MIL57z/rrvu0g9+8IP05yOOOELnnnuuJGnjxo1au3atHnvssW1+nMCOgmBinioUChodHdXixYvTUMIGvtLMoNqvkOF7OtgUChu02kC+2+2qXq+ng+tSqZT2epBmBrtWGWDbjj+x9z0qbCDsKyr8dAQLHnyzTBsg2zFbfwh/nNVqNTMNxC+DWalU0oaRfpqHDfztGvpBva/08H0s7Fhtaki8Kkm73c4EHhZ2WK8NW+bTXxtfgeHDCl8tYdes1WqlTTV9cGAVFHE4ZM+3a+KDIrv+caDigx07lo9+9KO66KKLdOONN26l31pg53fzzTdrxYoVeR/GFjvhhBN011135X0YALDFDjroIP3yl7/M+zCe0IEHHqh77703/fmGG27QU5/6VEnSV7/6Vb3qVa/Sy172srwOD5h3CCbmoec+97l6wQteoNHR0bTKoFKpqFAopA0P/VQMPzXBxNUMvnohDg38J/b2XL+spZ/yYduzagIbAFtgYNu3Y/a9GYwfMFuDSElasmRJZnWPWq02qxdDPL3DjrNarc5aCcNXeNh+40oPf+38iiMWAFkAYvtrt9vp9nz/Dik7dcZY40x//D5M8kuC2vc21cX3wPD9NPx0FB8a+eP2K5r4UMSOL56iAgAAMN+9/e1v1zve8Y68D2OLPPOZz9Sdd94pSdp7770VQkh/fuMb38gqH1jwCCbmmec+97k66qijtNdee2WmPkizAwhfsRBXL8SDb/+9n97gl6L0y176YCLeRhwO+IGxPc6CDzsuCx/8Ep/xFAy7zVeC+D4N8VSMeLUPz87Tr1hhlQd+qU2/TT+499UffnlV24afhuIDoXhb8Sogxl8rf+z+mHxfCwtH/Dn462IBk+9t4StS/Pe2nWHTQwDM9sd//Mc64YQTJA0C1B3ZXXfdpa9//es6//zzM9VYADDfvf3tb9crX/lK7bfffnkfyhap1WqzemDYz29+85t10kknqdFo6KMf/eisvy2BhYC/SuaJQqGgZcuW6YUvfKH23HPPzPSNYYNne440M0i223xfCSk7CPa3+8G1v80PYOOQwPYRN6/0bEUMv01fZTAsEIgbWxrfi8IHFb5Bpm03bvpojSH9QN341UPiXh0+oPBTZPr9fjpdxMKWYQGL/z6eAuOvga+48MFO3MjSroG/7v758TQNE6+a4l9bew7BBPD49t9/f73qVa/SW97ylrwPZav47W9/qw9/+MM699xzCSYA7BBKpZIOOuggveMd79hhQ4kn8rrXvU6StH79el111VX67W9/q2azmfNRAdsXf5XME4sWLdK5556bNj+0VTiq1WpmgOtXu5Bmmk0Wi8VZS3ta4OCXB41DgEKhoGq1mm7PKib8Sg+9Xi+zlGepVMpMj/CDZ2nQDMj6N0jZsMOLgwgfNvgpEPavnbefouArRez2uLLEKgPa7XamT0ccdsShgF1rmz7j+2/Ytn1Fhk0HsdfFtmFTU/wyov57HzjYcyuVSnqO/vrYdRlWJeKXi/XX3fbT7XbTc7H+I0zlAB7fv/3bv223Lu8AgNmWL1++Q/SU2BqWLFmiX/ziF3rOc56jm2++Oe/DAbYrgol54JhjjtHLXvYy1Wo1jY6OpgNG+zQr7g8hKfMJvqS0waRvMun7JNhA1ga8VilhzRZ9KGADYP8pfaPRyIQGvrmjX0LT+mC02+3MoNiO0b7iCg4/BcEG7T5AiKedWIVAvGyp751gq034HhhxEDKsQsRPvbApIPazBTa+kWVcgeLDBLvmFgj4/hJ2PUMImdU+7Jz9eds1tm3735F4VRW7hva7ETfgtCagwypUAAwsX75cN998c9rxHQCw/b3xjW/Uhz70obwPY7u76qqr9KlPfUrve9/78j4UYLshmMhJuVzWi170IpXLZe27777ac889Mz0l4j4Ow/oB+AG5X7XDBrdxdYQNbH1w4VdvsAG8H3TbQNd6HPhBrh1DfEy9Xi9dKcKOPW5K6QMWSZlBt5/+4FfSsPOwgML6KvhQxVcAWBPJOAQwPliIAw47Ngsb5uq1Meza+V4Qtl0LgPyqHPHrGE/b8cGJP0/rAeJDHgtA/PSNZrOZVtL4RqXDXkcAM0444QS94Q1v2KFX35jL4YcfrgsvvDDTOwcA5pORkRFdcMEFCiHoyCOPXJAB8e67766lS5fmfRjAdkUwkYORkREtX75cz33uczUyMpJWOvhPwX2o4KsA/EDSl/P7QfuwKR9xMGEBQafTSacASDNBge/HYLcPCyPsGHyfCz+tw8Q9J7xhzTCH9WXw/8bNJOMGmlYxEE/xsIDDn4/dN6wHxVwBjA+NfMWIBTj+2sfhhoUT8ffx9v0KJfZlYUK1Wk1XIrFwwl7zfr+vSqUyq2LEllb1YU/8WgALValU0jHHHCNJOvXUU3XmmWfmfETbxlOf+lSdddZZeR8GAMypVqvp7LPPZropsMAQTGxnIQQdeOCBOu200zQ2NqZ6vZ72hrBPwm2AGTe0tE/EbTvS8EG+DY6tYsDCCr/Kg23Dggkb3PZ6vUwvBz/1IA4nfC8Gv6Sm3599WR+LeBs+KDB+Oocdp335/hJ+oG7TWiyI8EGJvy5+CkOn08mcq2/Q6f+Nj9XO2TfJ9EFEvAqHVTsMa04ZV1T46Td+6kW321Wr1VKn08mEFPY7USwW098h+12p1WqZSgk7ZjtuO19goQshaJdddtH111/PH8IAkKP4w52FKJ7SDCwUBBPb2Z//+Z/r4IMPVr1eV71e18jISOYN2DetjN+QLDTwUx6kbNNI+77f76d9HqzHhN0ef1puoYLd32q1MtMwyuWyut1uZkDslwJtNpuzGlL6ppIWBkizKx38dAU752FvxH65UduOTRexwbg1t7R92Hn43hW2/Kddc9tGr9dLr5cfxPtAxk9D8atd2PHZcdtx+KoXHwbZtfFTVGxbvuGoXfNh12xqaiqdYmPNUiVl+ndYqba9pv769/t9veUtb9GaNWs27RcX2Im96lWv0mc/+1lCCQDI2UJ/P163bp0OPPBA9Xq99G83YKEgmNhOCoWCTjnlFK1cuVKLFi1SvV5XrVbL9CnwVRJ+gG+3+0+//Rt2PHD1g2I/pcOmBvieCtZEst1up9uxRow2gLVKA9u2348Nom0lDj/Y9o0abWlNKdvbwU8p8dsul8tpaOCPwfd6iAfztg1rCBmv0uGviw8Y7LracdmAPr6udg1tuohVk9g2/GN8IGPH7Xtt+J4b9nobXw1i1y/ul9HtdtVoNNIKCv97Y78vvmLFB012zJOTk3NOJQEWkkqloiVLluR9GNvFz3/+c1144YX63Oc+p49//OO6/PLL8z4kAJAknX/++frTP/3TBfN+HPvxj3+sT3ziE3xohAWLYGI7GBkZ0T777KMjjzxSIyMjaX8A33zMBtR+4O0bOvrpDf4T+7jcLe67YPxg2FcBxL0VbF9+oBs3mPQDfdt/vV5Pl6OMl/qMm1/aChX2KX98/D4Q8KFEu91OKzXiMMV6KlgQYFMj4iklcd8Nf1w+fLH74ooJuyZxE0/jz9WOf9jr48/P9/8YNl3GemfEU1eswsPut+eUy+XMtA5fRVIoFDQ1NaVVq1YRSgAarIp05JFH5n0Y28XPf/5zXXHFFfqXf/kXnXbaafrmN7+pVatW5X1YABa4QqGgF73oRXrVq16lo48+Ou/DycUtt9yiyy+/XN/+9rfzPhQgN+HxuvKHEGjZvxXsv//+Ov300zUyMqJyuaxaraaxsbF0ioT1lqjX65nBqE2jsEoHG2hbgGEDcD+1w4IFe248HcGmMfigwcSVGzZ49kGCNem0CohyuZz2yOh0Oup0Omq1WmklhqS0wqBQGCwl2mw21e12VavV0mO0KSzSzFKm9jgbQG/cuFHVajVt5NhoNNLqiGKxqHa7nRmYW6jjl9T0g/skSdIyOSuZ6/V6qlQq6TUYNs/RV3bY8qn+uB+v9M4HRBbk2DWKK2Z8QJIkidrtdvqcTqejRqORVr3UarX0dbCf7XVvt9uanJxUq9XSxMSEbrvtNv31X//15v4aYzMlSbLV12LlPXnrqtVquuqqq3TiiSfmfSjbhL13V6tVNZtNnXnmmfrGN76R92EBudja78m8H28dhUJBS5Ys0erVq9N+ZAtNs9nUy1/+cn3ve9/L+1CA7WKu92MqJraDYrGoer2u0dHRzMoJ3W5X7XY7MxAeNn3Af5pvUyZsZQY/2I6rHPy0Dz8lxJf+WzWEDcDtk3Zpph+Cb5Bpt1vFh90+MTGRaS5pUw8kpSHD1NRUWlFhg2pbPcP273tBNJvN9Nzsy362EKFarabHZWGIbcP6TliAUygU1Gq1MtfZBzQWoPjKEr/Epp+64ntLWCARN/F8IhaaWJBhYUTck8JPwfErqNhz/GN8NY1vOGrH/tnPflaXXnrpJh8jsLOq1Wp66KGHtGjRorwPZZs577zz9LOf/Uzf+973tN9+++mRRx7J+5AAIONFL3qRrrjiigUdSuy1117auHFj3ocC5I5gYjuwVSl8dYBvUDhsRQxjg0oLIfw2Y74RpJSdDmL7sUGrPc4PxG3ffoBuPRV81YHvFdHv99VoNDQ5OZn2WbBz9fvwS1T6bsM24LYAwM7Dpnz4YMIP2O3a+R4dvsmmHX/cR8I3prQgwzcFtRDGV5n40MhPmfDVGb4ypVQqZaa/zNXA0k+z8Ct3+FVFLDDxwYifHuKvT7vdTitZ7Dl2TLYvC8SAhc4C1p25wdpZZ52lG2+8US996Uv12GOP0eEdwLxTLBYXbChxyy236F3vepc2btzI+zMggontwj7ptqoF3+sgHlgP67HgAwbfu8AGnPESoj6ciJeJHPbG5wewPhyxn+v1eqZPg/+E3vd/sAG4TS/x27QqAz/txPbhezL4wbnfvj9Ge76/Tn7JUr8tv9TpXEtn+ms317Xxr4dt278Ow5pY+ms4rBLGv1Y+CLHt+vOOH2vTafx+fOhjIY5tt9/v6/vf/77+8Ic/DD1PADufjRs36p577tE111yT96EAADT4e+2b3/ym2u22fv7znzN9A3AIJrYDG7jb0qBxMGEDfT+Y9J/oS0o/ifefqNtzLKDwq0lI2b4F8SfnNsC1x9sA3Vcu2KC7VqulA2b7dN++/HKbPoyIp5XE4YlfwjQOE/yypH55Ut/MMm4yOexfP4XBByB+2ou9HnFo4SsTfLjhp1jYY/x0Dz/txq6nDyYsLPEBRlxJYdvw18Dvc1hQ5aeY+PO013H9+vW64IIL9Nhjj23eLy+wk0qSROvWrdOyZcsyjYh3Jpdeeqk+/elP530YADCnTqejdevWaZdddsn7ULa5brerdevW6U1vepPWr1+f9+EA8w7NL7eTarWqiy66SJVKJTP49f0KrNLA7q/VarOmZYQQ0oZmPgiwPhZ+mVAr6fehgZ9S4h8rzYQClUolM5XA9zbo9/uanJzMTH+w8MEeNzo6moYZ9pipqSm1Wq3M+dlx23KY5XI5rZKwFTc6nU4aGthjrfKk1+ulUzMqlUrmWvpwR5oJh1qtVnq7Ne+0YKDX66VBi23D96ew6SX++vp92etpj/HXxQcXwypXfMhiAZVfCtS/nuVyOb2Wdn0tJGq32+l0lEqlolKppHvuuUd/9md/Rpngdkbzy/mvUCjo6quv1otf/OK8D2WbSJJE119/vY4//vi8DwXIHc0v56/R0VGtWbNmp5/SceONN+r5z38+f49hwaP5Zc7a7bY+/OEP6/TTT9dBBx2UqYaQlBnEGhuMxxUN8XKU9n2r1ZrVvDLuiWA9CGybNki3T+V9LwpjA21fERA3pLTKCpuyMjU1NesaWPWAr1Kw6ggbrMdVDX65UEnpcdr1a7fb6bbjZTH99BFrmNnv99Mgxvbtr5ev/vDXzQcLflpH3HzU7rNzs/35qSu2/bg6w55r2/TXxj7RtesRhxIWmjQaDU1NTanf7+sTn/iEHn30UTWbTf4nCAzR7/f19re/XUuWLElv++IXv6jDDjssx6OaccMNN+i8887T9773vXR55Q0bNujkk0/WF77wBR122GF65JFH9IpXvEKS9KY3vUl/8id/ote85jXpNiYmJnI5dgDYVFNTUzruuOP0T//0T3rOc56T9+FsU/w9BsyNYGI7SZJE99xzj66//nq1220dc8wxmf4EfnBsj/cNFH2PCLstnqJgg36b5uBDAz+w980P7VN+P1i2bfvH2r9xLwg/ePbTG3yY4fnztJDBAhirovDTF3wQY+ckzfRg8PuxP9yH7dOHO3HPiLiiwTcg9YGBPddPg7HXz78m9ry48sKuv/+dkLL9NuJt+vP2FTLWT8Oeb9u9++67deONN6rX62nVqlWUCgJP4Ne//nXm589//vNauXKlxsbG9Jd/+Zc5HdXA+Pi4br31VvX7fV122WW69957NTk5qZtuukkTExP6+c9/rssuu0w333yzJOmUU05Ro9FIfwaAHUGSJPrpT3+qSy65ROvXr9dJJ52U9yFtddddd50uv/zyvA8DmNcIJraz6667ThMTE3rqU5+a+aS9WCxql112mTWwjZtfSjM9D+w2G7zb9vxKGL7Bo32qHg92bX/SzAoiFhw0m81Z0yRsmzbFIm4QaVMQpGwQYVUOvoLAAo9Wq5XpoWHH6Hs0xM0zbf92/BYa+GDBhy32vLj/gq+E6Ha7aad+HxiZ+Fx9WGLbjx8vaVYFhA+V7HrYucW9Jfx1sm1a5Yv9bPPlb7zxRn3+85+f47cPwBO58MILJUnLly/Xi1/8Yi1fvjz9b21r2rBhwxMGh48++qiSJNH999+vCy+8UD/84Q/T+x5++GGtWrVK73//+9PbxsfH9dBDD231YwWA7eFTn/qUHnroIR166KGZ20ulkpYvX57TUT15q1ev1pe+9CVdcskleR8KMK/RY2Ke2HXXXXXhhRdmBr02zcIPyovFYqZPRbFYzJTqW9WALRFqj/UhSL/fT3sVWF8L+z2w3hY2iLbQw7YrKe250Gw21el0VK/X0x4Ivn+CTZ3wzTntMVNTU+k0jHjahZ920m630696vZ5ZBrPf72vDhg2ZppXxl11DqyLx00c6nU6m34Sdk+9jMWy7fplS39TTAhvfq6JQKKjRaKTHWKvV0uDHV1r4JVrt+KSZJWA7nU5aUWJhkPXZaDabGh8f19vf/vZZn/4iP/SY2DnceeedOvjgg7f6dt/3vvfpAx/4wFbfLoDh6DGx49pnn31077335n0YW2zFihV64IEH8j4MYN6gx8Q8dtxxx+mVr3zlrE/zJc2qVIg/wfef/Nug1S/5Ga9e4bdhUyHixzQajcw0BHusfT81NaVmsylJaYPFeDWIfr+vRqOhRqOhdrudHps008fCqgXsWH2QYfu3ho7WtNKaYtpg3u6347Zt+nChUqmkwYo/RgsPfJ8HHwrYdqxpaL1ezzT1lJSGJnatSqVSZpqFNEjKC4WCRkZGtOuuu2rp0qVpaGEVFr46wk+t8a+RXUO7Bq1WS41GQ4888oj+9//+33xSCmwDL3nJS/TOd75Tb33rW/M+FABYcF7/+tfrfe97X/rzRRddpP/4j//QVVddleNRbZ4f/OAHeu9736t/+Zd/yftQgHmNYCInlUpFp512morFog488EDtt99+arfbmYaG0kyPhRBC2lzSPt33lRV+tQ4b9FvAYI/30wUkzfpkXprpueDDAUmanJxMqwdarVY6xaNSqcxaDtSvTmHBQbfb1YYNG5QkiUZGRrTLLrtkpl8YP5XDlhS1cKFer2dCm0qlorGxsXQQb8fmVxEplUqq1WqZ/hM+bDE26Pc9LezY7Jr6lTcsxGi1WpqYmEhXybCpNfb4JEk0Pj6ucrmcvqZx2GTHYvuzahH7suDDV7FIg1Ck2Wxq3bp1uu+++zKvF4AnZ/Hixfqbv/kbSdIRRxyxSc/pdrv6yEc+kpl6NZfrrrvuyRweACwIv/71r/XlL385/fm6665Llz7/+Mc/ruOPP17HHntsXoeXsWHDBn384x+XJP3Jn/yJXvjCF0qS9t9/f+266655HhqwQyCYyMHo6Kj22Wcfvfa1r00/2ferY1gw0Wq10moDm0JgS4j6wbU9z8IAW+7TnmuBhg2q4yBAmgk3/HQP+wohaGJiIm0waZ/a20oRNli2gbFVDVgg4asLLHCw7VjYYedh27Pj9sfmr0+/308DBwtRarVa2oHepltUKhVVq9U0mLD9+YaX/ppbFUXc5NOqLyxwsOvow4ZOp5NeU9u/lK28aLfbmpycTK+JDxPsmCwMsaDErmO73U77bfi+IpL0lKc8JdOjguoJ4MlZsmSJ/vZv/1bSoNfDHXfcoRCCDjzwQJVKJTUaDf3+97/PPKfVaulDH/pQGiYCAJ6cm2++eVZD3/3331933HGHPvaxj2ndunUaGxtTCEEHH3zwrF5fkrR+/fpZUynK5bIOPPDAWY+96667tGzZMtVqtfQ9fsWKFVq8eHH6mHvvvXfoikcPPfRQOkVv7dq12n333dP71q5duxlnDSxM9JjIwYknnqjzzz9/1tQMvzSlJG3cuFGTk5MqFouqVqtavHhxpj+Bb7zYbDY1MTGhdrut0dHR9NN8e57/JN6voGH79APpEELaF8ECj/HxcRWLRdXrdS1evDidwmGDaOt3YBUaU1NT2rhxY1ohUa1W00F1uVxWvV7PLJlpg28fCIyMjKQD9XK5nE5rsPP2S67a89avX5+u1GH79T0mfO8I3yjTL+MZr7QRVzXYNbJQY3JyUu12Oz02/xgLnOKVNyzM6XQ66na7acgjKRNOWPXGhg0b0p4eVpXhm6BaQFIqlTQ+Pq63vOUtW/V3FpuPHhM7Nj+n2feDuO+++7RixQrdcMMNet7znpfnIQLYDPSY2LkVi0U9+uij2mWXXWbd95WvfEWvf/3rM7fN1bdixYoVOv/88/WsZz0rfY//6le/qte+9rXpY04++WR997vf3cpnACwc9JiYR2zAWqvVMlMLbHDp095araZSqZROZYinWfgwoFarZVapqNfraZWDX6nCBwB+RQrbt33y71fOGBkZSasWxsbGVK1WM6uGWDDRbre1YcMGrV69WpVKRSMjIxoZGdHo6OisZTn9tZCUCUYsNPAVEna/VSfEUy586GIVB3acFrK0Wq206afvrREvx+mrEWxKia8I8eHD6OioRkZGMq+LD5x8KGOhiK1c4lfq8NUr8eu8aNGiTHjTaDQkzQQqFiT1+32NjY3poosu0gc/+EE98sgjW/IrCmAOz372s9MwFQAwP/R6PR1++OFDKyampqZm3fbggw9qxYoVs25fvXq13vOe92Savp999tl65zvfmf5sU0kAbF0EE9vZKaecouc///np4Nd6Idi0Az+FwvpJ+C9rguj7I/hwoFqtpgP6TqejVqslSenzLcQY1hDTf8JvA/okSTQ5OZkO0n2vBRvIW0NI++p2u5qcnMys/PF4A3v73gcT9hwfGNixWqWF3W7nbtNE7Dz9Pn1gYd/HK2vEzTvjY/TXSFImmLEgJO614Y/ZjseOz+6z7flpJf5aWEWLXSPfG8T2YyupWKAyNjam17zmNfrhD3+o22677Un/3gILzbp16/S2t71N733vezO3M00KAOan1atXb/Jje73enCtlxEs5r1u3TuvWrXtSxwbgiRFMbCchBD3taU/TCSecoEMOOSQt5beBvk0x8J+i+wG7hRJ+eU8b7NqA1PZj0x5sexZK2ODWN1e0Kgh7rg2I/eoYfsqIn37igwz71D9eVtOCFz9lyAIBe76fFmH78Mfqj8FXJPhztuf5QMWqKmyfFgr4UMJXkkjKhAt2X9xo1E/t8PuXZipY/HlZL404yPDBiq/8sOkafrvxtBN/HlbRYdfIGo6eeOKJ6nQ6Gh8f1z333LOpv6oAJE1MTOjiiy/W8ccfr/vuuy/vwwEAANip0WNiOymXy/r85z+ver2eVkIUi0WNjo6qVqulDRr9tAKbGmEDfOuXIM0MzC3g8D0LfLVBu91On2e3F4vFtLeBhR7STCAwrOlitVqVpDSAGFY5YftstVpau3Ztpp9EpVJJz8OvmGEhRqfTUbPZzIQG8TQXe4xfscRPkbABul2LZrOpfr+varWaVpLYgN5PF7Egw6Z6+BDGV7T4Kgbjl1u1axUHMX551G63m2nY6bdnxz01NaXR0dFZIZGtctJsNtNwwhqixr1HGo1G2qPkt7/9rd72trdlqmyw7dFjAgDmD3pMAMD8QI+JeWDDhg2Ssk0UbSBrK1n46Rq2GodVPNjA0z5Nt6oEv4KDPdcP8P3UA5tGUCgU0rAgno/np0asX79ea9as0fLly9P5dn51CjsHaTAAr1QqKhQK2n333dN+CDbAt74ONni2+22A7pcqtSoDKVst4Ptj2IDdV21YpYVtK652sKaZ8bXx5+1XE7HtWPDRbrczvS98/wpfDWH8833Q4adixA034+Vg4/ttu8aOQZrpv2F9QorFovbZZx9dcsklOueccyhFBAAAADDvzO4Qg22i2+3qS1/6ku6++241m8106UcLFGzagU0FsAGtVVJYoOCncPj+CrYs5ujoaNqM0S8TagNdG9j7XglSdiUIv1pGsVjUxMSEHn74Ya1du1aNRiOtUrCKDL/Mp61O4adE2H02qPZTEmzqwdTUVKa/hmcDfqsOqNfrqlarqtVqaXPQfr+fXldJaehifIBh5+V7UNg18PfbNfOhiq+28IGDHaefruGDBTt/X1liX/73wPfPsNvtGtn3fr9WNWG/H/a7ZL9fdi2WLl2qN73pTTryyCO3zi80AAAAAGwlBBPbSZIkuvXWW/Wzn/1Mv//979VqtWYFE755oaR0NQ7/CXo8aPeD00qlkgYUNjC359qXDwiMDzk8a6ZZLpfVbrfTRpq+GaU930INX0lgj/Xf+/3ZbRZwxCtkxHyViJ2vD0VarVY6FWPYEp1x4BL3jfA9PXxVSFy9EDe59OfpXx87Xv+Y+Pz9qiN2Xe2cfGWJ//2wx/gv38PC+of4MKZarep5z3ue9t5771nXFQAAAADyxFSO7ezKK6/U6tWr9V//639NB7/Wm8AaW/pP7OMlNv0UAKs8sMfGTSJ7vV7az8Ae02q1MtMH/KDbtispfc7o6Kj23ntvNRqNNPDwg3sLJPzqFr5vhK8A8QNvm3pg+/IDez9lxRs26LfrYcGE34e/Vvb8YVUO9hi/bKnvneErHnzlg7/m/trHq37Ydfb7K5VK6fWJV/zwFRVxNYU9xvfssGO0KSVxgOEbjVqFib/+AAAAAJAnml/mIISgxYsX6xOf+IQWLVqUViVUq1XV6/V0MOn/jVdk8MGFH3z6gbOktKzfNBoNVSqVdABr+7RBvu95ISlTKWHbTpJEixcvzlQkWENG31zTr7JhgYZ9em/TL+yr2+2moYkFNtbM0rbR6XRmVRr4wfj4+HgmjOj3+2kTSdv3yMhIeixx5Yftxx+Xr2Cx/cZLdvopLLYNX3URByzWZ8NXQsQhlDTT8LPVamlycjINOGq1WjpVx0KUdrutZrOpZrOpRqMhSZnfk1KppEajofHxcd12222zlkDE1kfzSwCYP2h+CQDzA80v55EkSTQxMaFPfOIT+qu/+is99alPzVQA2IDfD3xNoVBIB+M2rcE+/bbn+cG2/wTfN9OMmyla6GBNNu0xpVJJrVYrU/1goYKvmvDnZp/u+54M9sm+Hyz7qoN4KomFB3a7HY89xo7B/vVTIvyA36Z7+CVMfT+NODSIp8vY423bvhGpf469RvEUkfj62DXyK3/43hH2XN+A1BqBzlVdYduM+4/YsdrvVbPZVK/X0/Lly/W2t71Nn/vc59LQCQAAAADyQjCRk16vp1/+8pe6/vrr1Ww2ddBBB2WCCRsg+5DCBvs2qPXLf/qpB766wg/ukyRJpwDEjSj9FAMbuPueDJ1OZ9b0Dxvox9Ma+v1+OoXEs23Fg3ofXNht8eoi/rxsW74JZ6FQUL1eTwfyNgi3qQu2DV/lYcfzeD0tLITw1R/GLx/qq1ts+3F4YOxax+GQ/RuvRuKrYuJVWvy0HB92xOGFr+ool8s6+OCDZwUmAAAAAJAHgomcXXrppVqzZo123313LVu2TO12O7Pqg/8E3yol4saSNvD2TRCNDbxtEGqDWik78LWqC9uOpDQkqVQqmaUwbbBvTTeTJFG1Ws1MT7BKDuuRYPv2IYpvBhkvW2oDbat0sAoRP/j2z/eDeauUaLfbqtfr6YoafipKkiSZaghfjeFDG7sWxqaU2P026LdrZBUccaNL3+fCBxNWLRGHMj6gKpVKqtVq6f79dfS/B3HY5AMRW0LUlkJNkkQjIyOZ1TsAAAAAIA/0mJgnli1bposvvjhtMGnLYdqA34cLNvC1QMD6U/jeDdJME0rPBra2/KTd5j9ht0oEP3D2jR9HRkYy0wRsHxZCNJvNNLCwaRa2Qogdvx2fDyD8ID5JEnU6nXQqRtws0w/w4xU+LByRpLGxsXS/1sPCzsOCiXiZTj8dwgcXcajgKzoshLHraVNLvLjJp4UFdr1tVZVyuZwJK+yc/P7ihqjNZlOTk5PpfguFQnp+SZJoampK69at0+TkpBqNhlqtlhqNhr7yla/otttue1K/uxiOHhMAMH/QYwIA5gd6TMxz4+Pjeve7363zzjtPy5cvnzUNwA+S/coLfopC3KfBBrzlcllSdtnMeGUKPzVjYmJi1uoWVhVgFRS+z4L9a0GDr3CwKg6b2uErE/zxWoWAr+DwlRVWkdDpdGZNWfDn5EMFP3C3n/1KGbaSh29U2Wq1MtfFP9euv9+nBSBe3OsjXqLVhz2+gamvwPBTTezc/XasesXCILsudm3s9fLX0M7BzjcOrQAAAAAgDwQT80S329Xdd9+t7373u3ruc5+rQw45JB14xp+O25f9LGWnPkjZIMMP8u2xcQ8Cv8yoXwLUtmcDaP9pvYn3Wy6XM1NS/PH5Y/N9MfzUDF+VEF8D47cbTwvxA+54v3Ew4p9n243PzQcIfl+2fVstxE9FiadZ2Lb81Bbbn00B8efknzusMsRfGx90PN6Xv/aS9JOf/ESPPfaYAAAAACBPBBPzzL/+67+q1+tpzz33VLVazaz2IClTLWFTLWwaQb/fT6sjfCNGGwgPq3CoVCpp7warSPArYFgVgj1+2KfsvreCpHSqiK9c8Mt42jSDeLWRuLIgbujo9x33bIibTcbNOO24fMgxrE9DHGoM679gVRP2ZddsWHjh+0346Rs2zcI374x7XNjrGwcV9rMPqfx1iFdzia+jHeNVV12VLi0KAAAAAHkhmJiHLrvsMt1666365Cc/OfSTfD/gbrfbmV4NNrj2jRvjXge+oWMIQbvuumtmG9YsUpqZhhAPpO04bBv2qb000zTStmMDd78PP50iDhX8YN0G577BpOcH6z6wsbAkDhra7bbK5XJmFRC7z57vpzxYmODDgfgYLOCIKxt8bwhrPNlut9M+Ir5CotvtptfLnm99QKzixU8x8cdsfSrsWG36SavVSs8zrvSIV0cBAAAAgLwQTMxTq1ev1pvf/GYVCgW97nWv00knnSRJaTVD3JDRN660AbmffuEf1+l0MkHHhg0b0sG6PXbYig/xl2+QWSqVVK1WFUJQs9nMNF+0KgU7duuJEDeaNH4AbdMVpJlpDzYgj1cgiVfqGNbPwi9Z2u1205U77Djb7faslTj8oN43tvR9IOxx3W531vQVHx74Y7DjtZDCqi4swLAVNPxUETt3H/L41U/iaTBWLeNfL0lDK18AAAAAIA8EE/NUt9vVAw88IGnQGNOaLPqlPn2lgp92EQ+A7XYbSNvz7b5Wq5UGF9bU0k9XsH36ECCeFuL7K/iBuYUKflWJONyIG3ba4Dpu9OmP31dZ+OMwft/2OD+9JV521CoT4qkhvonmXOfvm2LGoZG/7rZvfz39lBk7LquusHP3q4bYY/zyrXF/EDsu30jTH/vatWt17bXXDm3cCQAAAADbG8HEDmDt2rW6//77tffee0uaCSUKhYJarVb6KX08zcAaUcbLgdo2bHBrwYSvRLDgwqovfK+EYUuQ2iDY78c3ebRBdtz00rNP+P35WChhVQFWaWD7ins7GLsWPviwx/tjsaU5LRCIj9tP+fBVEz7Y8Nc8nlLir5HvbWGP9QGIHYO9pnZcfglQ25/97IOJuKGpr9iw69vv97VmzRpdeeWVm/jbBwAAAADbFsHEDuDrX/+6fvazn+nDH/6wOp3OrB4SvjrAVsOwL5ueUSqVMtUW9kn8sOUwLZQol8vpwD9uMCnN9Cmw7VnAYf0lpJnKBD+dZNiKGnYONn3BBuF+BRI7Xt9DQpIqlUq6vbiSIW5w6QMc28fU1FRaPeBDHL/SiL/OvjrEXg8fEPglTeNlVX1w4K9Bs9lMp2/YNBcLF0qlUjpdxq+0Ysdr4u232+3M1Bbbx7CGngAAAACQF4KJHcTvfvc7velNb1IIQWeccYae85znaGRkJG2s6JtIWhjhV92wygc/lcEG/TYQttUirAGmH8hLygQIFhpIg8G3HwTbJ/4WTrRaLVUqlUxTSL9Sha8M8A0o42oBG6D7FUmswsG276eW+D4WcbVHv9/X5OSk+v2+Wq3WrGoO3zjT927wIY0POCwssFU34ukZFoL4ShBjoY41uzQ+XImXE/UVL9a7Iw6OLHSywMe/7gAAAAAwXxBM7CC63a7Wrl0rSbrmmmv0y1/+Mh34vuAFL9Dy5ctVLBY1OjqafkrvB7TxtIlhvR38yhI+LKjVapnVHXxFgw8Q7HlxIGCrckjZ6Qs+6LCKBT/9QZqpCPBBiA84fEjib/ehht0Wn59f9cI3jfR9Gvw27Hn++vnpM/5nHyTYa+GnocSVIn6aSFz5EE8X8fvy1TE+cLCAyqo3bJrKrbfeqp/85CfDf8kAAAAAIAcEEzug22+/Xbfffnv68wEHHKA99thDtVpNtVotM1i1AEGa3dPAmmL6T9htVQ9pZvBu5go4/KDeD7ZtoOyrC/zz4lUrhk15sP36Y4/35YORufoq+CoDu91Cifg4/b7jQMBfC6uE8IGAXyHF95SwUMIHMr6vh99vPAXFV0T4yg27Vsb3ArHz9ddOkn7zm99o1apVQ88JAAAAAPJAMLETSJIkrZao1+uZqRLxgL7X66VTLOy2Wq2W6UVgVQ72qfvGjRvVarVUq9VUr9dnNZS0CgGrLvBLWYYQ0mVEfVWADxAsHLBQxKaf2JektPeCbcceb/0lbKqCBQZxBYU/Hr+SiZ86Yj/btBA73nj6i51zHMTYeVQqlXQqSBy2+CDCV3bYY+LVQ+x51Wo1PQarWPFNNG0bFvLYOfrwxaasAAAAAMB8QjCxE/C9EHyFgw2g/fQAuz0eAPvpDFJ2MO/7WFhTTBt0J0mS9pew7dvA2Pe7iAfgdpx+P74ngjXr9FMWfAWFHXO73U6DjnK5nF6DZrOp9evXZ6a2WO8ICwbsXPz1qlQqaTBhAYA0U4lhTSj9bdbPwpb5tLDEjtX3xej3+2o2m7MqPOLXyI7Hrq/t07ZZqVQyoZMFLL5RaKvVUrvdTv9917vepYcffngLf8sAAAAAYNsgmNhJ2ADWAgO/YoYNcC2M6Ha7mftt4G6frhsb5FuVhKTMFAnPBsT+k3kb1LdarVlTOWzwbPvwVQt+yU1j5+SX4oyrJ4rFYhoO2FetVkunUfgqBWmmcsNPn4invfggwh+L/esrTex6Dpu64isr4qkv8UolFur4io9Wq5XZx7DeF7aiib0Gvlqi3W5ramoq8/oCAAAAwHxAMLET8J+s+yoAm1IRr0wR9ykoFovpYDhuftnpdDQyMpLpVeG34cX9JeIAIA43rOLBKgLiRp3+OXZefvpHHCL4KQwhBNVqNVUqlbRqwzeZjM/DV4/EAUYckMTn7P/1x+7/9ecTV2HEAUZ8nCEEtVqtNDix1Un8/iyYsGtg4ZAPf+JzBwAAAID5gGBiJ+AHwzbQ9c0XfShhPRj8gDjuR2GDXpseYQNiv03/qb5Ni5CU9piwQbGfwuF7NZTLZTWbzfST/Wq1mvaWkJROh4incFh1RavVSsMM3+PBHjcyMqKlS5dmqh1sKobvyeCvl59yYv9aWGJVGnZuccjir6/9GzeejPtF+OPwkiRRs9nMNO0sFouqVqvp+dpSsDaNw3pLNJvNNKCw822325qcnCSYAAAAADAvEUzsJPx0Db8KhA1kfa+GSqWSeZzvgeAHy375Uas+8NUVPqSIB9gWFNhguFwuq91up/uxT/0t/LD92XH7xpF+ukPcW8HYbVZZUalU0qabPpCwfdj0hnq9nrlulUolbaRp18oHLD7o8A01C4VCeh62NKd9+QqIYrGoWq2WBgd2bfxr4KsgrNqh2+2mzU3t3Gybdi6tViv9stek2+3qvvvu03ve8x6mcQAAAACYlwgmdiK+osFPuzA+nCgWi2lvCRv4+oDBf+LvV/mQlKkC8JUGcSWGn0oizTTY9IN4SWng4QfzcRWHHX+5XM6soOErPKySwZ+7r2DwA3NfzWBhhT/HYddyruVL469Go5H2e7Dj9fz5+ADGN6+0So1SqZSujBIvg2oBkV/lw15HXzVhry8AAAAAzEcEEzuBX/3qVxodHdXhhx+eGezagNcG1H4AbOKlLiVlGlfa/bb6RbxMpVUb+CU0fTWFPc6OIw5F7HurdPDH7LfpzyM+h/g5vhrEL2Pqm1XacdnUEztv39hy2Lb91A07dx80xIGOb0g6bHUU3zDT71+aCXYs4PDn7UOKODzylRb33Xefbr/99sf9/QEAAACAPBFM7ASuvvpqjY+Pa7/99ktXkbBP3H1wYINmG9TalAb/ZQNh35/CKh18JYQ006/CQgZpMNi26SPxNnx1QKlUSnskWChRrVYzx2bTIIwf1NuUEj/Yt4G9BRI2ZUWaCVv8ChjWl8Gui03h8Ct1xE0o7X4/jcNuM9ak04KJdrutcrmcXqf4y19PX/XhA4dyuZz+bK/TsFVM7PG9Xk8TExP6yU9+omuuuWZr/roBAAAAwFZFMLGTuPHGG3XTTTdJkj7+8Y/r0EMPzQx+fRWBb4xoAUa5XM4Mzn3pv93X7XbTJor1ej3To8LzfRIsqKhWq+ng2h5v+za+cqHf76fBhU036XQ6aRWBb/Dpl/q0qRl+5Qrjw4Zer6dms5mpgrCQwE8r8cFMPHXDprD4gMCmV/geEBs3bkyrHvwqIb7qwq6Ffe+X/2w2m2mIYvuq1+vpShvWDNR+tu187GMf04MPPrjVfscAAAAAYFsgmNiJ2ED4H/7hH1Sr1bTrrrvq/e9/vySlVQy+IaU007fBN7ys1WrpQNzCAF/tYNUVVgFg0yHiZTDteX66hjRTaeFXwbCAwx+bDwR8zwc7ThvA23n4vg9+2U07Rzsf30TTAg+rvrDzN36ZzXiVjWErbti+fWNLHyLYY62Cw0IXP7XFroefemPHat/XarXMCiP+PMbHx/WRj3xEjz766JP/pQIAAACAbYxgYid07733SpJGR0f17W9/W4VCQYcddpgOPvjgNBDwTTAlZaoqpJkeBtZM0feuGNbo0m/DpnfE1Qc+VJCUCTL86hVWhWADb3+swxpH+t4Kxp4XhzBx4854uog/L9/vwfeYiM85Dij8OdjKHn76hx2ffy3i/hb+cXH40Ol0NDY2ll4/3/Ty7rvv1k9/+lP97ne/27xfGgAAAADICcHETmxyclKf+cxnJEmnnnqqFi1apEWLFqlSqUhSZjlRaWbahd0nKTOFwB5jn9rbig++SsGe6xtc2vPibfj+EDZVxAcRNhUjXr3CT6nwvRh8g0u/P3+8vg9D3KDTvuIgxj/OthdXSMTBhLFpMj7k8Y+3bVkw4ftl+HDCmlm2Wi31ej0tWbIkneriG5T+4he/0De/+c2t8esDAAAAANsFwcQCcfnll+uWW27RRz7yEY2NjaUNGm0aga9uiHsz2GDebvcDbT+dw1cS+P4Q1rxRmhlk+wDCTzOx6gUbiFsjT3u+7/tg/SSGrZhh39v0B5t+4s+p3W5nAoo4aLBlO+1xkmY147Rjsv3a7b7hqA9Mms1meg2tcsT6S/iVNeIgwwKiZrOpVqulDRs2qF6vp9fOKin88QEAAADAjqDwxA/BzuKRRx7R+eefr4cfflhTU1NqNBpqtVqzGjvaINn3b7Dv/TKe8ZdVSVizTGlmsB73ZfA/+5Ukut1u2six0Wio2WymTSB9tUO8GoZv7ikprSCw59u2LaiwQMSvYGLb87002u320MaXdn+z2UzDAwsfLKzxYYsFKo1GQw8++KDWr1+vRqOR3u+vh6+W8Nf+m9/8pi655BJ1u11NTU1pcnJSk5OTarVaajabuvjii3XVVVdtk98dAAAAANhWqJhYQLrdrlavXq0rrrhCxx9/fLpyR7vdHrqMpe/BYFMN4soICxbK5XLmuVZdYYFB3OshXurSL1Xql+20aRXx9v2+bT++T4WFCr6KIl61wk9X8Xx4Ep+rn2bR7/fVbDbTpUltGkzMjtlWz5iYmFC1Wk1DHAt1Yv4Y+/2+xsfHddddd+nqq6/WyMiIjj/+eHW7Xa1atUrdbld33XWXNm7cuBm/EQAAAACQP4KJBejqq69WpVLR2NiYVq5cqVarlVZC+ABA0pzBhF85wg/s/VQEP0ViWCNKe7yFERYetFqtTFVCvKSn70nhpz/Y421KQ7vdziwPaity+JVE/HH7pUt9OBFXf9gUmHiZTkmZaomYPc8qQOLj9/0x/Lla0NPv97VmzRpde+21kqRddtlFk5OTuvTSSzfzNwAAAAAA5g+CiQXqiiuu0B133KEPfehDqlQqQ1fPsKDAVwjY91YRYdUQzWYzfa5ty1cdWMBhA3FbFtP6JjQaDZXLZTWbTU1MTKQhiU0rKZfL6nQ6mX0OWx3Epm5YwFGr1TIVGT50sXOwY4qna/jmmsZXeNjynHZ+PtSx0MM3roynkdjj40agdi52vexa+eoNSbrkkku21a8HAAAAAGw3BBML2O9//3udffbZuuiiizKrW0jZZTPjiohms5n2k7Dmi+12W8ViUeVyWYsXL9bIyEj6XN880gcD1gPCVpqwkKLb7aparaZVF9YDwvdq8L0lfFhg+/RVExYwVKvV9Dl2jsNW8IhX3bDzNn4Kir8utl+/CohfWaRWq2nZsmUql8tpKOGnoPjKDB/q+GkoAAAAALCzIZhYwHq9ntasWaMvfvGLetnLXpb2nCgWi+ng3Pc5kGb6OlgFgn3vl65st9tpsOB7PNh2bGqCTWmwx7RarXQFj3K5nDaS9A0q/T5NvBSp/9nfViqV0vMaxldhxAHIXE087fokSZKZ1uGDhXK5nK58Uq1WZy1BalNV/FQRfyy9Xk9f+9rXdM899zy5FxwAAAAA5iGCCeiaa67Rbrvtpmq1qoMOOiitLDB+OoMN7C0YsKoA3/jRQgd7jE3H8INxX9UgKQ00CoVCOrVEUrrSRhxM+AAhbmbpxaGFn2Jh/8ZTTrw4kPDbtO35c7Jmnb5CxI7fprhISqe+GH8+fuqMBRM//OEPNTk5+YSvJQAAAADsaAgmIEn62te+prvuukvvf//7VS6XJc30OIiX5/Q9Gqw5paRZ1QOS0uoAvySnLQnqqyX8ihk2PcSeEy/RGVcWSIOmkxYM+H4M/n5J6SoY1nzSb6vf788KEHzvCX+Ovh+HHa8dm1WPWChh19O254OfuHrDAhv7arfb6bUEAAAAgJ1ReLx56yEEJrUvIMViUYsXL9YXv/hF1Wq1TIVD3CDSVp+wIMGmK1SrVS1dujR9jqTMah9WmeB7S/T7fU1MTKjf76tSqWS2ZUGBVTr40MEG/L4KYWpqKg0dbOWQWq2mWq2mfr+varWaVnRMTEyk27BzK5VKqtfrmf35ygbfH8OmnsQVG/7axL0r4t4Uw6okbNvdbld33HGHzj//fKoldkBJkgyfM/Qk8J4MAFtma78n834MAFtmrvfj2bXvWLB6vZ7Wr1+vv//7v9edd96ZNqKUlBlg+6oFP53BT4uw/hK+gmHY6hZ+2oevkLBtFwqFdCqEbdPv36aJWNNJf4zxPv2KFxau+NVILFiI9+H562HhhR2jVUf46hILYny/Dl89Yvvz0zbsulx99dX64he/SCgBAAAAYKfGVA5k9Pt9/fjHP9aKFSvU6/V0wAEHSJoZ1NvUDd9E0vdcsMDBV1jYFAl//7AlN32VgQ85/P59sBD3rIibRvopGNJMiGH78lMs/Db9fqWZ6Sv+WPxUDws37PZ4WU+//fhcfDNPH0ysWrVKP/rRj7Rq1aon94ICAAAAwDxHMIGhvva1r+nee+/VWWedpUWLFqXVATb1wAb3w4KCdrud2ZZfhtSaXNqX7zXhB/5Jkqjb7abVCL6KoVAozJoa4gf6Fn5YFYOFDaVSKe1lYcGE74VhVRC+r4UPSaSZZpz+OvieFMOabcYriMTXxgIaO+eJiQldcMEFWrNmzVZ9TQEAAABgPiKYwJxuuOEG3XHHHbrooovSBo+2nGdc2eAH35JmTZHwAYKvkJBmggtblaNUKml0dDTTz2FycjINKSwQsd4M1lOi2+1mKjCKxWK67biJZb/fV6PRUKfTSXtaFAoF1Wq1zHFJylRLSMpUfPhzNXat7Ll+W4VCIT0+Y8fd7/d1zz336K/+6q/U6XS20qsIAAAAAPMbwQTmlCSJNm7cqI9+9KM644wztHz5ckkzA2lJaThg1QxW0WDBgfVd8BUTFlZY74hOp6NWq5VWG1hFhN+2nybhV8Bot9vp6hVxNYZVSfR6PbXb7fSYfJWCHZM/vmHTSCSlvSxCCGmQYEunzjUFxQKTeHqHn7ZhPTb+4z/+Q1deeSWhBAAAAIAFhWACj6vX6+n222/XDTfcoKOOOkpPe9rT0sG0pLTCwU9R8BUK8VKbftDuB/M2GLemlK1WK50GYQGDDxZsoG9TQWw6iF9is9frZaZ8WD8I3yPDT72w8/Uhgu8lYSyU8M02LXCJgw2/LKnfhgUTnU5HvV5PP/rRj/SjH/1It99++9Z78QAAAABgB0AwgU3y7W9/W+vWrdPuu++ukZGRTHNJq36wgXepNPi18o0ubelPSek0C1+l0Gq10nDCtuWX3bRtWYhgQYQFEBaWdLtdtVotTU1NSZIqlUq6DKn1h7BwIv7Xb9fEq2z4Bp72c7fbzSw7as+3Y/KVGfYc3/hz/fr1+vSnP60HHnhgG716AAAAADB/EUxgk1133XX6xS9+oY985CPqdDqqVqvpJ/+lUkmVSiUdsFerVUlKqyF8o0zfH8JXFljwYI02rUGlTZ3w1QvNZjOdWmHBhIUUzWYz7R8RQlC9Xle9Xle1WlW5XFa1Wk3DCGuSaduNV9awY7Xj8dNCQgiqVCrp423Khh1Xp9NRo9FQq9XKLCnqe1Q89NBDev3rXz/nSh4AAAAAsLMjmMBmGR8f14c//GElSaLjjz9exx13nFqtlqrVaqYhpA3yrdqg1WqlVRa22ka329U111yjr371q+p0Ojr77LNVq9XU6XTSZpTSzBQQW0Wj2+2q2WymK4BYCOCX3LSqCwswrElmvV7PVGNIylQ0SJo1tcNPHbGgwYIYH0r4aSl+1ZFms5lZ1UMaBB4//OEP9Y1vfINQAgAAAMCCRjCBzdLr9XTPPfdIkkZHR9VsNlUqlVQqlXTkkUfqgAMOSHsq+GaWFkpIM0HAf/7nf+o///M/9etf/1rSoCLj2GOP1aGHHpr2n7BpH8ZCgGazqUKhkOkx4fs4xFMrfNWChSOVSiXtXWHH1+/301DE96Kw/TYajfRY/BQPCyZsdRGbVmL81JPrrrtO/X5fv/jFL/S73/1uG71SAAAAALBjIJjAFrvjjjt0xx13pD93Oh0tWrQoncaxePHidPnN8fFxVSoVSTOrenz5y1/ODMyvvPJKdbtdLV26VPV6XcuWLUt7U9ig36ZJtFotrV27Np1WETfV9EuJWoXE3nvvnT7e+l1YaOIfa/0obBt2zFYBUavVJM2EHj508dNLLNQoFAoaHx/XxMSE1q9fr89+9rOZRpgAAAAAsJCFxxsghRAYPWGLnXfeeXrhC1+odrutV7/61Zu9DObFF1+sPfbYI61gsBCh3++r0WjozDPP3ORtrlixQhdeeGHa58FWE6lWq2mlhE0hqVQqmZ4YfnpGoVDQ4sWL08f4agqb9uF7YVhPine/+9269dZbN+8CYoeWJEl44kdtHt6TAWDLbO33ZN6PAWDLzPV+TDCBbWbXXXfVyMiIkiTZohUn9txzz8yKGV6/39fq1as3eVulUkl77LFHui3/7xlnnKFnPvOZ6vV6GhkZUalUUpIkaRBhYUgIQaOjo6rX62kVh/W5sMaXFnqEEHTbbbfpYx/7mJIk0aOPPqpWq7XZ1wA7LoIJAJg/CCYAYH4gmADmcOyxx2qfffZJlxUtFApasWKFnvGMZ6SPqVQqqlarWrRoUWYJ0UKhoE6no36/r0ceeUTf+c530vvuv/9+XXvttbmcE/JHMAEA8wfBBADMD3O9H9NjAgvezTffrJtvvjlz2zOe8QyNjY2lUzNqtZpGR0c1Ojqarr4hzSwhGkLQ3XffrUsuuSSPUwAAAACAHRYVEwCwDVAxAQDzBxUTADA/zPV+XNjeBwIAAAAAAGAIJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG4IJgAAAAAAQG5CkiR5HwMAAAAAAFigqJgAAAAAAAC5IZgAAAAAAAC5IZgAAAAAAAC5IZgAAAAAAAC5IZgAAAAAAAC5IZgAAAAAAAC5+f8BUz5mUU93tlEAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dice Score : 0.8415458937198068\n",
      "Jaccard Index : 0.7264386989157632\n",
      "SSIM : 0.9996470460206464\n",
      "Specificity : 0.9973337053744439\n",
      "Sensitivty : 0.8481012658227848\n",
      "raTS-GLI-01489-000\\t1n\\Slice_dim2_120.png\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bouhe\\AppData\\Local\\Temp\\ipykernel_22348\\2740733576.py:29: UserWarning: Inputs have mismatched dtypes. Setting data_range based on im1.dtype.\n",
      "  sim1 = compare_ssim(medsam_seg,mask_array)\n"
     ]
    }
   ],
   "source": [
    "# Create a figure with subplots\n",
    "fig, axes = plt.subplots(1, 3, figsize=(15, 5))\n",
    "\n",
    "# Display the original image\n",
    "axes[0].imshow(np.array(image),cmap='gray')\n",
    "axes[0].set_title(\"Original Image\")\n",
    "axes[0].axis(\"off\")\n",
    "\n",
    "# Display the predicted mask\n",
    "axes[1].imshow(np.array(image))\n",
    "axes[1].imshow(medsam_seg, cmap=\"gray\")\n",
    "axes[1].set_title(\"Predicted Mask\")\n",
    "axes[1].axis(\"off\")\n",
    "\n",
    "# Display the ground truth mask\n",
    "axes[2].imshow(np.array(image))\n",
    "axes[2].imshow(mask_array, cmap=\"gray\")\n",
    "axes[2].set_title(\"Ground Truth Mask\")\n",
    "axes[2].axis(\"off\")\n",
    "\n",
    "# Adjust spacing between subplots\n",
    "plt.tight_layout()\n",
    "\n",
    "# Show the plots\n",
    "plt.show()\n",
    "\n",
    "score_dice1 = dice(medsam_seg,mask_array)\n",
    "jaccard1 = Jaccard(medsam_seg,mask_array)\n",
    "sim1 = compare_ssim(medsam_seg,mask_array)\n",
    "true_positives1, false_negatives1, true_negatives1, false_positives1 = confusion_matrix(medsam_seg,mask_array)\n",
    "sensi1 = sens(true_positives1, false_negatives1)\n",
    "speci1 = spec(true_negatives1, false_positives1)\n",
    "    \n",
    "print('Dice Score :' , score_dice1)\n",
    "print('Jaccard Index :' , jaccard1)\n",
    "print('SSIM :' , sim1)\n",
    "print('Specificity :' , speci1)\n",
    "print('Sensitivty :' , sensi1)\n",
    "\n",
    "#File path\n",
    "print(t1n_filtered[idx][0][-41:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Processing images: 100%|██████████| 24523/24523 [2:19:40<00:00,  2.93image/s]  \n"
     ]
    }
   ],
   "source": [
    "# All predictions :\n",
    "predicted_masks = []\n",
    "\n",
    "for element in tqdm(dataset_test, desc=\"Processing images\", unit=\"image\"):\n",
    "    \n",
    "    mask_array = np.array(element['label'])\n",
    "    image = element['image']\n",
    "    \n",
    "    # get box prompt based on ground truth segmentation map\n",
    "    prompt = get_bounding_box(mask_array,1)\n",
    "\n",
    "    # prepare image + box prompt for the model\n",
    "    inputs = processor(image, input_boxes=[[prompt]], return_tensors=\"pt\").to('cuda')\n",
    "    model.eval()\n",
    "\n",
    "    # forward pass\n",
    "    with torch.no_grad():\n",
    "        outputs = model(**inputs, multimask_output=False)\n",
    "    \n",
    "    # apply sigmoid\n",
    "    medsam_seg_prob = torch.sigmoid(outputs.pred_masks.squeeze(1))\n",
    "\n",
    "    # convert soft mask to hard mask\n",
    "    medsam_seg_prob = medsam_seg_prob.cpu().numpy().squeeze()\n",
    "    medsam_seg = (medsam_seg_prob > 0.5).astype(np.uint8)\n",
    "    predicted_masks.append(medsam_seg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "chime.success()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1n_pred_path = [t1n_filtered[i][0].replace('train','predicted_normal') for i in range(len(t1n_filtered))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loop through the list and save each array as an image\n",
    "for image_array,path in tqdm(zip(predicted_masks, t1n_pred_path), desc=\"Saving images\"):\n",
    "    # Convert the array to a numpy array with uint8 data type\n",
    "    image_array = np.array(image_array, dtype=np.uint8)\n",
    "    \n",
    "    # Create an image from the array\n",
    "    image = PIL.Image.fromarray(image_array, mode=\"L\")  # \"L\" mode for grayscale\n",
    "    \n",
    "    # Save the image with the corresponding name\n",
    "    print(path,image_array)\n",
    "    image.save(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Performance Evaluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dice score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mean DICE Score\n",
    "def dice(medsam_seg,mask_array):\n",
    "    # Convert images to numpy arrays\n",
    "    predicted_mask_np = medsam_seg\n",
    "\n",
    "    # Compute the intersection and sums of pixels\n",
    "    intersection = np.sum(np.logical_and(predicted_mask_np, mask_array))\n",
    "    sum_predicted = np.sum(predicted_mask_np)\n",
    "    sum_ground_truth = np.sum(mask_array)\n",
    "\n",
    "    # Compute the Dice score\n",
    "    dice_score = 2 * intersection / (sum_predicted + sum_ground_truth)\n",
    "    \n",
    "    return(dice_score)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Jaccard index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Jaccard(predicted_mask_np,mask_array):\n",
    "    # Compute the intersection and union of pixels\n",
    "    intersection = np.sum(np.logical_and(predicted_mask_np,mask_array))\n",
    "    union = np.sum(np.logical_or(predicted_mask_np,mask_array))\n",
    "\n",
    "    # Compute the Jaccard Index\n",
    "    jaccard_index = intersection / union\n",
    "    return(jaccard_index)\n",
    "#print(\"Jaccard Index:\", jaccard_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### SSIM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skimage.metrics import structural_similarity as compare_ssim\n",
    "def ssim(predicted_mask_np ,mask_array):\n",
    "    \n",
    "\n",
    "    # Compute the SSIM\n",
    "    ssim_score = compare_ssim(predicted_mask_np ,mask_array)\n",
    "    return(ssim)\n",
    "\n",
    "#print(\"SSIM Score:\", ssim_score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Confusion matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def confusion_matrix(predicted_mask_np, mask_array):\n",
    "    # Calculate True Positives and False Negatives\n",
    "    true_positives = np.sum(np.logical_and(predicted_mask_np, mask_array))\n",
    "    false_negatives = np.sum(np.logical_and(np.logical_not(predicted_mask_np), mask_array))\n",
    "    # Calculate True Negatives and False Positives\n",
    "    true_negatives = np.sum(np.logical_and(np.logical_not(predicted_mask_np), np.logical_not(mask_array)))\n",
    "    false_positives = np.sum(np.logical_and(predicted_mask_np, np.logical_not(mask_array)))\n",
    "    return(true_positives, false_negatives, true_negatives, false_positives)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sensitivty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sens(true_positives, false_negatives):\n",
    "    # Calculate Sensitivity (True Positive Rate)\n",
    "    sensitivity = true_positives / (true_positives + false_negatives)\n",
    "    return(sensitivity)\n",
    "\n",
    "#print(\"Sensitivity (TPR):\", sensitivity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Specificity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spec(true_negatives, false_positives):\n",
    "    # Calculate Specificity (True Negative Rate)\n",
    "    specificity = true_negatives / (true_negatives + false_positives)\n",
    "    return(specificity)\n",
    "\n",
    "#print(\"Specificity (TNR):\", specificity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "score_dice,jaccard,sim,speci,sensi = [],[],[],[],[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for pred,gt in zip(predicted_masks_non_f_1,t1n_filtered):\n",
    "    \n",
    "    # Open an image\n",
    "    image = PIL.Image.open(gt[1]) \n",
    "\n",
    "    # Convert the image to a NumPy array\n",
    "    mask_array = np.array(image)\n",
    "    \n",
    "    score_dice.append(dice(pred,mask_array))\n",
    "    jaccard.append(Jaccard(pred,mask_array))\n",
    "    sim.append(compare_ssim(pred ,mask_array))\n",
    "    true_positives, false_negatives, true_negatives, false_positives = confusion_matrix(pred,mask_array)\n",
    "    speci.append(spec(true_negatives, false_positives))\n",
    "    sensi.append(sens(true_positives, false_negatives))\n",
    "    \n",
    "print('Dice Score :' ,np.mean(score_dice))\n",
    "print('Jaccard Index :' ,np.mean(jaccard))\n",
    "print('SSIM :' ,np.mean(sim))\n",
    "print('Specificity :' ,np.mean(speci))\n",
    "print('Sensitivty :' ,np.mean(sensi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bouhe\\AppData\\Local\\Temp\\ipykernel_7872\\3652228023.py:11: UserWarning: Inputs have mismatched dtypes. Setting data_range based on im1.dtype.\n",
      "  sim.append(compare_ssim(pred ,mask_array))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dice Score : 0.7410537189881816\n",
      "Jaccard Index : 0.6179527896067623\n",
      "SSIM : 0.9991963914486591\n",
      "Specificity : 0.9932784414947607\n",
      "Sensitivty : 0.841689810083357\n"
     ]
    }
   ],
   "source": [
    "for pred,gt in zip(predicted_masks_non_f_2,t1n_filtered):\n",
    "    \n",
    "    # Open an image\n",
    "    image = PIL.Image.open(gt[1]) \n",
    "\n",
    "    # Convert the image to a NumPy array\n",
    "    mask_array = np.array(image)\n",
    "    \n",
    "    score_dice.append(dice(pred,mask_array))\n",
    "    jaccard.append(Jaccard(pred,mask_array))\n",
    "    sim.append(compare_ssim(pred ,mask_array))\n",
    "    true_positives, false_negatives, true_negatives, false_positives = confusion_matrix(pred,mask_array)\n",
    "    speci.append(spec(true_negatives, false_positives))\n",
    "    sensi.append(sens(true_positives, false_negatives))\n",
    "    \n",
    "print('Dice Score :' ,np.mean(score_dice))\n",
    "print('Jaccard Index :' ,np.mean(jaccard))\n",
    "print('SSIM :' ,np.mean(sim))\n",
    "print('Specificity :' ,np.mean(speci))\n",
    "print('Sensitivty :' ,np.mean(sensi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bouhe\\AppData\\Local\\Temp\\ipykernel_22348\\1586440660.py:11: UserWarning: Inputs have mismatched dtypes. Setting data_range based on im1.dtype.\n",
      "  sim.append(compare_ssim(pred ,mask_array))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dice Score : 0.5599570807043689\n",
      "Jaccard Index : 0.42990439357838267\n",
      "SSIM : 0.9987996599015008\n",
      "Specificity : 0.9953492231057433\n",
      "Sensitivty : 0.5376540332077726\n"
     ]
    }
   ],
   "source": [
    "for pred,gt in zip(predicted_masks,t1n_filtered):\n",
    "    \n",
    "    # Open an image\n",
    "    image = PIL.Image.open(gt[1]) \n",
    "\n",
    "    # Convert the image to a NumPy array\n",
    "    mask_array = np.array(image)\n",
    "    \n",
    "    score_dice.append(dice(pred,mask_array))\n",
    "    jaccard.append(Jaccard(pred,mask_array))\n",
    "    sim.append(compare_ssim(pred ,mask_array))\n",
    "    true_positives, false_negatives, true_negatives, false_positives = confusion_matrix(pred,mask_array)\n",
    "    speci.append(spec(true_negatives, false_positives))\n",
    "    sensi.append(sens(true_positives, false_negatives))\n",
    "    \n",
    "print('Dice Score :' ,np.mean(score_dice))\n",
    "print('Jaccard Index :' ,np.mean(jaccard))\n",
    "print('SSIM :' ,np.mean(sim))\n",
    "print('Specificity :' ,np.mean(speci))\n",
    "print('Sensitivty :' ,np.mean(sensi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#0\n",
    "- Dice Score : 0.5599570807043689\n",
    "- Jaccard Index : 0.42990439357838267\n",
    "- SSIM : 0.9987996599015008\n",
    "- Specificity : 0.9953492231057433\n",
    "- Sensitivty : 0.5376540332077726"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#1\n",
    "- Dice Score : 0.710560475938147\n",
    "- Jaccard Index : 0.5813044060910975\n",
    "- SSIM : 0.9990325528534505\n",
    "- Sensitivty : 0.9922630519084908\n",
    "- Specificity : 0.7947214326090183"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "chime.succes()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summarized results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dice Score : 0.710560475938147\n",
      "Jaccard Index : 0.5813044060910975\n",
      "SSIM : 0.9990325528534505\n",
      "Sensitivty : 0.9922630519084908\n",
      "Specificity : 0.7947214326090183\n"
     ]
    }
   ],
   "source": [
    "print('Dice Score :' ,np.mean(score_dice))\n",
    "print('Jaccard Index :' ,np.mean(jaccard))\n",
    "print('SSIM :' ,np.mean(sim))\n",
    "print('Sensitivty :' ,np.mean(sensi))\n",
    "print('Specificity :' ,np.mean(speci))"
   ]
  }
 ],
 "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}