Datasets
Models
Downloads: 1
Diff of
/Experimentations/Exp15-Human expert comparison with model.ipynb
[000000]
..
[94d9b6]
Switch to side-by-side view
--- a +++ b/Experimentations/Exp15-Human expert comparison with model.ipynb @@ -0,0 +1,753 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 15. Experimentation: Analysis of Human-Expert Level Performance with the Model's performance" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torch.autograd import Variable\n", + "import torch.optim as optim\n", + "import torchvision\n", + "from torchvision import datasets, models\n", + "from torchvision import transforms as T\n", + "from torch.utils.data import DataLoader, Dataset\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "import time\n", + "import pandas as pd\n", + "from skimage import io, transform\n", + "import matplotlib.image as mpimg\n", + "from PIL import Image\n", + "from sklearn.metrics import roc_auc_score\n", + "import torch.nn.functional as F\n", + "import scipy\n", + "import random\n", + "import pickle\n", + "import scipy.io as sio\n", + "import itertools\n", + "from scipy.ndimage.interpolation import shift\n", + "import copy\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "%matplotlib inline\n", + "plt.ion()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import Dataloader Class and other utilities" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from dataloader_2d import *\n", + "from dataloader_3d import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Build Data loader objects" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "train_path = '/beegfs/ark576/new_knee_data/train'\n", + "val_path = '/beegfs/ark576/new_knee_data/val'\n", + "test_path = '/beegfs/ark576/new_knee_data/test'\n", + "\n", + "train_file_names = sorted(pickle.load(open(train_path + '/train_file_names.p','rb')))\n", + "val_file_names = sorted(pickle.load(open(val_path + '/val_file_names.p','rb')))\n", + "test_file_names = sorted(pickle.load(open(test_path + '/test_file_names.p','rb')))\n", + "\n", + "transformed_dataset = {'train': KneeMRIDataset(train_path,train_file_names, train_data= True, flipping=False, normalize= True),\n", + " 'validate': KneeMRIDataset(val_path,val_file_names, normalize= True),\n", + " 'test': KneeMRIDataset(test_path,test_file_names, normalize= True)\n", + " }\n", + "\n", + "dataloader = {x: DataLoader(transformed_dataset[x], batch_size=5,\n", + " shuffle=True, num_workers=0) for x in ['train', 'validate','test']}\n", + "data_sizes ={x: len(transformed_dataset[x]) for x in ['train', 'validate','test']}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "im, seg_F, seg_P, seg_T,_ = next(iter(dataloader['train']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Find Max and min values of Images (all 7 contrasts), of Fractional Anisotropy maps and of Mean Diffusivity maps for image normalization" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "min_fa = np.inf\n", + "min_md = np.inf\n", + "min_image = np.inf\n", + "max_fa = 0\n", + "max_md = 0\n", + "max_image = 0\n", + "for data in dataloader['train']:\n", + " if min_fa > torch.min(data[0][:,7,:,:]):\n", + " min_fa = torch.min(data[0][:,7,:,:])\n", + " if min_md > torch.min(data[0][:,8,:,:]):\n", + " min_md = torch.min(data[0][:,8:,:])\n", + " if min_image > torch.min(data[0][:,:7,:,:]):\n", + " min_image = torch.min(data[0][:,:7,:,:])\n", + " if max_fa < torch.max(data[0][:,7,:,:]):\n", + " max_fa = torch.max(data[0][:,7,:,:])\n", + " if max_md < torch.max(data[0][:,8,:,:]):\n", + " max_md = torch.max(data[0][:,8,:,:])\n", + " if max_image < torch.max(data[0][:,:7,:,:]):\n", + " max_image = torch.max(data[0][:,:7,:,:])\n", + "norm_values = (max_image, min_image, max_fa, min_fa, max_md, min_md)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Import Models" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from unet_3d import *\n", + "from unet_basic_dilated import *\n", + "from vnet import *\n", + "from ensemble_model import *" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "seg_sum = torch.zeros(3)\n", + "for i, data in enumerate(dataloader['train']):\n", + " input, segF, segP, segT,_ = data\n", + " seg_sum[0] += torch.sum(segF)\n", + " seg_sum[1] += torch.sum(segP)\n", + " seg_sum[2] += torch.sum(segT)\n", + "mean_s_sum = seg_sum/i" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Loss functions and all other utility functions like functions for saving models, for visualizing images, etc." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from utils import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import all the Training and evaluate functions to evaluate the models" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "from train_2d import *\n", + "from train_3d import *\n", + "from train_ensemble import *\n", + "from evaluate_2d import *\n", + "from evaluate_3d import *\n", + "from evaluate_ensemble import *" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 15. Experimentation: Analysis of Human-Expert Level Performance with the Model's performance" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "keys2 = ['MDnr','FAnr','NUFnr','SegmentationF', 'SegmentationT', 'SegmentationP','S0nr']\n", + "keys0 = ['DXnr','DYnr','phasenr','errorner']\n", + "keys1 = ['EigenValuenr','EigenVectornr']\n", + "new_path = '/beegfs/ark576/new_knee_data/train/'\n", + "for i in new_test_file:\n", + " image_data = sio.loadmat('/beegfs/ark576/new-data-apr-24/test data' +'/'+ i)\n", + " for j in range(15):\n", + " new_image_data ={}\n", + " for k,v in image_data.items():\n", + " if k in keys2:\n", + " if len(v.shape) == 4:\n", + " new_image_data[k] = v[:,:,j,:]\n", + " if len(v.shape) == 3:\n", + " new_image_data[k] = v[:,:,j]\n", + " if k in keys1:\n", + " new_image_data[k] = v[:,j]\n", + " if k in keys0:\n", + " new_image_data[k] = v[j,:]\n", + " pickle.dump(new_image_data,open('/beegfs/ark576/new-data-apr-24/test data/mod_test/'+i+str(j)+'.p','wb'))\n", + "# pickle.dump(new_test_file_names,open(test_path+'/test_file_names.p','wb'))" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "new_file = sorted(os.listdir('/beegfs/ark576/new-data-apr-24/test data/mod_test/'))" + ] + }, + { + "cell_type": "code", + "execution_count": 195, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "existing_test_path = '/beegfs/ark576/new_knee_data/test/'" + ] + }, + { + "cell_type": "code", + "execution_count": 186, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "existing_test_file_names = sorted(os.listdir(existing_test_path))" + ] + }, + { + "cell_type": "code", + "execution_count": 189, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "new_test_file_names = sorted(existing_test_file_names + new_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 190, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "105" + ] + }, + "execution_count": 190, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(new_test_file_names)" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pickle.dump(new_test_file_names,open(existing_test_path+'test_file_names.p','wb'))" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "example = sio.loadmat('/beegfs/ark576/Knee Cartilage Data/Train Data/FirstEvalautionJR_Pat54_LeftKL1.mat')" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "train_file_names = sorted(os.listdir('/beegfs/ark576/new_knee_data/train/'))" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "final_train_files = train_file_names[:-5]" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pickle.dump(final_train_files,open('/beegfs/ark576/new_knee_data/train/train_file_names.p','wb'))" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(256, 256, 15)" + ] + }, + "execution_count": 61, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "variables = pickle.load(open(variable_path_name,'rb')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "train_full_file_names = os.listdir('/beegfs/ark576/Knee Cartilage Data/Train Data/')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "train_full_file_names.remove('train_file_names')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "pickle.dump(train_full_file_names, open('train_file_names','wb'))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "test_full_file_names = os.listdir('/beegfs/ark576/Knee Cartilage Data/Test Data/')\n", + "test_full_file_names.remove('test_file_names')\n", + "pickle.dump(test_full_file_names, open('test_file_names','wb'))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "7" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(test_full_file_names)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "resegmentation_path = '/beegfs/ark576/new-data-apr-24/resegmentation/'" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "resegmentation_files = os.listdir(resegmentation_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['2017.09.20_MeasRO1_Pat47_Left_KL_SegmentedEvaluationAD.mat',\n", + " '2016.08.11_MeasRO1_Pat13_LeftKL1_SegmentedEvaluationAD.mat',\n", + " '2016.08.15_MeasRO1_Pat12_RightKL1_SegmentedEvaluationAD.mat',\n", + " '2017.09.29_MeasRO1_Pat4_RightKL1_FU_SegmentedEvaluationAD.mat',\n", + " '2017.10.13_MeasRO1_Pat9_RightKL1_FU_SegmentedEvaluationAD.mat',\n", + " '2016.08.08_MeasRO1_Pat11_LeftKL1_SegmentedEvaluationAD.mat',\n", + " '2017.10.14_MeasRO1_Pat51_RightKL1_SegmentedEvaluationAD.mat',\n", + " '2016.09.06_MeasRO1_Pat14_LeftKL1_Meas1_SegmentedEvaluationAD.mat',\n", + " '2016.12.19_RadialRO1_Pat15_LeftKL1_SegmentedEvaluationAD.mat',\n", + " '2017.09.20_MeasRO1_Pat29_LeftKL1_SegmentedEvaluationAD.mat']" + ] + }, + "execution_count": 51, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "resegmentation_files" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "train_file_path = '/beegfs/ark576/Knee Cartilage Data/Train Data/'" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "train_files = os.listdir(train_file_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "dice_score_F = 0\n", + "dice_score_T = 0\n", + "dice_score_P = 0\n", + "reseg_dc_sr = {0:[],1:[],2:[]}\n", + "for i in resegmentation_files:\n", + " resegmented_image = sio.loadmat(resegmentation_path+i)\n", + " original_image = sio.loadmat(train_file_path+i)\n", + " reseg_F = resegmented_image['SegmentationF']\n", + " reseg_T = resegmented_image['SegmentationT']\n", + " reseg_P = resegmented_image['SegmentationP']\n", + " ori_F = original_image['SegmentationF']\n", + " ori_T = original_image['SegmentationT']\n", + " ori_P = original_image['SegmentationP']\n", + " for j in range(15):\n", + " te_re_F = reseg_F[:,:,j]\n", + " te_or_F = ori_F[:,:,j]\n", + " temp_dice_F = (2*(np.sum(te_re_F*te_or_F)) + 1e-4)/(np.sum(te_or_F + te_re_F) + 1e-4)\n", + " dice_score_F += temp_dice_F\n", + " reseg_dc_sr[0].append(temp_dice_F)\n", + " for k in range(15):\n", + " te_re_T = reseg_T[:,:,k]\n", + " te_or_T = ori_T[:,:,k]\n", + " temp_dice_T = (2*(np.sum(te_re_T*te_or_T)) + 1e-4)/(np.sum(te_or_T + te_re_T) + 1e-4)\n", + " dice_score_T += temp_dice_T\n", + " reseg_dc_sr[2].append(temp_dice_T)\n", + " for l in range(15):\n", + " te_re_P = reseg_P[:,:,l]\n", + " te_or_P = ori_P[:,:,l]\n", + " temp_dice_P = (2*(np.sum(te_re_P*te_or_P)) + 1e-4)/(np.sum(te_or_P + te_re_P) + 1e-4)\n", + " dice_score_P += temp_dice_P\n", + " reseg_dc_sr[1].append(temp_dice_P)\n", + "dice_score_F /= 15*5*2\n", + "dice_score_T /= 15*5*2\n", + "dice_score_P /= 15*5*2" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.70956598319055086" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dice_score_F" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.75458329820914749" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dice_score_P" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.60834781778619007" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dice_score_T" + ] + }, + { + "cell_type": "code", + "execution_count": 276, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x2b86b2548908>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9UAAAFjCAYAAAAzRiheAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3Xl8VNX9//H3JwmEBCKETSEBwzYkEyDaIAi4gWjxW1eQutCKVWSxahWXWqW1bi1U/bWllYJasbhbwQ0rFmvFFQURhKxGBWUNmwk7JDm/PzJDIwnJZGCy3Lyej8c8mHvnLp85GfLJZ86555pzTgAAAAAAoPai6jsAAAAAAAAaK4pqAAAAAADCRFENAAAAAECYKKoBAAAAAAhTTH0HAAAAADRGn376aceYmJjHJPURnVVAU1AmaVVJScm4zMzMwuBKimoAAAAgDDExMY8dd9xxaR06dNgeFRXFLXUAjysrK7PNmzf7N27c+Jik84Pr+UYNAAAACE+fDh06FFNQA01DVFSU69ChQ5HKR6f8b309xQMAAAA0dlEU1EDTEvg//706mqIaAAAAaKTMLPOCCy7oFlw+cOCAEhMTM4YOHdqzNsdJSkrqu2HDhmovDa24TVJSUt/wIj5yAwYM6P3uu+/GS9Lpp5/ec8uWLdGH2/bJJ59s8+mnn7YILt94442dX3755YS6iLM699xzT8cdO3YcrMXi4+NPrKtzz58/PyH4+Xj66adb33HHHcdVtV1NMW3ZsiV66tSpHYLLq1evbjZixIjuRzfayJs8eXLn3/zmN8ceyTG4phoAAAA4Gswyj+rxnPu0pk3i4uLK8vLy4nbu3GmtWrVyL7300jHHHnvsgaMaRx04cOCAmjVrVuv9Fi1aVFDd6y+//HKbkpKSoszMzL2S9Kc//Wl9mCEeVbNmzTr2mmuu2ZaQkFBWn3GMGTOmSFJROPtu3bo1+u9//3vH22+/fbMkpaSkHFiwYMFXRzXARoKeagAAAKARGz58eNE///nPNpL07LPPth01atS24GubNm2KHj58eA+fz+fPyMhI/fjjj+MkaePGjdFDhgzp1bNnz/RLLrnkeOf+N4p9xowZbfv27ZuWmprqv/zyy48vKSmpdM7ExMQSSVqzZk2z/v37905NTfX36tUrfcGCBa0O3TYpKanvxIkTk30+n79v375pq1atipWkUaNGpVx++eVd+/Xrlzpp0qTk4uLiqNGjR6f07ds3LS0tzf/UU0+1kaSdO3faueee27179+7pZ511Vo+9e/daxWMHe8//+te/tvP5fP7evXv7L7zwwm4LFy5s+dZbb7WZMmVKcmpqqj8rKyt21KhRKbNnz06UpFdeeSUhLS3N7/P5/KNHj07Zs2ePBY950003dfb7/Wk+n8//2WeftTj0Pe3evdsuvvjiFJ/P509LS/O/9tprCZI0ffr0dmeffXaPU089tdfxxx/fZ+LEicmH7nvfffd1LCwsbHb66af7Bg4c6Auuv/7665N69+7tz8jISP32229jJGn9+vUxP/zhD3v06dMnrU+fPmn//ve/Wx56vIyMjNSlS5cejDHYk//f//43/oQTTkhNS0vzn3jiiakrVqyIPXTf6dOnt7viiiu6SlJubm7zE044IdXn8/lvuOGGzsFtioqKogYNGuQLtkfw53LzzTcnf/vtt7Gpqan+CRMmJOfl5TXv1atX+pG2jyRde+21ST169Ej3+Xz+8ePHJ0vSM88807pfv36paWlp/sGDB/uCbTR58uTOI0eOTMnMzOzduXPnvk888USb8ePHJ/t8Pv+pp57aa9++fQd/rlV9DivKysqKPfXUU3ulp6enZWZm9q7qZ18VimoAAACgEfvpT3+67fnnn0/cvXu35eTkxA8aNGhX8LXbbrutc0ZGxu78/Pzse++9d93YsWO7SdLtt9/eedCgQTsLCgqyLrroou82bNjQXJKWLVvW4sUXX2y7dOnS3Nzc3OyoqCg3c+bMdoeec9WqVTmS9Pjjj7c988wzi3Jzc7NzcnKyBg4cuLuqGFu3bl2Sn5+fPWHChMLrr7++S3D9hg0bmi9btiz3scceW3vHHXd0Gjp0aPHKlStz3nvvvbwpU6YkFxcXRz344IMd4+Liyr766qus++67b312dnalwnLp0qUtHnzwwU6LFi3Kz8vLy541a9Y3Z5111q7hw4d/d999963Nzc3NTk9P3xfcfvfu3TZhwoRuzz///Jf5+fnZJSUleuCBBw4OZW7fvn1JdnZ2zlVXXbV56tSplYYGT5s2raOZKT8/P/uZZ575avz48Sm7d+82ScrOzo5/+eWXv8rJycl69dVXEwsKCr7XBT9lypTCjh07Hli0aFH+xx9/nC9Je/bsiRo0aNDOvLy87EGDBu38y1/+0kGSJkyY0GXy5MmbVq1alfPSSy99OXHixJRDYxk5cuS2p59+uq1U/iVHYWFhs9NOO213RkbG3iVLluTm5ORk33XXXetuu+22KgvYoGuvvbbruHHjNufn52d36tTp4GiH+Pj4stdff70gOzs7Z9GiRfl33HFHcllZmR566KG1Xbp02Zebm5s9a9astUerfTZu3Bj9r3/9K/GLL77Iys/Pz/7d7363QZLOOuusncuXL8/NycnJvvjii7fdc889B4etr1mzJvbDDz/Mnzt3bsHEiRO7Dx8+vDg/Pz+7RYsWZS+88ELr4HaH+xwGjRs37vgZM2Z8k5WVlfPAAw+snTRpUtfq2iyI4d8AAABAIzZw4MA9a9eujX300UfbDh8+/HtDeT/55JOEuXPnFkjS+eefv2P8+PEx27Zti1q8eHHCvHnzCiTp0ksvLZowYUKpJC1YsCBh1apV8RkZGWmStHfv3qiOHTtW7qoOOPnkk3dNmDAh5cCBA1EXX3zx9sGDB++paruxY8duk6Rrrrlm25QpUw4WMyNHjtweE1NekrzzzjvHvPnmm22mT59+nCTt27fPCgoKmr///vutbrjhhsLge/X5fJUK9zfffPOY8847b3unTp1KJOnYY48tra7NVqxY0SI5OXlfv3799knSlVdeufXhhx/uKKlQki6//PLtkjRgwIDdr776auKh+3/44Yetrr/++kJJOvHEE/d27tx5/8qVK1tI0imnnFLcrl27Uknq2bPn3i+//DK2Z8+e1Q7Jb9asmbv00kuLJCkzM3PXW2+9dYwkffDBB8d88cUXccHtdu7cGV1UVBTVunXrg8PGr7jiiu1nnXWW749//OP6OXPmJJ533nnbJWnbtm3Rl1xySbfVq1e3MDN34MABO/S8FS1btqzVG2+88aUkTZgwYeu9996bLJXfRurGG29MXrx4cauoqCgVFhY2X7t2bbV15JG0T7t27UpjY2PLLrnkkpRzzz33u0suuaRIkr7++uvmF154YfLmzZub7d+/P6pLly4HvyQZPnx4UWxsrBswYMCesrIyXXzxxcWSlJ6evufrr79uHtzucJ9DqbxH/rPPPms1evToHsF1+/fvr7bNgiiqAQAAgEZuxIgR3911111d/v3vf+cVFhaG/Te+c85Gjx699eGHH14XyvbnnHPOznfffTdv7ty5ra+66qpu11133abrrrtu66HbRUX9b4CsmR0ca96qVauDxaFzTi+++GJBRkbGPtWzFi1aOEmKiYlxJSUlIRVWQc2bNz/4/qKjo2ssZoPnCbZRTEyMgud0zmnZsmU58fHxh51lvlu3bgfatGlT8vHHH8fNmzev7cyZM9dI0i9/+cuk008/fcfChQu/zMvLaz5s2LDeNcVR1Wz2s2bNart169aYlStX5sTGxrqkpKS+e/bsCXvEc03t06xZMy1fvjzn1VdfPebFF19M/Nvf/tZx8eLF+dddd13XX/ziFxvHjBlTNH/+/IR77rnn4BD12NhYFzje99oyKipKFX9+h/scSlJpaakSEhJKcnNzs2v7nhj+DQAAADRykyZN2nLLLbesHzBgwPd6igcOHLhj9uzZ7aTyWZ8TExNL2rZtW3byySfveOKJJ9pJ0gsvvHBMcXFxtCSNGDGieP78+Ynr1q2Lkcqvyc7Pz29+6PmC8vPzmycnJx+4+eabt1xxxRWbly1bFl/VdnPmzGkrSX//+98TTzzxxF1VbTN06NDihx566NiysvI6+4MPPoiTpFNOOWVncHjzkiVLWuTn51c6xw9/+MPi1157LXHjxo3RwbglqVWrVqXFxcWVap6MjIy969atax68rnbOnDntTj311B2He5+HGjJkyM6nnnqqrSR9/vnnsRs2bGjer1+/vaHu37Jly9KioqIaa7FTTjml+Pe//33H4PKHH34YV9V2o0aN2va73/3uuB07dkQPHDhwjyQVFxdHJycn75ekWbNmta/pXD/4wQ92Pvroo20l6dFHHz045L+oqCi6ffv2B2JjY91rr72WsH79+uaS1Lp169Jdu3ZV+R6OpH2KioqiAr3sRTNnzvw2Nzc3XpJ27NgR3bVr1wOSFPzs1lZ1n8O2bduWJScn73/88ccTJamsrEwfffRRle19KIpqAAAAoJHr0aPHgSlTphQeun7atGnrP/vss3ifz+e/8847k5544omvJWnq1KnrP/jgg1Y9e/ZMnzdvXmKnTp32S1JmZubeKVOmrDvzzDN9Pp/PP2zYMN+333572Gm533zzzYS0tLT0tLQ0/9y5c9vedtttm6rabvv27dE+n88/Y8aMY6dPn/5tVdtMnTp1fUlJiaWmpvp79uyZPmXKlCRJuuWWWwp37doV3b179/Q777wzye/3VyrK+/fvv/fmm2/ecOqpp6b27t3bf+2113aRpDFjxmybPn36cWlpaf6srKyDE1PFx8e7mTNnrh49enQPn8/nj4qK0i233LK5+lb+n9tuu62wrKzMfD6f/5JLLukxa9as1XFxcSHfs3zs2LFbRowY8b2JyqryyCOPfLts2bKWPp/P36NHj/S//vWvHara7ic/+cn2119/ve0FF1xwcJK6X/7ylxt/+9vfJqelpfmrmmzuUDNmzPjmkUce6ejz+fzr1q07+DMfN27cthUrVrT0+Xz+f/zjH+26deu2V5KOO+640szMzJ29evVKnzBhwveu1z6S9vnuu++iR4wY0cvn8/kHDRrU+9577/1Wku688871l112WY/09PS0du3a1fyGqlDT5/DZZ5/9avbs2e179+7t79WrV/rcuXPbhHJcqzjTHwAAAIDQrFixYnVGRsaW+o6joUtKSuq7dOnSnOD1zkB9OJqfwxUrVrTPyMhICS7TUw0AAAAAQJiYqAwAAABAxKxbt25lfccARPJzSE81AAAAAABhoqgGAAAAACBMFNUAAAAAAISJohoAAAAAgDBRVAMAAACNVHR0dGZqaqrf5/P5zzrrrB7bt29v1H/f5+XlNZ85c2bb2m737rvvxl955ZVdjkYM8fHxJ4a776hRo1Jmz56deLSOdzRNnjy5c8eOHfulpqb6g48tW7ZER/Kct99++3GRPH5DwezfAAAAwFGQcvvrmUfzeKun/ujTmraJjY0ty83NzZakkSNHpvzxj3/scM8992w6mnHUpS+++CL2+eefbztx4sRttdnutNNO233aaaftrpsoG6+JEyduqovPR1lZmZxzmj59eqepU6dujPT56luj/iYLAAAAQLmTTz5515dffhkbXP71r399bJ8+fdJ8Pp//pptu6ixJxcXFUWeccUbP3r17+3v16pX+6KOPJkrSe++9F3/SSSf1Tk9PTzvllFN6rVmzppkkLVq0KN7n8/lTU1P9EyZMSO7Vq1e6JE2fPr3d8OHDewwePLhXUlJS3/vvv7/jb37zm2PT0tL8GRkZqZs2bYqWpKysrNhTTz21V3p6elpmZmbvzz77rIVU3qN75ZVXdjnxxBNTk5OT+wZ7d++8886kpUuXtkpNTfXffffdHfPy8ppnZmb29vv9aX6/P23hwoUtq9pu/vz5CUOHDu0pSZs2bYoePnx4D5/P58/IyEj9+OOP46TyntrRo0enDBgwoHdycnLf++67r+Ph2vLqq6/u0rNnz/RBgwb51q9fH5OVlRXr9/vTgq+vXLnye8uhqBijJF1xxRVdp0+f3k6SkpKS+v785z9PSk1N9aenp6e999578UOGDOnVpUuXPn/4wx86SFJRUVHUoEGDfH6/P83n8/mfeuqpNlJ5r3337t3TL7300uN79uyZPmTIkF47d+60UOO6++67O44ePTpFkj755JO4Xr16pe/YsSNq8uTJnS+88MJuJ5xwQurxxx/f56GHHmof3Keqz1ZeXl7zlJSUPhdddFGKz+dLv+SSS1L27dsXlZqa6j///PO71aatGhuKagAAAKCRKykp0X/+859j0tPT90jSvHnzjikoKGjx+eef5+Tk5GQvX748/o033mg1b968Y4477rgDeXl52V988UXWyJEji/ft22c33HBD11deeeXLrKysnLFjx2655ZZbkiRp3Lhx3WbMmLEmNzc3Ozo62lU8Z35+ftzrr7/+5ZIlS3J+//vfJ7Vq1aosJycnu3///rtmzZrVLrD/8TNmzPgmKysr54EHHlg7adKkrsH9N23a1Gzp0qW5r7zyyhd33XVXkiTdf//96/r3778zNzc3+6677irs3LlzyXvvvZefnZ2d8/zzz3910003da1qu4px3XbbbZ0zMjJ25+fnZ997773rxo4de7CgKygoaLFo0aL8JUuW5Dz44IOd9+3bV6n43LNnT1T//v13FRQUZA0ZMmTH7bff3jk9PX1fQkJC6YcffhgnSbNmzWo/ZsyYrVX9LKZMmZJccYh1qD/Drl277s/Nzc0++eSTd1599dUp8+fP//Ljjz/OnTZtWmdJio+PL3v99dcLsrOzcxYtWpR/xx13JJeVlUmSvvnmmxY33HBDYUFBQVbr1q1L58yZk1jVOWbOnHlsMK6BAwf6AvEWfv3117Fz5sxpc9VVV6U8/PDDqxMSEsokKScnJ+7999/PW7x4ce4DDzzQefXq1c0O99kKxBF73XXXbS4oKMh68cUXVwdHUrz66qtfh9oOjRHDvwEAAIBGKtgTuGnTpmZJSUn7b7311s2StGDBgmPefffdY/x+v1+Sdu/eHZWbm9vizDPP3HHnnXd2mTRpUtIFF1xQNGLEiJ1Llixp8cUXX8QNGzbMJ5UP3e3QocOBLVu2RO/atStq+PDhuyRp7Nix2xYuXNgmeO7BgwfvSExMLEtMTCxLSEgoGT169HeS1Ldv392ff/55fFFRUdRnn33WavTo0T2C++zfv/9gEXv++ed/Fx0drczMzL1bt25tVtX7279/v1199dXHZ2dnx0VFRWnNmjWxVW1X0SeffJIwd+7cgsA5dowfPz5m27ZtUZJ09tlnfxcXF+fi4uJK2rZte2Dt2rUxPXr0OFBx/6ioKI0bN26bJF111VVbR44c2VOSrrzyyi2PPvpo+wEDBnz7yiuvJC5ZsiSnqvPfd999a3/2s59tDy6Hek31j3/844Ptt2vXrqhg2zZv3rxsy5Yt0QkJCWU33nhj8uLFi1tFRUWpsLCw+dq1a2MkKSkpad/gwYP3SNKJJ564e/Xq1VW2U1XDv6OjozVnzpyv+/fvnz5mzJjNZ5999q7ga+ecc853rVq1cq1atSoZNGhQ8Xvvvdfyvffea1XVZ6t79+77O3XqtP/MM8/cdeh5vY6iGgAAAGikgj2BO3bsiDrjjDN6PfPMM23Gjh37nXNON95444Zbb711y6H7LFu2LHvu3Lmtf/3rXye99dZbxT/+8Y+/69mz557ly5fnVtyupkmsmjdvfrDnOioqSi1atHDB5yUlJVZaWqqEhISS4DXfhwpuL0nOuao20f33339sx44dD8ydO/frsrIyxcXFHdF167GxsQdPFB0drZKSkhqHSZuVbzJ27Njt06ZN6/zcc8/t6Nu37+7jjjuutDbnbtasmQv2LEvSob3kFdvv0LY9cOCAzZo1q+3WrVtjVq5cmRMbG+uSkpL67tmzJ0r6/s8iOjraBdeHKicnp0V8fHzZxo0bv/flRvC9V1w+3GcrLy+veXx8fJmaIIZ/AwAAAI1cQkJC2fTp07+5++67k0pLS3XOOecUP/nkk+2LioqiJOnrr79utm7dupjVq1c3S0hIKLv22mu3TZ48eePy5cvj+/Xrt3fbtm0xb731VkupvNhbunRpi/bt25e2bNmy7O23324pSU8++WSNs3JX1LZt27Lk5OT9jz/+eKJU3gP+0UcfxVW3T+vWrUt37tx5sJgvKiqK7tSp04Ho6GjNmDGjXWlpaZXbVTRw4MAds2fPbieVX8ecmJhY0rZt25CLvbKyMgWv8X7iiSfaDRgwYIckxcfHu9NPP71o8uTJXa+88spKX1bUpEePHvsKCgri9uzZY1u2bIl+//33j6nN/kVFRdHt27c/EBsb61577bWE9evXN69tDFXZunVr9M0339z17bffzt22bVtMxdnL33jjjTa7d++2jRs3Ri9evDjhlFNO2XW4z1ZVx46JiXFVDbH3GnqqAQAAAA8YMmTInpSUlH2PPfZY2wkTJmzLyspqcdJJJ6VK5dfjPv3001/n5ubG/upXv0qOiopSTEyMmzFjxpoWLVq455577ssbbrih644dO6JLS0tt0qRJm/r377931qxZqydOnHh8VFSUBg0atCMhIaFWvbPPPvvsV9dcc83x06ZN61RSUmIXXXTRtkGDBu053PYDBgzYEx0d7Xr37u2//PLLt9x4442Fo0aN6vHcc8+1GzZsWFFcXFxZVdtlZmYePOa0adPWjxkzJsXn8/nj4uLKnnjiiVpdzxsXF1f2ySeftHzggQc6t2vX7sC8efO+Cr52xRVXbFuwYEHiyJEji2tzTEnq2bPngfPOO297ampqenJy8r709PRazVY+bty4beecc05Pn8/n79ev3+5u3brtrW0MM2fOPPaFF15oF1x+5ZVXCqZMmdJ53Lhxhf369dv3j3/8Y/WwYcN6n3322TskKS0tbffgwYN7b9++PeaWW27ZkJKSciAlJeVAVZ+tmJiYSsMNxowZszktLc3fp0+f3V6+rtoON9QCAAAAwOGtWLFidUZGRq17LBuToqKiqNatW5dJ0h133HHchg0bms2ePfvb+o6rvvzmN785tqioKPrPf/7z+vqOJdImT57cuVWrVqWN+RZtkbJixYr2GRkZKcFleqoBAAAAVOmFF15o/dBDD3UqLS21pKSkfc8888zq+o6pvpx11lk91qxZE7to0aL8+o4FDQs91QAAAEAYmkJPNYDKDu2pZqIyAAAAAADCRFENAAAAhKesrKzM8zMbA/ifwP/5780mT1ENAAAAhGfV5s2bW1NYA01DWVmZbd68ubWkVRXXM1EZAAAAEIaSkpJxGzdufGzjxo19RGcV0BSUSVpVUlIyruJKJioDAAAAACBMfKMGAAAAAECYKKoBAAAAAAgTRTUAAAAAAGGiqAYAAAAAIEwU1QAAAAAAhKlB3VKrffv2LiUlpb7DAABE2KeffrrFOdehvuNoLMiPANB0kCMbnwZVVKekpGjp0qX1HQYAIMLMbE19x9CYkB8BoOkgRzY+ES2qzWy1pB2SSiWVOOf6R/J8AAAAAADUpbroqR7qnNtSB+cBAAAAAKBOMVEZAAAAAABhinRR7SS9ZWafmtn4qjYws/FmttTMlm7evDnC4QAA0DiQHwEAaBwiXVSf4pw7QdI5kn5uZqcduoFz7hHnXH/nXP8OHZjkDgAAifwIAEBjEdGi2jm3LvBvoaSXJA2I5PkAAAAAAKhLESuqzaylmSUEn0s6W9KqSJ0PAAAAAIC6FsnZv4+V9JKZBc/zjHNuQQTPBwAAAABAnYpYUe2c+0pSRqSODwAAAABAfeOWWgAAAAAAhImiGgAAAACAMEXymmoAwNFSPj9Fw+BcfUcAAADQYNBTDQAAAABAmCiqAQAAAAAIE0U1AAAAAABhoqgGAAAAACBMFNUAAAAAAISJohoAAAAAgDBRVAMAAAAAECaKagAAAAAAwkRRDQAAAABAmCiqAQAAAAAIE0U1AAAAAABhoqgGAAAAACBMFNUAAAAAAISJohoAAAAAgDBRVAMAAAAAECaKagAAAAAAwkRRDQAAAABAmCiqAQAAAAAIE0U1AAAAAABhoqgGAAAAACBMFNUAAAAAAISJohoAAAAAgDBRVAMAAAAAEKaY+g4AAAAAAMKVcvvr9R2CJGn11B/VdwioJ/RUAwAAAAAQJopqAAAAAADCRFENAAAAAECYKKoBAAAAAAgTRTUAAAAAAGGiqAYAAAAAIEwU1QAAAAAAhImiGgAAAACAMFFUAwAAAAAQJopqAAAAAADCRFENAAAAAECYKKoBAAAAAAgTRTUAAAAAAGGiqAYAAAAAIEwU1QAAAAAAhImiGgAAAACAMFFUAwAAAAAQpogX1WYWbWafmdn8SJ8LAAAAAIC6VBc91b+QlFMH5wEAAAAAoE5FtKg2s2RJP5L0WCTPAwAAAABAfYh0T/WfJN0mqSzC5wEAAAAAoM5FrKg2s3MlFTrnPq1hu/FmttTMlm7evDlS4QAA0KiQHwEAaBwi2VM9RNL5ZrZa0nOShpnZU4du5Jx7xDnX3znXv0OHDhEMBwCAxoP8CABA4xCxoto59yvnXLJzLkXSpZLeds79JFLnAwAAAACgrnGfagAAAAAAwlSrotrMoszsmNqexDn3jnPu3NruBwCAl4WbVwEAQMNRY1FtZs+Y2TFm1lLSKknZZnZr5EMDAMB7yKsAAHhLKD3VfudcsaQLJb0hqZukn0Y0KgAAvIu8CgCAh4RSVDczs2YqT/6vOucOSHKRDQsAAM8irwIA4CGhFNWzJK2W1FLSu2Z2vKTiSAYFAICHkVcBAPCQmJo2cM5NlzS9wqo1ZjY0ciEBAOBd5FUAALwllInKjjWzv5vZG4Flv6SxEY8MAAAPIq8CAOAtoQz/fkLSm5I6B5bzJd0YqYAAAPC4J0ReBQDAM0Ipqts7516QVCZJzrkSSaURjQoAAO8irwIA4CGhFNW7zKydAjOTmtnJkooiGhUAAN5FXgUAwENqnKhM0mRJr0rqYWYfSOog6eKIRgUAgHeRVwEA8JBQZv9eZmanS+otySTlBe7V+OOwAAAZk0lEQVSpCQAAaom8CgCAt9RYVJvZyENW+cysSNJK51xhZMICAMCbyKsAAHhLKMO/r5Y0SNJ/A8tnSPpUUjczu8c592SEYgMAwIvIqwAAeEgoRXWMpDTn3Cap/P6akuZIGijpXUkkfwAAQkdeBQDAQ0KZ/btLMPEHFAbWbZPENWAAANQOeRUAAA8Jpaf6HTObL+mfgeVRgXUtJX0XscgAAPAm8ioAAB4SSlH9c5Un/CGB5TmS5jrnnKShkQoMAACPIq8CAOAhodxSy0l6MfAAAABHgLwKAIC31HhNtZmdbGZLzGynme03s1IzK66L4AAA8BryKgAA3hLKRGV/lXSZpC8kxUkaJ+nhSAYFAICHkVcBAPCQUIpqOecKJEU750qdc7MljYhsWAAAeBd5FQAA7whlorLdZtZc0nIz+4OkDQqxGAcAAJWQVwEA8JBQkvhPJUVLuk7SLkldVD5rKQAAqD3yKgAAHhLK7N9rAk/3SLo7suEAAOBt5FUAALwllNm/zzWzz8xsm5kVm9kOZikFACA85FUAALwllGuq/yRppKSVgXtrAgCA8JFXAQDwkFCuqV4raRWJHwCAo4K8CgCAh4TSU/1LSW+Y2TuS9gVXOuf+X6SCAgDAw8irAAB4SChF9b2SdkpqIal5ZMMBAMDzyKsAAHhIKEV1Z+dcn4hHAgBA00BeBQDAQ0K5pvpfZnZ2xCMBAKBpIK8CAOAhoRTVkyQtMLM93PoDAIAjRl4FAMBDahz+7ZxLqItAAABoCsirAAB4y2GLajNLdc7lmtkPqnrdObcscmEBAOAt5FUAALypup7qyZLGS3qoitecpGERiQgAAG8irwIA4EGHLaqdc+MD/w6tu3AAAPAm8ioAAN4UykRlAAAAAACgChTVAAAAAACE6bBFtZkNCfwbW3fhAADgTeRVAAC8qbqe6umBfz+qi0AAAPA48ioAAB5U3ezfB8zsEUlJZjb90BedczdELiwAADyHvAoAgAdVV1SfK2m4pB9K+rRuwgEAwLPIqwAAeFB1t9TaIuk5M8txzq2ow5gAAPAc8ioAAN4UyuzfW83sJTMrDDzmmllyxCMDAMCbyKsAAHhIKEX1bEmvSuoceLwWWFctM2thZp+Y2QozyzGzqUcWKgAAnhBWXgUAAA1TKEV1R+fcbOdcSeDxhKQOIey3T9Iw51yGpH6ShprZqUcQKwAAXhBuXgUAAA1QKEX1FjP7iZlFBx4/kbS1pp1cuZ2BxWaSoiVtP4JYAQDwgrDyKgAAaJhCKaqvkvRjSRslbZB0saSfhXLwwB8LyyUVSnrHObcq3EABAPCIsPMqAABoeKq7pZYkyTm3RtL54RzcOVcq6QQzayPpTTMb6pz7b8VtzGy8pPGS1LVr13BOAwBAoxFqXiU/AgDQOITSU33EnHPfSXpdUv8qXnvEOdffOde/QwcuKQMAQCI/AgDQWESsqDazDoEeaplZnKSzJC2P1PkAAAAAAKhr1RbVZhZlZj8O89idJP3XzFZI+kTSfOfcwjCPBQBAo3eEeRUAADRA1V5T7ZwrM7PbJL1Q2wM75z6XdGK4gQEA4DVHklcBAEDDFMrw77fM7BYz62JmbYOPiEcGAIA3kVcBAPCQGmf/lnRJ4N+fV1jnJHU/+uEAAOB55FUAADwklFtqdauLQAAAaArIqwAAeEuNw7/NLN7MppjZI4HlXmZ2buRDAwDAe8irAAB4SyjXVM+WtF/S4MDyOkn3RSwiAAC8jbwKAICHhFJU93DO/UHSAUlyzu2WZBGNCgAA7yKvAgDgIaEU1fvNLE7lk6jIzHpI2hfRqAAA8C7yKgAAHhLK7N93SVogqYuZPS1piKQrIxkUAAAeRl4FAMBDQpn9e6GZLZN0ssqHp/3CObcl4pEBAOBB5FUAALwllJ5qSTpd0ikqH6rWTNJLEYsIAADvI68CAOARodxSa4akiZJWSlolaYKZPRzpwAAA8CLyKgAA3hJKT/UwSWnOueCEKv+QlBXRqAAA8C7yKgAAHhLK7N8FkrpWWO4SWAcAAGqPvAoAgIcctqfazF5T+bVeCZJyzOyTwPJASZ/UTXgAAHgDeRUAAG+qbvj3g3UWBQAA3kdeBQDAgw5bVDvnFlVcNrNjqtseAAAcHnkVAABvqjGZm9l4SfdI2iupTOX31HSSukc2NAAAvIe8CgCAt4TyDfmtkvo457ZEOhgAAJoA8ioAAB4SyuzfX0naHelAAABoIsirAAB4SCg91b+S9JGZLZa0L7jSOXdDxKICAMC7yKsAAHhIKEX1LEn/kbRS5dd+AQCA8JFXAQDwkFCK6hjn3OSIRwIAQNNAXgUAwENCuab6DTMbb2adzKxt8BHxyAAA8CbyKgAAHhJKT/VlgX9/VWEdt/4AACA85FUAADykxqLaOdetLgIBAKApIK8CAOAtNRbVZnZFVeudc3OOfjgAAHgbeRUAAG8JZfj3SRWet5B0pqRlkkj+AADUHnkVAAAPCWX49/UVl82sjaTnIhYRAAAeRl4FAMBbQpn9+1C7JHE9GAAARwd5FQCARiyUa6pfU/mspFJ5Ee6X9EIkgwIAwKvIqwAAeEso11Q/WOF5iaQ1zrm1EYoHAACvI68CAOAhoVxTvaguAgEAoCkgrwIA4C01XlNtZiPN7AszKzKzYjPbYWbFdREcAABeQ14FAMBbQhn+/QdJ5znnciIdDAAATQB5FQAADwll9u9NJH4AAI4a8ioAAB4SSk/1UjN7XtLLkvYFVzrn5kUsKgAAvIu8CgCAh4RSVB8jabeksyusc5JI/gAA1B55FQAADwll9u+f1UUgAAA0BeRVAAC8JZRrqgEAAAAAQBUoqgEAAAAACNNhi2oz+0Xg3yF1Fw4AAN5EXgUAwJuq66kOXvP1l7oIBAAAjyOvAgDgQdVNVJZjZl9I6mxmn1dYb5Kcc65fZEMDAMBTyKsAAHjQYYtq59xlZnacpDclnV93IQEA4D3kVQAAvKnaW2o55zZKyjCz5pJ8gdV5zrkDEY8MAACPIa8CAOA9Nd6n2sxOlzRH0mqVD1HrYmZjnXPv1rBfl8B+x0pykh5xzv35iCMGAKARCzevAgCAhqnGolrS/5N0tnMuT5LMzCfpWUmZNexXIulm59wyM0uQ9KmZLXTOZR9RxAAANG7h5lUAANAAhXKf6mbBxC9Jzrl8Sc1q2sk5t8E5tyzwfIekHElJ4QYKAIBHhJVXAQBAwxRKT/VSM3tM0lOB5TGSltbmJGaWIulESR9X8dp4SeMlqWvXrrU5LAAAjVFIeZX8CABA4xBKT/UkSdmSbgg8sgPrQmJmrSTNlXSjc6740Nedc4845/o75/p36NAh1MMCANBYhZRXyY8AADQONfZUO+f2qfz6r/9X24ObWTOVF9RPO+fm1T48AAC85UjyKgAAaHhC6akOi5mZpL9LynHO8YcDAAAAAMBzIlZUSxoi6aeShpnZ8sDj/yJ4PgAAAAAA6lQoE5WFxTn3vsrvvwkAAAAAgCfVWFQH7p95q6TjK27vnBsWwbgAAPAk8ioAAN4SSk/1PyXNlPSopNLIhgMAgOeRVwEA8JBQiuoS59zfIh4JAABNA3kVAAAPCWWistfM7Foz62RmbYOPiEcGAIA3kVcBAPCQUHqqxwb+vbXCOiep+9EPBwAkWQOa49C5+o4A3kNeBQDAQ2osqp1z3eoiEAAAmgLyKgAA3hLK7N/NJE2SdFpg1TuSZjnnDkQwLgAAPIm8CgCAt4Qy/PtvkppJmhFY/mlg3bhIBQUAgIeRVwEA8JBQiuqTnHMZFZbfNrMVkQoIAACPI68CAOAhocz+XWpmPYILZtZd3FcTAIBwkVcBAPCQUHqqb5X0XzP7SpJJOl7SzyIaFQAA3kVeBQDAQ0KZ/fs/ZtZLUu/Aqjzn3L7IhgUAgDeRVwEA8JbDFtVmNsw597aZjTzkpZ5mJufcvAjHBgCAZ5BXAQDwpup6qk+X9Lak86p4zUki+QMAEDryKgAAHnTYoto5d1fg6T3Oua8rvmZm3SIaFQAAHkNeBQDAm0KZ/XtuFetePNqBAADQRJBXAQDwkOquqU6VlC6p9SHXfx0jqUWkAwMAwEvIqwAAeFN111T3lnSupDb6/vVfOyRdE8mgAADwIPIqAAAeVN011a9IesXMBjnnPqrDmAAA8BzyKgAA3lTjfaolTTSzHOfcd5JkZomSHnLOXRXZ0AAA8CTyKoCwpdz+en2HIElaPfVH9R0C0GCEMlFZv2DilyTn3HZJJ0YuJAAAPI28CgCAh4RSVEcFvkWXJJlZW4XWww0AACojrwIA4CGhJPGHJH1kZv+UZJIulnR/RKMCAMC7yKsAAHhIjUW1c26OmX0qaWhg1UjnXHZkwwIAwJvIqwAAeEtIw82cc1lmtlmB+2iaWVfn3DcRjQwAAI8irwIA4B01XlNtZueb2ReSvpa0SNJqSW9EOC4AADyJvAoAgLeEMlHZvZJOlpTvnOsm6UxJiyMaFQAA3kVeBQDAQ0Ipqg8457aqfLbSKOfcfyX1j3BcAAB4FXkVAAAPCeWa6u/MrJWkdyU9bWaFknZFNiwAADyLvAoAgIeE0lN9gaTdkm6StEDSl5LOi2RQAAB4GHkVAAAPqban2syiJc13zg2VVCbpH3USFQAAHkReBQDAe6rtqXbOlUoqM7PWdRQPAACeRV4FAMB7QrmmeqeklWa2UBWu+XLO3RCxqAAA8C7yKgAAHhJKUT0v8AAAAEeOvAoAgIcctqg2s67OuW+cc1zvBQDAESKvAgDgTdVdU/1y8ImZza2DWAAA8DLyKgAAHlRdUW0VnnePdCAAAHgceRUAAA+qrqh2h3kOAABqj7wKAIAHVTdRWYaZFav8m/W4wHMFlp1z7piIRwcAgHeQVwEA8KDDFtXOuei6DAQAAC8jrwIA4E3VDf8GAAAAAADVoKgGAAAAACBMFNUAAAAAAISJohoAAAAAgDBVN/v3ETGzxyWdK6nQOdcnUucBAAAAIinl9tfrOwQADVgke6qfkDQigscHAAAAAKBeRayods69K2lbpI4PAAAAAEB945pqAAAAAADCVO9FtZmNN7OlZrZ08+bN9R0OAAANAvkRAIDGod6LaufcI865/s65/h06dKjvcAAAaBDIjwAANA71XlQDAAAAANBYRfKWWs9KOkNSezNbK+ku59zfI3U+AABweA3plkCrp/6ovkMAAOCoiVhR7Zy7LFLHBgAAAACgIWD4NwAAAAAAYaKoBgAAAAAgTBEb/g0gRGb1HUE55+o7AgAADmpI8wAAQHXoqQYAAAAAIEwU1QAAAAAAhImiGgAAAACAMFFUAwAAAAAQJiYqA1CuoUyYBgAAADQi9FQDAAAAABAmeqoBAAAA1Aq3PAP+h55qAAAAAADCRFENAAAAAECYvDf8u6FMtuRcfUcAAAAAAIgweqoBAAAAAAgTRTUAAAAAAGGiqAYAAAAAIEwU1QAAAAAAhImiGgAAAACAMFFUAwAAAAAQJopqAAAAAADCRFENAAAAAECYKKoBAAAAAAhTTH0HAAANmll9RwAAAIAGjJ5qAAAAAADCRFENAAAAAECYKKoBAAAAAAgT11QDAADgoJTbX6/vEACgUaGoRtPE5FMAAAAAjgKGfwMAAAAAECaKagAAAAAAwkRRDQAAAABAmCiqAQAAAAAIE0U1AAAAAABhoqgGAAAAACBMFNUAAAAAAISJohoAAAAAgDBRVAMAAAAAECaKagAAAAAAwhRT3wGgiTGr7wgAAAAA4KihpxoAAAAAgDBRVAMAAAAAECaKagAAAAAAwkRRDQAAAABAmCiqAQAAAAAIU0Rn/zazEZL+LCla0mPOuamRPB8AAEBjlHL76/UdAgAgTBHrqTazaEkPSzpHkl/SZWbmj9T5AAAAAACoa5Ec/j1AUoFz7ivn3H5Jz0m6IILnAwAAAACgTkWyqE6S9G2F5bWBdQAAAAAAeEJEr6kOhZmNlzQ+sLjTzPKO8JDtJW05wmMcObP6jqCihtEmDQttUhltUjXa5VBmR6NNjj8aoXiZZ/OjJJtW3xF8T4NplwaENqmMNqmMNjmETTtqbUKObGTMOReZA5sNkvRb59wPA8u/kiTn3O8jcsL/nXepc65/JM/R2NAmldEmldEmVaNdKqNNGid+blWjXSqjTSqjTSqjTSqjTZquSA7/XiKpl5l1M7Pmki6V9GoEzwcAAAAAQJ2K2PBv51yJmV0n6U2V31LrcedcVqTOBwAAAABAXYvoNdXOuX9J+lckz1GFR+r4fI0BbVIZbVIZbVI12qUy2qRx4udWNdqlMtqkMtqkMtqkMtqkiYrYNdUAAAAAAHhdJK+pBgAAAADA0xplUW1mI8wsz8wKzOz2Kl43M5seeP1zM/tBfcRZ10JolzGB9lhpZh+aWUZ9xFmXamqTCtudZGYlZnZxXcZXH0JpEzM7w8yWm1mWmS2q6xjrWgj/d9qb2QIzWxFok5/VR5x1ycweN7NCM1t1mNeb5O/ZxoAcWRn5sTLyY9XIkZWRI7+P/IgqOeca1UPlk559Kam7pOaSVkjyH7LN/0l6Q5JJOlnSx/UddwNpl8GSEgPPz/F6u4TSJhW2e1vl1/9fXN9x13ebSGojKVtS18Byx/qOuwG0yW8lTQs87yBpm6Tm9R17hNvlNEk/kLTqMK83ud+zjeFBjgy7TciPTTw/1uKzQo5s4jmS/Mijqkdj7KkeIKnAOfeVc26/pOckXXDINhdImuPKLZbUxsw61XWgdazGdnHOfeic2x5YXCwpuY5jrGuhfFYk6XpJcyUV1mVw9SSUNrlc0jzn3DeS5JzzeruE0iYbJSWYmUlqpfI/GErqNsy65Zx7V+Xv83Ca4u/ZxoAcWRn5sTLyY9XIkZWRIw9BfkRVGmNRnSTp2wrLawPraruN19T2PV+t8m/RvKzGNjGzJEkXSfpbHcZVn0L5nPgkJZrZO2b2qZldUWfR1Y9Q2uRRSX5J6yWtlPQL51xZ3YTXYDXF37ONATmyMvJjZeTHqpEjKyNH1l5T+x0LRfiWWmiYzGyoyv9oOKW+Y2kA/iTpl865svIvWKHy3wuZks6UFCfpIzNb7JzLr9+w6tWvJH0uaaikHpIWmtl7zrni+g0LwNFEfvwe8mPVyJGVkSPR5DXGonqdpC4VlpMD62q7jdeE9J7NrJ+kxySd45zbWkex1ZdQ2qS/pOcCfzC0l/R/ZlbinHu5bkKsc6G0yVpJW51zuyTtMrN3JWVI8uofDKG0yRBJv3POOUkFZva1pFRJn9RNiA1SU/w92xiQIysjP1ZGfqwaObIycmTtNbXfsVDjHP69RFIvM+tmZs0lXSrp1UO2eVXSFYHZ906WVOSc21DXgdaxGtvFzLpKmifpp03kG9Ua28Q51805l+KcS5H0oqRrPf4HQyj/f16RdIqZxZhZvKSBknLqOM66FEqb5Kq8V0Jmdqyk3pK+qtMoG56m+Hu2MSBHVkZ+rIz8WDVyZGXkyNprar9joUbYU+2cKzGz6yS9qfIZCR93zmWZ2cTA6zNVPkvl/0kqkLRbkqen9pdCbpffSGonaUbgm+cS51z/+oo50kJskyYllDZxzuWY2QKVD+Uqk/SYc67K20Z4QYifk99Jmm1mn6v8y8hfOue21FvQdcDMnpV0hqT2ZrZW0l2SmklN9/dsY0COrIz8WBn5sWrkyMrIkZWRH1EVKx+pAQAAAAAAaqsxDv8GAAAAAKBBoKgGAAAAACBMFNUAAAAAAISJohoAAAAAgDBRVAMAAAAAECaKauAwzKzUzJabWZaZrTCzm80sKvBafzObfhTOcbKZfRw4T46Z/faIAwcAIMLIkQDwP9xSCzgMM9vpnGsVeN5R0jOSPnDO3XUUz5En6cfOuRVmFi2pt3Mu+wiPGe2cKz06EQIAUBk5EgD+h55qIATOuUJJ4yVdZ+XOMLP5kmRmrcxstpmtNLPPzWxUYP3ZZvaRmS0zs3+aWasqDt1R0obAOUqDfyxUc8zLAutWmdm04EHMbKeZPWRmKyQNMrNMM1tkZp+a2Ztm1imiDQQAaLLIkQCaOopqIETOua8kRas8yVf0a0lFzrm+zrl+kt42s/aSpkga7pz7gaSlkiZXcdg/Ssozs5fMbIKZtajmmJ0lTZM0TNIJkk4yswsD27eU9LFzLkPSx5L+Iuli51ympMcl3X9UGgEAgCqQIwE0ZTH1HQDgAcMlXRpccM5tN7NzJfklfWBmktRc0keH7uicu8fMnpZ0tqTLJV0m6YzDHPM0Se845zZLUmC/0yS9LKlU0tzA5r0l9ZG0MHDuaAW+6QcAoI6RIwF4HkU1ECIz667yxFwoKa2mzSUtdM5dVtNxnXNfSvqbmT0qabOZtQsjvL0VrhEzSVnOuUFhHAcAgFojRwJoyhj+DYTAzDpIminpr67y7H4LJf28wraJkhZLGmJmPQPrWpqZr4rj/sgCX5VL6qXyP0i+O8wxP5F0upm1D0zYcpmkRVWEmyepg5kNCuzbzMzSw3jbAADUiBwJoKmjqAYOL84CtwuR9Jakf0u6u4rt7pOUGJgYZYWkoYHhZ1dKetbMPlf5sLbUKvb9qcqvF1su6UlJYwLfpld1zA2Sbpf0X0krJH3qnHvl0AM65/ZLuljStMC+yyUNDr8ZAACohBwJAAHcUgsAAAAAgDDRUw0AAAAAQJgoqgEAAAAACBNFNQAAAAAAYaKoBgAAAAAgTBTVAAAAAACEiaIaAAAAAIAwUVQDAAAAABAmimoAAAAAAML0/wHFWQsUtWybuwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x2b86b1915d68>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<matplotlib.figure.Figure at 0x2b86b11ddc18>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def compare_plots(valid,reseg):\n", + " for i in range(3):\n", + " print(i)\n", + " f, axarr = plt.subplots(1,2,sharey=True)\n", + " f.set_size_inches(15, 5, forward=True)\n", + " axarr[0].hist(valid[i],label = \"Model's prediction on the validation sample\",color = 'r', normed = True)\n", + " axarr[1].hist(reseg[i], label = 'Resegmentation by Human Expert',normed=True)\n", + " f.legend()\n", + " axarr[0].set_xlabel('Dice Score')\n", + " axarr[0].set_ylabel('Fraction of number of images')\n", + " plt.xlabel('Dice Score')\n", + " plt.ylabel('Fraction of number of images')\n", + " plt.show()\n", + "compare_plots(dice_hist_smooth,reseg_dc_sr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Discussion\n", + "As it can be seen above, the distribution of dice scores for the model's prediction and resegmented images by a human expert are very similar. It suggests the model and human are making similar errors and also focussing on similar kind of information in an image while segmenting it." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}