diff --git a/recognition/ISICs_Unet/README.md b/recognition/ISICs_Unet/README.md index 549f2535f2..f2c009212e 100644 --- a/recognition/ISICs_Unet/README.md +++ b/recognition/ISICs_Unet/README.md @@ -1,101 +1,52 @@ -# Segment the ISICs data set with the U-net - -## Project Overview -This project aim to solve the segmentation of skin lesian (ISIC2018 data set) using the U-net, with all labels having a minimum Dice similarity coefficient of 0.7 on the test set[Task 3]. - -## ISIC2018 -![ISIC example](imgs/example.jpg) - -Skin Lesion Analysis towards Melanoma Detection - -Task found in https://challenge2018.isic-archive.com/ - - -## U-net -![UNet](imgs/uent.png) - -U-net is one of the popular image segmentation architectures used mostly in biomedical purposes. The name UNet is because it’s architecture contains a compressive path and an expansive path which can be viewed as a U shape. This architecture is built in such a way that it could generate better results even for a less number of training data sets. - -## Data Set Structure - -data set folder need to be stored in same directory with structure same as below -```bash -ISIC2018 - |_ ISIC2018_Task1-2_Training_Input_x2 - |_ ISIC_0000000 - |_ ISIC_0000001 - |_ ... - |_ ISIC2018_Task1_Training_GroundTruth_x2 - |_ ISIC_0000000_segmentation - |_ ISIC_0000001_segmentation - |_ ... -``` - -## Dice Coefficient - -The Sørensen–Dice coefficient is a statistic used to gauge the similarity of two samples. - -Further information in https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient - -## Dependencies - -- python 3 -- tensorflow 2.1.0 -- pandas 1.1.4 -- numpy 1.19.2 -- matplotlib 3.3.2 -- scikit-learn 0.23.2 -- pillow 8.0.1 - - -## Usages - -- Run `train.py` for training the UNet on ISIC data. -- Run `evaluation.py` for evaluation and case present. - -## Advance - -- Modify `setting.py` for custom setting, such as different batch size. -- Modify `unet.py` for custom UNet, such as different kernel size. - -## Algorithm - -- data set: - - The data set we used is the training set of ISIC 2018 challenge data which has segmentation labels. - - Training: Validation: Test = 1660: 415: 519 = 0.64: 0.16 : 0.2 (Training: Test = 4: 1 and in Training, further split 4: 1 for Training: Validation) - - Training data augmentations: rescale, rotate, shift, zoom, grayscale -- model: - - Original UNet with padding which can keep the shape of input and output same. - - The first convolutional layers has 16 output channels. - - The activation function of all convolutional layers is ELU. - - Without batch normalization layers. - - The inputs is (384, 512, 1) - - The output is (384, 512, 1) after sigmoid activation. - - Optimizer: Adam, lr = 1e-4 - - Loss: dice coefficient loss - - Metrics: accuracy & dice coefficient - -## Results - -Evaluation dice coefficient is 0.805256724357605. - -plot of train/valid Dice coefficient: - -![img](imgs/train_and_valid_dice_coef.png) - -case present: - -![case](imgs/case%20present.png) - -## Reference -Manna, S. (2020). K-Fold Cross Validation for Deep Learning using Keras. [online] Medium. Available at: https://medium.com/the-owl/k-fold-cross-validation-in-keras-3ec4a3a00538 [Accessed 24 Nov. 2020]. - -zhixuhao (2020). zhixuhao/unet. [online] GitHub. Available at: https://github.com/zhixuhao/unet. - -GitHub. (n.d.). NifTK/NiftyNet. [online] Available at: https://github.com/NifTK/NiftyNet/blob/a383ba342e3e38a7ad7eed7538bfb34960f80c8d/niftynet/layer/loss_segmentation.py [Accessed 24 Nov. 2020]. - -Team, K. (n.d.). Keras documentation: Losses. [online] keras.io. Available at: https://keras.io/api/losses/#creating-custom-losses [Accessed 24 Nov. 2020]. - -262588213843476 (n.d.). unet.py. [online] Gist. Available at: https://gist.github.com/abhinavsagar/fe0c900133cafe93194c069fe655ef6e [Accessed 24 Nov. 2020]. - -Stack Overflow. (n.d.). python - Disable Tensorflow debugging information. [online] Available at: https://stackoverflow.com/questions/35911252/disable-tensorflow-debugging-information [Accessed 24 Nov. 2020]. +# Segmenting ISICs with U-Net + +COMP3710 Report recognition problem 3 (Segmenting ISICs data set with U-Net) solved in TensorFlow + +Created by Christopher Bailey (45576430) + +## The problem and algorithm +The problem solved by this program is binary segmentation of the ISICs skin lesion data set. Segmentation is a way to label pixels in an image according to some grouping, in this case lesion or non-lesion. This translates images of skin to masks representing areas of concern for skin lesions. + +U-Net is a form of autoencoder where the downsampling path is expected to learn the features of the image and the upsampling path learns how to recreate the masks. Long skip connections between downpooling and upsampling layers are utilised to overcome the bottleneck in traditional autoencoders allowing feature representations to be recreated. + +## How it works +A four layer padded U-Net is used, preserving skin features and mask resolution. The implementation utilises Adam as the optimizer and implements Dice distance as the loss function as this appeared to give quicker convergence than other methods (eg. binary cross-entropy). + +The utilised metric is a Dice coefficient implementation. My initial implementation appeared faulty and was replaced with a 3rd party implementation which appears correct. 3 epochs was observed to be generally sufficient to observe Dice coefficients of 0.8+ on test datasets but occasional non-convergence was observed and could be curbed by increasing the number of epochs. Visualisation of predictions is also implemented and shows reasonable correspondence. Orange bandaids represent an interesting challenge for the implementation as presented. + +### Training, validation and testing split +Training, validation and testing uses a respective 60:20:20 split, a commonly assumed starting point suggested by course staff. U-Net in particular was developed to work "with very few training images" (Ronneberger et al, 2015) The input data for this problem consists of 2594 images and masks. This split appears to provide satisfactory results. + +## Using the model +### Dependencies required +* Python3 (tested with 3.8) +* TensorFlow 2.x (tested with 2.3) +* glob (used to load filenames) +* matplotlib (used for visualisations, tested with 3.3) + +### Parameter tuning +The model was developed on a GTX 1660 TI (6GB VRAM) and certain values (notably batch size and image resolution) were set lower than might otherwise be ideal on more capable hardware. This is commented in the relevant code. + +### Running the model +The model is executed via the main.py script. + +### Example output +Given a batch size of 1 and 3 epochs the following output was observed on a single run: +Era | Loss | Dice coefficient +--- | ---- | ---------------- +Epoch 1 | 0.7433 | 0.2567 +Epoch 2 | 0.3197 | 0.6803 +Epoch 3 | 0.2657 | 0.7343 +Testing | 0.1820 | 0.8180 + + +### Figure 1 - example visualisation plot +Skin images in left column, true mask middle, predicted mask right column +![Visualisation of predictions](visual.png) + +## References +Segments of code in this assignment were used from or based on the following sources: +1. COMP3710-demo-code.ipynb from Guest Lecture +1. https://www.tensorflow.org/tutorials/load_data/images +1. https://www.tensorflow.org/guide/gpu +1. Karan Jakhar (2019) https://medium.com/@karan_jakhar/100-days-of-code-day-7-84e4918cb72c diff --git a/recognition/s4633139/IUNet.ipynb b/recognition/s4633139/IUNet.ipynb new file mode 100644 index 0000000000..165f64bec1 --- /dev/null +++ b/recognition/s4633139/IUNet.ipynb @@ -0,0 +1 @@ +{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"IUNet.ipynb","provenance":[],"collapsed_sections":[],"mount_file_id":"1UdH3PIDr4uawfSNGUl8ntSrq2Lbo_uQQ","authorship_tag":"ABX9TyMhn0gJSue2GPm8/W30Ob7Y"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"},"accelerator":"GPU"},"cells":[{"cell_type":"code","metadata":{"id":"vlhQO-g6Y2ah","executionInfo":{"status":"ok","timestamp":1634536832538,"user_tz":-600,"elapsed":12962,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["import os\n","from PIL import Image\n","import glob\n","import matplotlib.pyplot as plt\n","\n","import torch\n","import torch.nn as nn\n","import torch.nn.functional as F\n","\n","import torch.utils.data\n","from torchvision import datasets, transforms"],"execution_count":1,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"7vcUuTeHs59d"},"source":["# Data preparation\n","\n"]},{"cell_type":"code","metadata":{"id":"gPYa8ZVvXk2d","executionInfo":{"status":"ok","timestamp":1634536832542,"user_tz":-600,"elapsed":9,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["import os\n","from PIL import Image\n","import glob\n","import matplotlib.pyplot as plt\n","\n","#define dataset for img and mask\n","file_dir = \"/content/drive/MyDrive/ColabGitHub/ISIC2018_Task1-2_Training_Data\"\n","os.chdir(file_dir)"],"execution_count":2,"outputs":[]},{"cell_type":"code","metadata":{"id":"StdLOrNGt3Id","executionInfo":{"status":"ok","timestamp":1634536854321,"user_tz":-600,"elapsed":9,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["from torchvision import datasets\n","from torchvision.datasets import ImageFolder\n","from torch.utils.data import dataloader, random_split, Subset\n","from torchvision.transforms import transforms"],"execution_count":4,"outputs":[]},{"cell_type":"code","metadata":{"id":"JhoipyIyXvBB","executionInfo":{"status":"ok","timestamp":1634536854321,"user_tz":-600,"elapsed":7,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["from torch.utils.data import Dataset\n","from PIL import Image\n","\n","class Unet_dataset(Dataset):\n"," def __init__(self,\n"," img_dir = './ISIC2018_Task1-2_Training_Input_x2',\n"," mask_dir = './ISIC2018_Task1_Training_GroundTruth_x2', \n"," img_transforms=None,\n"," mask_transforms= None):\n"," \n"," self.img_dir = img_dir\n"," self.mask_dir = mask_dir\n"," self.img_transforms = img_transforms\n"," self.mask_transforms = mask_transforms\n","\n"," self.imgs = [file for file in sorted(os.listdir(self.img_dir)) if file.endswith('.jpg')]\n"," self.masks = [file for file in sorted(os.listdir(self.mask_dir)) if file.endswith('.png')]\n","\n"," #meke dataloader\n"," def load_data(self, idx):\n"," img_path = os.path.join(self.img_dir, self.imgs[idx])\n"," mask_path = os.path.join(self.mask_dir, self.masks[idx])\n"," img = Image.open(img_path).convert('RGB')\n"," mask = Image.open(mask_path).convert('L')\n"," return img, mask\n","\n"," def __getitem__(self, idx):\n"," img, mask = self.load_data(idx)\n"," #transformation\n"," if self.img_transforms is not None:\n"," img = self.img_transforms(img)\n"," if self.mask_transforms is not None:\n"," mask = self.mask_transforms(mask)\n"," return img, mask\n","\n"," def __len__(self):\n"," return len(self.imgs)"],"execution_count":5,"outputs":[]},{"cell_type":"code","metadata":{"id":"vpwsi1o-xnYw","executionInfo":{"status":"ok","timestamp":1634536856022,"user_tz":-600,"elapsed":4,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["from torch.utils.data import DataLoader\n","import torchvision.transforms as transforms\n","\n","\n","#transformation\n","img_tfs = transforms.Compose([\n"," transforms.Resize((128,128)),\n"," transforms.ToTensor(),\n"," transforms.Normalize(mean=[0, 0, 0], std=[1, 1, 1]),\n"," ]\n"," )\n","\n","mask_tfs = transforms.Compose([\n"," transforms.Resize((128,128)),\n"," transforms.ToTensor(),\n"," ]\n"," )\n","\n","dataset = Unet_dataset(img_transforms=img_tfs, mask_transforms=mask_tfs)\n","\n","\n","#shuffle index\n","sample_size = len(dataset.imgs)\n","train_size = int(sample_size*0.8)\n","test_size = sample_size - train_size\n","\n","#train and test set\n","train_set, test_set = torch.utils.data.random_split(dataset, [train_size, test_size], generator=torch.Generator().manual_seed(123))\n","\n","#dataloader\n","train_loader= DataLoader(train_set, batch_size=64, shuffle = True)\n","test_loader= DataLoader(test_set, batch_size=64, shuffle=False)"],"execution_count":6,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"cN3J5wTpx_HX"},"source":["# Improved Unet"]},{"cell_type":"code","metadata":{"id":"VFiXmwWjSeXi","executionInfo":{"status":"ok","timestamp":1634536856023,"user_tz":-600,"elapsed":4,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["import torch\n","import torch.nn as nn\n","import torch.nn.functional as F"],"execution_count":7,"outputs":[]},{"cell_type":"code","metadata":{"id":"nzGxgjkBeFXR","executionInfo":{"status":"ok","timestamp":1634536862998,"user_tz":-600,"elapsed":410,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["class Context(nn.Module):\n"," def __init__(self, in_channels, out_channels):\n"," super(Context, self).__init__()\n"," self.context = nn.Sequential(\n"," nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),\n"," nn.BatchNorm2d(out_channels),\n"," nn.Dropout2d(p=0.3),\n"," nn.LeakyReLU(negative_slope=0.02, inplace=True),\n"," nn.Conv2d(in_channels, out_channels, kernel_size=3, stride = 1, padding=1, bias=False),\n"," nn.BatchNorm2d(out_channels),\n"," nn.LeakyReLU(negative_slope=0.02, inplace=True),\n"," )\n","\n"," def forward(self, x):\n"," x = self.context(x) + x\n"," return x\n","\n","\n","class Localization(nn.Module):\n"," def __init__(self, in_channels, out_channels):\n"," super(Localization, self).__init__()\n"," self.localization = nn.Sequential(\n"," nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),\n"," nn.BatchNorm2d(out_channels),\n"," nn.LeakyReLU(negative_slope=0.02, inplace=True),\n"," nn.Conv2d(out_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),\n"," nn.BatchNorm2d(out_channels),\n"," nn.LeakyReLU(negative_slope=0.02, inplace=True),\n"," )\n"," \n"," def forward(self, x):\n"," return self.localization(x)\n","\n","\n","class Upsampling(nn.Module):\n"," def __init__(self, in_channels, out_channels):\n"," super(Upsampling, self).__init__()\n"," self.upsampling = nn.Sequential(\n"," nn.Upsample(scale_factor=2, mode='nearest'),\n"," nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),\n"," nn.BatchNorm2d(out_channels),\n"," nn.LeakyReLU(negative_slope=0.02, inplace=True),\n"," )\n"," \n"," def forward(self, x):\n"," return self.upsampling(x)\n","\n","\n","class Segment(nn.Module):\n"," def __init__(self, in_channels, out_channels):\n"," super(Segment, self).__init__()\n"," self.segment = nn.Sequential(\n"," nn.Conv2d(in_channels, out_channels=1, kernel_size=1, stride=1, padding=0, bias=False),\n"," nn.BatchNorm2d(out_channels),\n"," nn.LeakyReLU(negative_slope=0.02, inplace=True)\n"," )\n"," \n"," def forward(self, x):\n"," return self.segment(x)\n","\n","\n","class Conv2(nn.Module):\n"," def __init__(self, in_channels, out_channels):\n"," super(Conv2, self).__init__()\n"," self.conv2 = nn.Sequential(\n"," nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False),\n"," nn.BatchNorm2d(out_channels),\n"," nn.LeakyReLU(negative_slope=0.02, inplace=True),\n"," )\n","\n"," def forward(self, x):\n"," return self.conv2(x)\n","\n","\n","class ImprovedUnet(nn.Module):\n"," def __init__(self, in_channels=3, out_channels=1, feature_size=[16, 32, 64, 128]):\n"," super(ImprovedUnet, self).__init__()\n"," self.Conv1 = nn.Conv2d(in_channels=3, out_channels=feature_size[0], kernel_size=3, stride=1, padding=1, bias=False) \n"," self.Downs = nn.ModuleList()\n"," self.Convs = nn.ModuleList()\n"," self.Ups = nn.ModuleList()\n"," self.Segmentations = nn.ModuleList()\n","\n"," self.upscale = nn.Upsample(scale_factor=2, mode='nearest')\n"," self.bottleneck = Context(feature_size[-1]*2, feature_size[-1]*2)\n","\n","\n"," #Downsampling frame\n"," for feature in feature_size:\n"," self.Downs.append(Context(feature, feature))\n"," self.Convs.append(Conv2(feature, feature*2))\n","\n"," #Upsampleing frame\n"," for feature in reversed(feature_size):\n"," #Upsample\n"," self.Ups.append(Upsampling(feature*2, feature))\n","\n"," #Localization\n"," if feature != feature_size[0]:\n"," self.Ups.append(Localization(feature*2, feature))\n"," else:\n"," self.Ups.append(Localization(feature*2, feature*2))\n"," \n"," #Segmentation\n"," self.Segmentations.append(Segment(feature, 1))\n","\n"," self.final_conv = nn.Conv2d(feature_size[0]*2, out_channels, kernel_size=1, stride=1, bias=False)\n"," \n","\n"," def forward(self, x):\n"," skip_connections = []\n"," segmentation_layers = []\n","\n"," x = self.Conv1(x)\n","\n"," #Downsampling steps\n"," for i, (context_i, conv_i) in enumerate(zip(self.Downs, self.Convs)):\n"," x = context_i(x)\n"," #preserve location\n"," skip_connections.append(x)\n"," x = conv_i(x)\n","\n"," x = self.bottleneck(x) + x\n"," skip_connections = skip_connections[: : -1]\n","\n"," #Upsampling steps\n"," for idx in range(0, len(self.Ups), 2):\n"," #upsample\n"," x = self.Ups[idx](x)\n","\n"," #localization\n"," skip_connection = skip_connections[idx//2]\n"," concatnate_skip = torch.cat((skip_connection, x), dim=1)\n"," x = self.Ups[idx+1](concatnate_skip)\n","\n"," #segmentation\n"," if idx == 2 or idx == 4:\n"," x_segment = self.Segmentations[idx//2](x)\n"," segmentation_layers.append(x_segment)\n","\n"," seg_scale1 = self.upscale(segmentation_layers[0])\n"," seg_scale2 = self.upscale(segmentation_layers[1]+seg_scale1)\n","\n"," x = self.final_conv(x)\n"," x = x + seg_scale2\n","\n"," output = F.sigmoid(x)\n"," \n"," return output"],"execution_count":8,"outputs":[]},{"cell_type":"code","metadata":{"id":"otdcbBK7g4fW","executionInfo":{"status":"ok","timestamp":1634536865757,"user_tz":-600,"elapsed":3,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["feature_size=[16, 32, 64, 128]\n","device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"],"execution_count":9,"outputs":[]},{"cell_type":"code","metadata":{"id":"oDhAF_WYyeJm","executionInfo":{"status":"ok","timestamp":1634536867513,"user_tz":-600,"elapsed":3,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["#dice coef\n","def dice_coef(pred, target):\n"," batch_size = len(pred)\n"," somooth = 1.\n","\n"," pred_flat = pred.view(batch_size, -1)\n"," target_flat = target.view(batch_size, -1)\n","\n"," intersection = (pred_flat*target_flat).sum()\n"," dice_coef = (2.*intersection+somooth)/(pred_flat.sum()+target_flat.sum()+somooth)\n"," return dice_coef\n","\n","#loss\n","def dice_loss(pred, target):\n"," dice_loss = 1 - dice_coef(pred, target)\n"," return dice_loss"],"execution_count":10,"outputs":[]},{"cell_type":"code","metadata":{"id":"dNMXUs-qViYi","executionInfo":{"status":"ok","timestamp":1634536882245,"user_tz":-600,"elapsed":9838,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["import torch.optim as optim\n","\n","#set parameters\n","feature_size=[16, 32, 64, 128]\n","model = ImprovedUnet(feature_size=feature_size)\n","model = model.to(device)\n","\n","optimizer = optim.Adam(model.parameters(), lr=0.001)\n","EPOCHS = 50"],"execution_count":11,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"JrGpP3KMPzpe","executionInfo":{"status":"ok","timestamp":1634529930671,"user_tz":-600,"elapsed":1700198,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"d305c055-fbf6-4433-efae-2d8caf9980ea"},"source":["from tqdm import tqdm\n","\n","TRAIN_LOSS = []\n","TRAIN_DICE = []\n","TEST_LOSS =[]\n","TEST_DICE = []\n","\n","for epoch in range(1, EPOCHS+1):\n"," print('EPOCH {}/{}'.format(epoch, EPOCHS))\n"," running_loss = 0\n"," running_dicecoef = 0\n"," running_loss_test = 0\n"," running_dicecoef_test = 0\n"," BATCH_NUM = len(train_loader)\n"," BATCH_NUM_TEST = len(test_loader)\n","\n"," #training\n"," with tqdm(train_loader, unit='batch') as tbatch:\n"," for batch_idx, (x, y) in enumerate(tbatch):\n"," x, y = x.to(device), y.to(device)\n"," tbatch.set_description(f'Batch: {batch_idx}')\n","\n"," optimizer.zero_grad()\n"," output = model(x)\n"," loss = dice_loss(output, y)\n"," dicecoef = dice_coef(output, y)\n"," loss.backward()\n"," optimizer.step()\n","\n"," running_loss += loss.item()\n"," running_dicecoef += dicecoef.item()\n","\n"," tbatch.set_postfix(loss=loss.item(), dice_coef=dicecoef.item())\n","\n"," epoch_loss = running_loss/BATCH_NUM\n"," epoch_dicecoef = running_dicecoef/BATCH_NUM\n"," TRAIN_LOSS.append(epoch_loss)\n"," TRAIN_DICE.append(epoch_dicecoef)\n","\n"," #test\n"," with tqdm(test_loader, unit='batch') as tsbatch:\n"," for batch_idx, (x, y) in enumerate(tsbatch):\n"," x, y = x.to(device), y.to(device)\n"," tsbatch.set_description(f'Batch: {batch_idx}')\n"," output_test = model(x)\n"," loss_test = dice_loss(output_test, y)\n"," dicecoef_test = dice_coef(output_test, y)\n"," tsbatch.set_postfix(loss=loss_test.item(), dice_coef=dicecoef_test.item())\n","\n"," running_loss_test += loss_test.item()\n"," running_dicecoef_test += dicecoef_test.item()\n","\n"," TEST_LOSS.append(running_loss_test/BATCH_NUM_TEST)\n"," TEST_DICE.append(running_dicecoef_test/BATCH_NUM_TEST)"],"execution_count":null,"outputs":[{"metadata":{"tags":null},"name":"stdout","output_type":"stream","text":["EPOCH 1/50\n"]},{"metadata":{"tags":null},"name":"stderr","output_type":"stream","text":["Batch: 0: 0%| | 0/33 [00:05torchviz) (3.7.4.3)\n"]}]},{"cell_type":"code","metadata":{"id":"oKvcU7lyeujb"},"source":["from torchviz import make_dot\n","make_dot(output, params=dict(model.named_parameters(), ))"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"zG5sYuWORuIO"},"source":["#save model\n","filename = \"Unet_ISIC2.pth\"\n","torch.save(model.state_dict(), filename)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"EhJChHsfViUi"},"source":["model.eval()\n","p = model(x)[0]\n","p = p.to('cpu')\n","plt.imshow(p.detach().squeeze(), cmap='gray')"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"4Rh-uq05TG-A"},"source":["#Evaluation"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":281},"id":"7ZBk4w3xIA8L","executionInfo":{"status":"ok","timestamp":1634530179125,"user_tz":-600,"elapsed":599,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"3d36229a-f06c-4097-81ef-ba14fcb527b8"},"source":["import matplotlib.pyplot as plt\n","import numpy as np\n","\n","X = np.arange(1,EPOCHS+1)\n","X_tick = np.arange(0,EPOCHS+1,5)\n","\n","plt.plot(X, TRAIN_LOSS, marker='.', markersize=10, label='train')\n","plt.plot(X, TEST_LOSS, marker='.', markersize=10, label='test')\n","plt.xlabel('Epochs')\n","plt.ylabel('Dice Loss')\n","plt.xticks(X_tick)\n","plt.legend()\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAYIAAAEICAYAAABS0fM3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3xU1bnw8d8zk5ncIEAgARICQYncMUAEq1bxgqK2Wi+12mqrpa9t32rt6dFWT1vPad/2tNrWeqlHa720xSq19tjailZAAliVixC5hRDkGm4Jl3DJbZKZ9f6xZ5KZZCZMIHsmyX6+n08+yazZM2vtEPYzaz1rryXGGJRSSjmXK9kNUEoplVwaCJRSyuE0ECillMNpIFBKKYfTQKCUUg6ngUAppRzO1kAgInNEpEJEtorI/VGev11EakSkLPj1FTvbo5RSqqMUu95YRNzAk8BsoApYJSKvG2M2tTv0T8aYu+J93yFDhpjCwsLua6hSSjnAhx9+eNAYkxPtOdsCATAD2GqM2QYgIvOBa4H2gaBLCgsLWb16dTc0TymlnENEdsZ6zs6hoXxgd9jjqmBZezeIyDoReVVECqK9kYjcKSKrRWR1TU2NHW1VSinHSnay+O9AoTFmCrAQ+H20g4wxzxhjSowxJTk5UXs2SimlTpGdgWAPEP4Jf0SwrJUx5pAxpin48Flguo3tUUopFYWdOYJVQJGIjMYKADcDnw8/QESGG2P2BR9eA5Tb2B6llIM1NzdTVVVFY2Njsptiq7S0NEaMGIHH44n7NbYFAmNMi4jcBfwTcAPPG2M2isiPgNXGmNeBb4rINUALcBi43a72KKWcraqqiv79+1NYWIiIJLs5tjDGcOjQIaqqqhg9enTcr7OzR4AxZgGwoF3Zg2E/PwA8YGcbAPwBQ2lFNRv3HmNiXhazxubidvXNPwSlVHSNjY19OggAiAiDBw+mq5NqbA0EPYE/YLjtuRWU7a6lwecn3eumuGAg8+bO1GCglMP05SAQcirnmOxZQ7YrraimbHct9T4/Bqj3+SnbXUtpRXWym6aUUj1Cnw8EG/ceo8Hnjyhr8PnZtPdYklqklHKi2tpa/ud//qfLr7vqqquora21oUVt+nwgmJiXRbrXHVGW7nUzIS8rSS1SSvUG/oBhcfkBHl9cyeLyA/gDp7etb6xA0NLS0unrFixYwMCBA0+r7pPp8zmCWWNzKS4YyJpdR2hsDuBNcVFcMJBZY3OT3TSlVA9lR27x/vvv5+OPP6a4uBiPx0NaWhqDBg1i8+bNbNmyhc985jPs3r2bxsZG7rnnHu68806gbVmdEydOcOWVV3LBBRfw3nvvkZ+fz9/+9jfS09NP+3ylt21eX1JSYrq61pA/YHhrwz6+8dJarp+az88/e7YmipVymPLycsaPHw/AD/++sdPh4SP1PrZWnyC8E+ASGJPbj0EZ3qivmZCXxX9+emLM99yxYwef+tSn2LBhA6WlpVx99dVs2LChdZrn4cOHyc7OpqGhgXPOOYelS5cyePDgiEAwZswYVq9eTXFxMTfddBPXXHMNt956a6fnGiIiHxpjSqK1rc8PDQG4XcLVU/IYnOnFm+LSIKCU6lR9k5/2I0EBY5V3lxkzZkTM9X/88cc5++yzOffcc9m9ezeVlZUdXjN69GiKi4sBmD59Ojt27OiWtvT5oaFwBdkZ7D5Sn+xmKKWSrLNP7gCLyw9w98trqQ+baJLhdfPDaydy6fih3dKGzMzM1p9LS0tZtGgR77//PhkZGcyaNSvqHdCpqamtP7vdbhoaGrqlLY7oEYQUZGew+3D3/OKUUn1XKLeY4XUjWEHgdHOL/fv35/jx41GfO3r0KIMGDSIjI4PNmzfzwQcfnHI9p8JZPYJB6SxYv48Wf4AUt6NioFKqC9wuYd7cmZRWVLNp7zEmdMOKBIMHD+b8889n0qRJpKenM3RoW89izpw5PP3004wfP56xY8dy7rnndsdpxM1RgWBkdgb+gGHf0UYKsjOS3RylVA/mdgmXjh/abUNBAC+99FLU8tTUVN58882oz4XyAEOGDGHDhg2t5ffee2+3tctRH4tDF3/NEyilVBtnBYJBwUBwWAOBUkqFOCoQDB+YhtslmjBWSqkwjgoEHreL4QPSdGhIKaXCOCoQgDU8tEuHhpRSqpXjAsFIvZdAKaUiOC4QFGSnc/BEU4elqZVSyk6nugw1wKOPPkp9vX0jGQ4MBDqFVCkVh4AfKt6CpQ9b3wOn9+GxJwcCR91QBmGB4HA9Zw3tn+TWKKV6pIAf5l0He1aDrx68GZBfAre9Bi73yV8fRfgy1LNnzyY3N5dXXnmFpqYmrrvuOn74wx9SV1fHTTfdRFVVFX6/nx/84AccOHCAvXv3cvHFFzNkyBCWLFnSzSfrxECg9xIopd68H/avj/18/WE4uBlMwHrsq4Mdy+GpCyAjO/prhk2GK38W8y1/9rOfsWHDBsrKynj77bd59dVXWblyJcYYrrnmGpYtW0ZNTQ15eXm88cYbgLUG0YABA3jkkUdYsmQJQ4YMOdUz7pTjhoaG9POS7nGzSxPGSqlYfCfagkCICVjl3eDtt9/m7bffZurUqUybNo3NmzdTWVnJ5MmTWbhwId/97ndZvnw5AwYM6Jb6TsZxPQIRoSA7XXMESjlZJ5/cASsn8JcvWz2BEG8mXPVzGDvntKs3xvDAAw/w1a9+tcNza9asYcGCBXz/+9/n0ksv5cEHHzzt+k7GcT0CsIaHdGhIKRVT0WwrJ+DNBMT6nl9ilZ+i8GWor7jiCp5//nlOnLB6GHv27KG6upq9e/eSkZHBrbfeyn333ceaNWs6vNYOjusRgJUwXrH9MMYYRHS3MqVUOy63lRiuXGjlEoZNtoLAKSaKIXIZ6iuvvJLPf/7zfOITnwCgX79+vPjii2zdupX77rsPl8uFx+PhqaeeAuDOO+9kzpw55OXl2ZIsdsSexe09u3wbP36jnDU/mE12ZvT9R5VSfUu0fXz7Kt2zOA4js3XmkFJKhTgyEOhNZUop1cbRgUAXn1PKWXrbUPipOJVzdGQg6JeaQnamVxefU8pB0tLSOHToUJ8OBsYYDh06RFpaWpde58hZQ2BtZF+lQ0NKOcaIESOoqqqipqYm2U2xVVpaGiNGjOjSaxwbCEZkZ7Bhz9FkN0MplSAej4fRo0cnuxk9kiOHhsCaObS3tgF/oO92E5VSKh6ODQQFgzJo9hv2H2tMdlOUUiqpnBsIstMB2HVI8wRKKWdzbCAYqfcSKKUU4OBAkDcwHZdAld5LoJRyOGfMGgr4g4tHrYNhU6BoNh63m+ED0vWmMqWU49kaCERkDvAY4AaeNcZEXQRcRG4AXgXOMcac3opy7YW2nKtaDc2RW85Z+xLoTWVKKWezbWhIRNzAk8CVwATgFhGZEOW4/sA9wApbGlK50Np3tLkOMNZGE3tWQ+VC3ZdAKaWwN0cwA9hqjNlmjPEB84Froxz3/4CHAHvmce5fZ20+Hc5XD/vXU5CdQfXxJhqb/bZUrZRSvYGdgSAf2B32uCpY1kpEpgEFxpg3bGvFsCnWcFA4bwYMm9w6c0iXmlBKOVnSZg2JiAt4BPj3OI69U0RWi8jqLq8TEtpyzpNpPXZ5WrecC91LoIvPKaWczM5AsAcoCHs8IlgW0h+YBJSKyA7gXOB1Eemwg44x5hljTIkxpiQnJ6drrQhtOXfj85CZC0MnWY9dbgoG6XLUSillZyBYBRSJyGgR8QI3A6+HnjTGHDXGDDHGFBpjCoEPgGu6fdYQWMFg7BwY/UloONS672hO/1RSU1yaMFZKOZptgcAY0wLcBfwTKAdeMcZsFJEficg1dtXbqZzxULsLmk4AICIUZGfo3cVKKUez9T4CY8wCYEG7sgdjHDvLzrYAkDvO+n6wAvKnA9a+BLs0R6CUcjBnLTGRG7yNoXpza1H+oHR21JzgsUVbWFx+QJelVko5jjOWmAgZVAgpaVC9CQB/wPBu5UEaWgI8uqiSdK+b4oKBzJs7E7dLkttWpZRKEGf1CFxuGFIENVaPoLSimn1HrfvYDFDv81O2u5bSiuokNlIppRLLWYEArIRxcGho495j+FoCEU83+Pxs2nssGS1TSqmkcF4gyB0Hx6qg8RgT87JI97ojnk73upmQl5WkximlVOI5LxDkjLe+11Qwa2wuxQUDCaUDMoI5glljc5PXPqWUSjDnBYLQFNKactwuYd7cmZw/ZghpHheP31ysiWKllOM4LxAMLISUdKguB8DtEi4bP5TG5gAT8wdoEFBKOY7zAoHLBTljWwMB0JoTKN+nSWKllPM4LxAA5I5vnUIKMG5YfwCdLaSUciRnBoKccXB8HzTUAtA/zcPI7AzK9x1PcsOUUirxnBkIckMzh9p6BeOH99ehIaWUIzkzEOQEZw6F5wmGD2D7oTrqfS1JapRSSiWHMwPBgAJrx7J2PQJjYPN+HR5SSjmLMwNB68yhTa1FoZlDmjBWSjmNMwMBWHmC8OWoB6aTlZaieQKllOM4NxDkjIO6aqg/DFi7lY0bnsUmDQRKKYdxbiBo3aQmPGGcRcX+4wR0cxqllIM4OBC0rTkUMmF4FvU+Pzt1M3ullIM4NxBk5UNqVkSeQBPGSikncm4gELFmDoVNIR2T2w+3SzRhrJRyFOcGArASxmFTSNM8bsbk9NOEsVLKUZwdCHLHQ/0hOFHTWqRLTSilnMbZgSAnSsI4L4t9Rxs5UudLUqOUUiqxnB0IQovPVYcvNaF7EyilnMXZgaD/cEgbENEjCAUCzRMopZzC2YFAxNrMPqxHMKRfKrn9UzUQKKUcw9mBACDnLNj3EZQ+BBVvQcDPhLws3aRGKeUYKcluQFIF/LDjX9BcB6U/BW8G5JcwYdhP+dfWg/haAnhTNFYqpfo2Z1/lKhfCsT3BBwZ8dbBnNRdJGc1+w9bqE0ltnlJKJYKzA8H+ddDSFFnmq2dMYDugCWOllDM4OxAMm2INB4XzZjDwjOmkeVw6hVQp5QgnDQQi8lkR6R/8+fsi8r8iMs3+piVA0WzILwFxW4+9mZBfgvusyxk7LEsDgVLKEeLpEfzAGHNcRC4ALgOeA56yt1kJ4nLDba9B8Resx1c9Yj12uRk3rB8fVdXy2KItLC4/gF/3KFBK9VHxBAJ/8PvVwDPGmDcAr31NSjCXG4o/b/2cPgBcbvwBw6rtR6hr8vPookrufnkttz23QoOBUqpPiicQ7BGR3wCfAxaISGqcr+s9hk8BccGeNQCUVlSzt7YBAAPU+/yU7a6ltKI6iY1USil7xHNBvwn4J3CFMaYWyAbus7VViebNtBag22sFgo17j9HUEog4pMHn1w1rlFJ9UjyBYDjwhjGmUkRmAZ8FVtraqmTImwZ714IxTMzLIt3rjng63etu3cFMKaX6kngCwV8Av4iMAZ4BCoCX4nlzEZkjIhUislVE7o/y/NdEZL2IlInIuyIyoUut7075U629CWp3MWtsLsUFA0lxCQAZXjfFBQOZNTY3ac1TSim7xBMIAsaYFuB64AljzH1YvYROiYgbeBK4EpgA3BLlQv+SMWayMaYYeBh4pEut7055U63ve9fgdgnz5s7kzk+eAcC3Liti3tyZuIOBQSml+pJ4AkGziNwCfBH4R7DME8frZgBbjTHbjDE+YD5wbfgBxpjwQfdMrNxscgydBC5Pa8LY7RK+/MnRABiDBgGlVJ8VTyC4A/gE8BNjzHYRGQ3Mi+N1+cDusMdVwbIIIvINEfkYq0fwzTje1x4pqTBskpUnCBrSL5UzczJZuf1w0pqllFJ2O2kgMMZsAu4F1ovIJKDKGPNQdzXAGPOkMeZM4LvA96MdIyJ3ishqEVldU1MT7ZDukTfNWpI60DZjaMbowazccVjvIVBK9VnxLDExC6jEGu//H2CLiFwYx3vvwUosh4wIlsUyH/hMtCeMMc8YY0qMMSU5OTlxVH2K8qdB0zE4tLW1aObobI43tlCxX/cnUEr1TfEMDf0SuNwYc5Ex5kLgCuBXcbxuFVAkIqNFxAvcDLwefoCIFIU9vBor4CRPWMI4ZMbobABWbj+UjBYppZTt4gkEHmNMReiBMWYLcSSLgzON7sK6Ga0ceMUYs1FEfiQi1wQPu0tENopIGfBt4EtdPoPuNGQseDJaE8YAeQPTGTEonZU7NE+glOqb4tmhbLWIPAu8GHz8BWB1PG9ujFkALGhX9mDYz/fE2c7EcKfA8LMjEsZg9QqWbanBGIOIzh5SSvUt8fQIvg5swprR883gz1+zs1FJlTfN2rDG39xaNHN0NgdP+Nh2sC6JDVNKKXvEM2uoyRjziDHm+uDXr4AlCWhbcuRNhZZGqC5vLZoxejCATiNVSvVJp7qK6MhubUVPkh/ccycsYVw4OIOc/qkaCJRSfdKpBoK+O6k++wxIGxCRMBYRZozO1kCglOqTYiaLReT6WE8B6fY0pwcQsYaH2iWMZ47O5o11+6g6Us+IQRkxXqyUUr1PZ7OGPt3Jc//o5LneL28avPc4NDeCJw0Iv5/gsAYCpVSfEjMQGGPuSGRDepS8qRBogf3roeAcAM7K7c+AdA8rtx/m+mkjktxApZTqPn1ry8nuEiVh7HIJ5xRqnkAp1fdoIIgmKx8yc6PmCbYdrKP6eGOSGqaUUt1PA0E0IlavIGzmELTlCVZtP5KMVimllC3iWX00Q0R+ICK/DT4uEpFP2d+0JBteDAcrYPH/g4q3IOBnYl4WGV63LkCnlOpT4llr6AXgQ6zNacBaSvrP9OWZQwE/bA6e3vJfgjcD8ktIue01po8axArNEyil+pB4hobONMY8DDQDGGPqse4l6LsqF8LhbcEHBnx1sGc1VC6kZNQgNu8/zsNvbWZx+QHdsEYp1evF0yPwiUg6wbuJReRMoMnWViXb/nXQ3BBZ5qsnsG8dCzdlAvBU6ceke90UFwzUje2VUr1aPD2C/wTeAgpE5I/AYuA7trYq2YZNsYaDwnkzWOcf2boCqQHqfX7KdtdSWlGd+DYqpVQ3iWf10YXA9cDtwMtAiTGm1N5mJVnRbMgvgZTgShruVMgvYbkppsHnjzi0wedn095jSWikUkp1j3hmDV0HtBhj3jDG/ANoEZGoewv3GS433PYafPYFSB0AQyfBba8xIX8Q6V53xKHpXjcT8rKS1FCllDp9cQ0NGWOOhh4YY2qxhov6Npcbxl4JZ98M1RuhpZFZY3MpLhhIRjAYuASKCwYya2xukhurlFKnLp5AEO2YeJLMfcO4q6yNaj5+B7dLmDd3Jk/cMpULi4YQMPC9q8drolgp1avFEwhWi8gjInJm8OsRrPsKnGHU+db+BJutrZfdLuHS8UN57OappKa4ePGDXUluoFJKnZ54AsHdgA/4U/CrCfiGnY3qUdweKLoCtrwF/pbW4kGZXj5TnM9f1+7haH1zJ2+glFI9WzyzhuqMMfcbY0qCXw8YY5y1i/u4q6DhMOxeEVH8pfMKaWj288rq3UlqmFJKnb6YgUBEHg1+/7uIvN7+K3FN7AHGXAZuL1QsiCiekJfFjMJs/vDBDr3DWCnVa3WW9J0X/P6LRDSkR0vtD6MvhM1vwOU/tlYnDfrSeYV846U1lFZUc+n4oUlspFJKnZqYPQJjzIfB70uBTcAmY8zS0FeiGthjjL0KjmyHms0RxZdPHMqwrDR+996O5LRLKaVOU6c5AhH5LxE5CFQAW0SkRkQeTEzTepixV1nfN78RUexxu7j13JEsrzzIxzUnktAwpZQ6PZ3lCL4NnA+cY4zJNsYMAmYC54vIvyWqgT1G1nBrU/t2eQKAm2eMxOt28QftFSileqHOegS3AbcYY7aHCowx24BbgS/a3bAeadxVsOdDOLYvonhIv1SunjyM+at28/N/6vLUSqnepbNA4DHGHGxfaIypATz2NakHG3u19b1dr8AfMHxcU0dTS4Anl3zM3S+v5bbnVmgwUEr1Cp0FAt8pPtd35Y6HQYUdAkFpRTVbw/IDujy1Uqo36SwQnC0ix6J8HQcmJ6qBPYoInHUlbCuN2Mt4495jujy1UqrXinkfgTHGHes5xwr4Ydd7EGiJ2Mt4YsnTpHvd1IcFgzRdnlop1UvEs9aQCqlcCAe3Bh+07WU8y/1R6/LUoVvNBmd6dXlqpVSv4JzlpLvD/nXQXB9Z5qvHfWAD8+beS2lFNZv2HuPdrQdZu+sI1ccbGT4gPTltVUqpOGmPoCui7WXsyYBhk1uXp7770iJ+8dmzAeGXb29JSjOVUqorNBB0RWgvY28mhAaBBuRZ5WEKsjO44/xC/rKmShPGSqkeTwNBV4T2Mr7hebj4PyBnHNQdhqbjHQ79vxePYUC6h5++WZ6EhiqlVPw0EHSVyw1j58BF34HrfmPtU7Ds5x0OG5Du4e5LilheeZClW2qS0FCllIqPrYFAROaISIWIbBWR+6M8/20R2SQi60RksYiMsrM93S6vGKbdBiuehpqO+YDbzh3FyOx0/uN/1/Pooi269IRSqkeyLRCIiBt4ErgSmADcIiIT2h22FigxxkwBXgUetqs9trnkQSth/M//6PCU2yWke1LYU9vAo4sqdekJpVSPZGePYAaw1RizzRjjA+YD14YfYIxZYowJzcf8ABhhY3vs0S8HLvoubF0IS34KSx9uveO4tKKa3Ufappvq0hNKqZ7IzvsI8oHwzXyrsJaxjmUu8KaN7bFPyVx458ew9CHrcfCO4035D8dcekJ3M1NK9RQ9IlksIrcCJUDHrKv1/J0islpEVtfU9MDE6/algGn7Ct5x/EkpI90buVKHx+3SpSeUUj2KnYFgD1AQ9nhEsCyCiFwGfA+4xhjTFO2NjDHPGGNKjDElOTk5tjT2tOxfBy3tmu6rZ4p7V8TSEy6BlkCAguyMqG+jlFLJYGcgWAUUichoEfECNwOvhx8gIlOB32AFgd47cB7tjmNvBq7hU5g3dyZP3DKVb88+i4dvOJustBS+Nb+MphZ/9PdSSqkEsy0QGGNagLuAfwLlwCvGmI0i8iMRuSZ42M+BfsCfRaRMRF6P8XY9W8Qdx0GDCqFodsTSEzeWjOAXny1m075jPPRmRdKaq5RS4WxddM4YswBY0K7swbCfL7Oz/oQJ3XFcuRD2lcHaP0L9EWuButT+EYdeNmEot59XyPP/2s4FRYO5ZJwmjZVSySXG9K457SUlJWb16tXJbkbndq+C52bDzK/ClQ91eLqx2c91//Me+4828P2rJ7CntoGJeVnMGpuL2yX4A4bSimo27j0WUa6UUqdKRD40xpREfU4DgU3e+HdY9Rz8n8WQP73D0xX7j3PlY8sAMAbSvW6KCwbyuztmcPsLKynbXUuDz99aPm/uTA0GSqlT1lkg6BHTR/ukSx+EfkPh7/eAv6XD01VH6klxuQgYa9Jpvc/PB9sO8aknlrNqx2Hqff7Wcr0JTSllJw0EdkkbAFc9DPvXW8Eg7I5jgI17j9HsD0S8JGBg56F6mv2RvTTd/1gpZSfdocxOY6+G9MFQ9iIgrXccc9trTMzL6rDPcYbXzVcuGM2z726P3P/Yo/sfK6Xsoz0CO21dBC0NwQdtdxxTuZBZY3MjbjbLCOYC7rqkqMP+xwFjODOnX5JOQinV12mPwE7710FzQ2SZrw42/Q130eXMu6OE9UtfpXHXWtJGTmXyRZfhTnExb+7M1v2P07xuHl+0hVt++wF/+PIMdh2u19lESqlupbOG7FTxFvzly9bFv72sEdb9B3U1VrAIGzbCFbk+0aa9x7j12Q843tSC2yU0NQd0NpFSqkt01lCytN/j2JsJhZ+EG56FjMFQu9O66Sw0bFS10ropLeC3gkgwwTxhWCbfvvwsmv2GxuaAziZSSnUrHRqyU/gdx/vXw7DJVnBwueHwdmvoiLAeWXMDvPZ1SM2EuoPQ0tjaUziS/zASebQuaa2U6hYaCOwW2uN47JzI8tBCdeHDRm4vpPWD2l1tZaElrUeU8ZR3YMRsIpfAyM5WMg34g0FonVVfKAgppVQYDQTJEho22rMafPVtOYJR50Hpz4j47O+rY4prB8UFs1rvOE5xCy1+w38vKGdIv1QaW/yRSWQCmHnX4d+9CldLA4GUdNwF5yBRchBKKWfTQJAssYaNKhd27CkArnXzmXfD5ayvqG2dZSRjZnPPK+v4wnMr8AQDQyiJ/JuZB0nZvoJ0Gq3Xt9TTuGMFni1v4x53ZTLOWCnVQ2kgSKZow0bRegoDR8HxatzPXkyxywOBFtiXAVUl3Hf5k3zzT+tb70au9/l57+ND/HXnC9zqboSwCUXeQBPbN3zAmRoIlFJhNBD0NLF6Chv+F/76NQg0W8f56mDXB7i8f4PAKC5xlTFRdlBlhvAJVzk3piyNzCxjPdzoy+XMhJ+UUqon00DQE0XrKRzZ3rpOUSt/E1dUfI81qRmk4cNDS+vMojXDPofZt44JZhtp+GgmBS/NjKj8I3sP3kLekOxEnpFSqgfTQNBbRJtllJIGw4rpX7UCV9jH/yZSOfuiz3D78i+RVVXKGP92trpHc0a/Zv697lHef/J69t/2J440oXcpK6U0EPQaMWYZuUadh6laEXFoKj6keiN/+Mq9lFaMYdPeY9wYvNjXLB3O+Uu/w5svfIHXuZCiwE5edZ/B8yNm8YevnKfBQCkH0kDQW3Qyy0ja9RTEmwHDJrfulxx+w9nQi7/KuoM1XLnx51xmPsTlMjTiZd2eBZSW/5lLJ+Z1T3tP5R4Gve9BqaTQQNCbxDvLKL/EKo9hh8ljnEnBK9aGOZk0UWy2MH/FX2k56/+wYdlfaNi1lvSRU5l80Y24U7r4ZxLww7zrOraps3sYTuU1SqluoYGgt+tsGYsYJrp24CYy8ZwuPq7Z8WP2/fhXnEUtqTTTuCOV8hVPMf47i7sWDCoXBi/owV5K2PLbHe6wPp3XKKW6hS461xeEegoX3Wd9P8kn6MJJn8DnSo0o8+FBvP0okGoyxIdbDJnSyBlN5axf+ir+lhbKFs/n/Re+S9ni+fhbgttvtlsgj4Afdr7XccVVX70VqGLZ91HXX9OZaO1SSkWlPQIHcp91OWmFM2kJW37CU3AOW/xjmbHzGcLzxek0MXT599jz7o84K3CQVHxtPYV738b98q3s5GsAABeKSURBVGfbhnNS0iC1v7VgXnsiMKgweoP8zbDzXx2KjSsFGTqx6yeow0xKdYkGAidyuZHbXiMlOJzkCg4npS35Mw0708gMLksB0Iwbr2liOAdb71LOpJHxTR/R9Ng00uv3ISb4abulAdPSgBTNwdQfwn9gI66WBozLgyvQjCz5CeQVw5CitrY0HoNXvgjbl3LAPYx+LUdIw0cAF55AM2bNPGTU+bDr/fiTyJULoWo1NHdhmKmriWpNbKs+RAOBU0VJPE++6EbKVzzF6KZy0vDRiJftqeM5NnQG5+6K7Cm4MPjrDkG7XINB8OdN50uV55Pla7uHYWhOLv/Z8DPk2Uvx3/AC63fV4N+2nPG1paTX76P8nJ9y04pCZrR8yATZySYzkqKUGu7fMg8eGQ+Yk27g02rLW21BIMRXD3vXtK3nFH4Bh671IEI9jqrV1n4S8fY4YgUPDUI9h0N/t7pDmYrgb2lh/dJXI2YNrV/6KkXL7iFT2noKdSaVVz3XcmPz38iUpojyb7V8k4X+qRHv63W7ePjSLK7d+G+YQxW0mBQ8WHmGj92j+fbAR1m3N/LiLcDLZ5Uyc9cz4UsmYTyZyI3Pd7yoD5sCS34MZX+MfnLuVEjLgqZj0OKzhrJyxsL4a2HZQ9b+D60NzoQbno/eg6h4C/58e9h+1IAnA258ofMeR3jw8KRb7f3M0/DXr1q5kPaBDk4/aKn4dXeA72E626FMewQqgjslheJLbwZubi2L1VM4WnIPZcs3Uuza2lq+NjCG8swZcKw54n19/gDferuWZalzeJjK1qmrAMP9exl64F3cMhV/2OcSA5TvP84MItbOg+Y6Aquew7X8F1C9yboguj3BhLDAeXfDnjWwr8x6zpMBg8+AjCGwbUnb+7Q0WMfsK+v4iwglqtsHm1Hnwbu/igwCYF04Nr4WOxB89LKVBwm0tB2/+wN4orhdvXVWsn3Jf8Ou94JJ9LCL0oyvQtWq4M52nP7sql5yEet27c979EXwr8ci/418ddbv+mRDin0gMGsgUCflTklh/HcWd+gpHKg8xFfl+8xoDg3njGJlynS+XDKKZ9/dHrGJTprHxedKChiz+Q2kPrIXmoaPL51xjLrA4Nb9FtK8bob2T+WjhlE0mNSIXocx4Nr6dmQj/T4QN1z9Cyi5I+w/etiU2uW/hG2lRK7GJzD6Qti9IrJHgLFeX7EADlYEk+GpVuX+JnCltF0wQu+zbr714+U/hj0fWheZzBzrYvLRy2ACHX+5g4vgUGVkWaAZlv8issxXB9uXwY53wbSbARUKWl0NBN19EeuuoS+7tf/k73Jb/67tf69gPb/qtzDmMmvCQ/vzqFzYvYE5STQQqLhE6ynMGpvLlIJsPth9Dkt801r3QrjrkiJW7zzSelEPlT/46Yms73chjcv+EpGQbsRLv8JpzLt4JqUV1Wzae4wJwSUxfr14GGuX/Z2p7Xod7qETOPfgnyOHjEwACc1YinbzXbT1mrwZMONr1s+hC6In3dpTev+6yE/+LY2AwKX/aQWU8Ato3jQYeS4sfwQ2/MW6aPh9wReKdSHZ+a+2CwZYw08Tr4MPnoxskycDCmYEg1Y4A4PPhCM7wt47WF6zGZobrZ5RvBfjyoXWPtnNwXM8nYtYrKDyhVfhxRus8niGvk41cMQbhEaUwPJfRQbUQIsV2CdcD1v+GZlfEjdsXQRPfxJSvFbQDv2N9B8OLU2R/6Zw6oE5iTQQqFPmdgnz5na8eHdWHmuYafJFN0ZdEmPSiGy+1q7XURooZtbeMqZ4I2c4NUkqnqGTiHnJiHUX9tgrrK/2PYglP7F6Ee0F/LFv4svMgbfuh0DYp39POkz/snXxbl/3hfdZvZH25aEhoIiglQmX/hBWPh0ZtLyZsOFV6xNuWn84vK3jxfiPN4a9JgMGjLDeu7ndEJevzpqhFS2pftKZWu0+GW9fBj8bGRlMfXVWQPzHt61hr4Nb2sbj86bD9b+FP38R9q2zAq8nw7p4h3op0S740EkQut76vbQ0gLii98pC/6Y546D+UMf3KfkKvPFvUB82Lbq5Hg5/bA03ujxty8OHdBbQeloPCU0WqySIlpCOdeeyP2C47bkVEb2LSXlZFAxM5fqNd0fkJz4yRdTd9AqzJ+XjDxhKK6o7rq4abcgo1n/CirfgL1/ueDGOlUQG6wa2Jf9Nh+Gni78Hn/x29LqjtQliD9tAx+O3L4O/fh2O74tsjzsVzroCKt9uN/QFpA20LmgRvQtAPJA1FOoPxzdTy98C82+x6miv//CObeoqccP022Hm12DBvR1/J9O+BK9/IzKoidv6t2o6FvleLg+c/TnY8FrkJ//Qv2trAGz3b/TOj2HZz9s3DGY9YAW21ntpwoYP+w+HxqORv8P2QTmBCenOksUaCFSPF7qoh/cunlyylccWbuYiV1lETyE91cN1U/NZu6uW7QfrIoam5s2dCRA9QEQT8Hd93+dTCR6xdCVogRWAlj4U55sLzLrfSkyHX5RyJ1rDS+1v8PNkQrSZWp50eOsBqN7Y8RO3NxPO/UbHoS9vJpxxMWx+gw67J2WfaX3S7qzd7V8TS2Yu1FVHOe92F+94Lsad/bu2Dx6jzrM2kdr8RuR7uL3W8OGuDyKDb6zfbfgHhW7I5eisIdWrRRsympiXRarXwzu+abzDNAC8KS7GDu3Pn1btbt26E6ztO1ftOMyvFlXw3tZDbN5/PK4AAS6+2PTdtvshAqM51jSLP+Dq+vBTJ4sAxhQtz9GZvGnWxSki35AOU26Gj+ZHDtF4M2B4sTU0FS2pvvM9Ii64zXWw4DvgcsHx/VbvQlzWOHtWAdz4e/jw+fiHvoq/YM3gan9hnXRD9MBx+U+s+0O2vNXxvIdOsRL6/qbI10y/Pcp7ZcDws+HCe7sWZDv7d4327zS8GDYviPwd+n1Wz6295jr4+z3W77P+kHVcSqo1fDdmtjXktufDtveyISGtgUD1SrPG5lJcMLBDQnre3Jk8umgLT7yzNeL4Zr/h1+9EftIMBYiH39rMyu2HqThgBYg0j4vCwZlMzM9ixY6jtASKgWLwQ0bVcUorqpk1Njd6z+IUFgHsNrEuVlc+bOUN4r2IRUuquzzQUg91NW1lxm+VX/ETmHgtTPh09POO9vuA6G2NFTimfdEaatmxvGOQmPVAZN7kZO8V67w709V/12i/Q08mzPwqrPhN5LCUy2P1wo7ubitraYRDW6F2t3XvS/teUDcnpHVoSPVa0YaM3C5hcfkB7n55bcT01XSPm5LCQSyvjLIOUhcVjxiAiLQGjvAglPSNfWINJ3VlmCnWUMSo86D0Z0TNf1x0n/1t7WyIBE7/vLtTZ7OoouUIYv5u/8MKKt0w3Kg5AuUo0RLMxQUDueP8Qu6ZXxYRIDK8bmYUZlO6pSbiPQS4atJwlmypjjje7RKMMQTa/bfJ8Lp54papXDp+aOxEdSfttfP4UxLtAlq5sPvyH93Zrp5641ZXAl1nv9ui2bbnCDQQqD4pWm8B6FKAeOxzxbzw3o4Ox0/OH8Bvlm3rUOeY3ExumDaCBev38XFNfInqWG2K1buIFeQS0hvpI3fR9kgn+912QwDUQKBUUFcCRPjFO/z40orqDkNPbpeQneGl5kRThzpTXMLnZ45k7a5atlafoLHZT6rHxRlDMpkxejB/XLEzIrkd6l1Ey0NEq/t0eiNd1ps+kfc2Nv9uNRAodRKx8g2xjo0VOH7+z838Zum2eCc4xnTpuByON7WwYc+x1jrGD8siM83Nsi0d8xxFuf24blo+b6zbF3XabNJzFyrpkhYIRGQO8BjgBp41xvys3fMXAo8CU4CbjTGvnuw9NRConqArieoMr5vzzhzM4vLq9qlALpuQy7+2Hoo4/mQz5ds/73YJ2Zleao537I101rvQ4OAsSbmPQETcwJPAbKAKWCUirxtjNoUdtgu4HbjXrnYoZYdo9zZA7GmtnzungPc+jrzgp3vd3DS9gLomf4fjCwdn8tLKXR3qveP8UVTsPxG1N/KLf1bw9NKPI4JEvc/PY4u28NiiSrbWnNCegorKzvsIZgBbjTHbAERkPnAt0BoIjDE7gs/FWABEqd4l1jpLQNQAccn4oVwyfmjUPMRfy/Z06FlcMCaH7189MWpvpKRwEOnvuzvkLjbsPRYxy6neZwWeTu+HUI5i29CQiNwIzDHGfCX4+DZgpjHmrijH/g74R6yhIRG5E7gTYOTIkdN37txpS5uVslN35SG6+pqzRwzkqaUdl22YOLw/LQZ2H67XnoID9PolJowxzwDPgJUjSHJzlDolsYaTYh0bawXXrr6mtKKajCg9hcoDJ/AFIpfiCPUU4mmj6jvsDAR7gIKwxyOCZUqpOHQlcHT2mlh5i5JRg3jina0dcgprdtbGHDJKyM1sKuHsDASrgCIRGY0VAG4GPm9jfUqpKDrrKaR7I3sKAC+8t403N+xj/7HGiMDxuztmcPsLK2MOV2mQ6L3snj56Fdb0UDfwvDHmJyLyI2C1MeZ1ETkHeA0YBDQC+40xEzt7T50+qlT3iJZTKMrtR2Ozn4oDJyKO9aa4uOisHJZW1ODzt83tSPO4+NG1k/j0lDzm/n5Vcu54VnHRG8qUUlFFS2D/+p1KfrWo8uQvPol0j5tffz72PQyxehDas7BHr08WK6XsEXV70PwBZLQbMkrzuLhp+gj+/GEVDc1tPYLUFBc3n1PAlgPHeX/b4Yj3bmj2851XP8Kb4uZwnQ9fS4A0j9VT+P2Xow8znWz4SdnDlewGKKV6llByOcPrRrDuX5g2chDf/9REpo4cFFE+fdQgHvz0RL7yyTPI8Eaui+NxC+meFPYdbaSpJYDBCg7vbzvEuB+82XqDncFKUq/Ydohrf/0uK7cfjigPzWQCqwezuPwAjy+uZHH5Afztl4FVp0SHhpRSHcS656Gz8mj3MMwYnc1jiyo7LJmRPzCNPbWNHer1ul0ROYiQM3IyufmcAv6xbh9bqzveIQ1d2IK0m/WWoSzNESilbBctSMRaLfUrF4zm2Xe3x1WeElxLqTrKWkqpKS4euels/rhiV6erx9q5N0TSlgXvIs0RKKVs15V7GO66pIjVO4/EXT5v7kweenMzzyyP3AeiqSXAXS+tRYTWZTTqfX7W7q7lnfIDUfeTONW9IaIFidKKasp217YGrt66fIf2CJRStjqVYaZ4V3ZNTXExMjuDyuoTHepNTXHR7A9ErLOUmuLigavGsWD9fjbsOdp6wR87rD8Xn5XDr5d83GF67OM3W3s9tA8SowZnWGs57TnWoe5LxuZwuL6ZLT1oO1MdGlJK9Xpd2YLU4xbyBqSz83D9adeb4hJGDc5g56F6Wtolp1Ncggm27WROtiS43bkGHRpSSvV6XV3ZNVqASE1xMTl/AKt3Hunw/uefOZg1u45ETI/1pri4sCiH8n3HOgQBAb4+60w+jDKUNW5Yf57/146I4+t9fn61sIJHFm7psHlQsqfNaiBQSvUasdZf6mqA2BRlj+rbzyvEQIfjf3Pb9KhJ79Dz37rsrKhJ8vmrdndY6G/z/hMRASU0bfaSX5Sy92hDRJ7jw51HeGfzAWZPGGZ/b0GHhpRSfVV37FHd2fTYWJ/YYx0/beQgfr1ka4fj+6elcLyxpUN5htfNdVPzKdtde9pbkGqOQCmlwnRlb4hTfc3pTqdNTXExKT+LdVVHafZHXqdD+YaurEyrOQKllArTXUt8d/X4rk6nnTd3Jo8u2sIT70T2Ihp8fjbtPdZt+0ZoIFBKqQTpbMOhWOWh5T7a5ycm5GV1W7s0ECilVALF6lnEKo/ViwjlO7qDBgKllOrBTmXb0q7SQKCUUj3cqeQ0ukKXoVZKKYfTQKCUUg6ngUAppRxOA4FSSjmcBgKllHK4XrfEhIjUADtPctgQ4GACmqN1a91at/Pq7611jzLG5ER7otcFgniIyOpYa2po3Vq31t276052/X2xbh0aUkoph9NAoJRSDtdXA8EzWrfWrXX32bqTXX+fq7tP5giUUkrFr6/2CJRSSsVJA4FSSjlcnwsEIjJHRCpEZKuI3J/guneIyHoRKRMRW/fTFJHnRaRaRDaElWWLyEIRqQx+H5TAuv9LRPYEz71MRK6yqe4CEVkiIptEZKOI3BMst/3cO6nb9nMXkTQRWSkiHwXr/mGwfLSIrAj+vf9JRLwJrPt3IrI97LyLu7vusDa4RWStiPwj+Nj28+6k7oScd7TriW1/58aYPvMFuIGPgTMAL/ARMCGB9e8AhiSorguBacCGsLKHgfuDP98PPJTAuv8LuDcB5z0cmBb8uT+wBZiQiHPvpG7bzx0QoF/wZw+wAjgXeAW4OVj+NPD1BNb9O+BGu//Ng/V+G3gJ+Efwse3n3UndCTnvaNcTu/7O+1qPYAaw1RizzRjjA+YD1ya5TbYwxiwDDrcrvhb4ffDn3wOfSWDdCWGM2WeMWRP8+ThQDuSTgHPvpG7bGcuJ4ENP8MsAlwCvBsvtOu9YdSeEiIwArgaeDT4WEnDe0eruAWz5O+9rgSAf2B32uIoE/UcNMsDbIvKhiNyZwHpDhhpj9gV/3g/Ys4tFbHeJyLrg0JEtw1LhRKQQmIr1CTWh596ubkjAuQeHKMqAamAhVu+31hjTEjzEtr/39nUbY0Ln/ZPgef9KRFLtqBt4FPgOEAg+HkyCzjtK3SGJOO9o1xNb/s77WiBItguMMdOAK4FviMiFyWqIsfqOiZwb/BRwJlAM7AN+aWdlItIP+AvwLWPMsfDn7D73KHUn5NyNMX5jTDEwAqv3O86OeuKpW0QmAQ8E23AOkA18t7vrFZFPAdXGmA+7+71Po27bzzuo0+tJd/6d97VAsAcoCHs8IliWEMaYPcHv1cBrWP9ZE+mAiAwHCH6vTlTFxpgDwYtFAPgtNp67iHiwLsR/NMb8b7A4Iecere5EnnuwvlpgCfAJYKCIhLactf3vPazuOcGhMmOMaQJewJ7zPh+4RkR2YA31XgI8RmLOu0PdIvJigs471vXElr/zvhYIVgFFwRkFXuBm4PVEVCwimSLSP/QzcDmwofNXdbvXgS8Ff/4S8LdEVRz64wy6DpvOPTg+/BxQbox5JOwp2889Vt2JOHcRyRGRgcGf04HZWDmKJcCNwcPsOu9odW8OuyAJ1lh1t5+3MeYBY8wIY0wh1v/nd4wxXyAB5x2j7lsTcd6dXE/s+Tu3O/Od6C/gKqzZHB8D30tgvWdgzVL6CNhod93Ay1jDEM1YY6RzscZOFwOVwCIgO4F1zwPWA+uCf6zDbar7Aqzu8DqgLPh1VSLOvZO6bT93YAqwNljHBuDBsL+7lcBW4M9AagLrfid43huAFwnOLLLxb34WbTN3bD/vTuq2/bxjXU/s+jvXJSaUUsrh+trQkFJKqS7SQKCUUg6ngUAppRxOA4FSSjmcBgKllHI4DQRKBYmIP2xFyTLpxtVrRaRQwlZrVaonSTn5IUo5RoOxllFQylG0R6DUSQTXhX84uDb8ShEZEywvFJF3gouPLRaRkcHyoSLyWnD9/o9E5LzgW7lF5Ldiren/dvAuXUTkm2LtcbBOROYn6TSVg2kgUKpNeruhoc+FPXfUGDMZ+DXWipQATwC/N8ZMAf4IPB4sfxxYaow5G2vfho3B8iLgSWPMRKAWuCFYfj8wNfg+X7Pr5JSKRe8sVipIRE4YY/pFKd8BXGKM2RZcdG6/MWawiBzEWk6iOVi+zxgzRERqgBHGWpQs9B6FWMs3FwUffxfwGGN+LCJvASeAvwJ/NW1r/yuVENojUCo+JsbPXdEU9rOfthzd1cCTWL2HVWGraiqVEBoIlIrP58K+vx/8+T2sVSkBvgAsD/68GPg6tG7oMiDWm4qICygwxizBWtd+ANChV6KUnfSTh1Jt0oO7cIW8ZYwJTSEdJCLrsD7V3xIsuxt4QUTuA2qAO4Ll9wDPiMhcrE/+X8darTUaN/BiMFgI8Lix1vxXKmE0R6DUSQRzBCXGmIPJbotSdtChIaWUcjjtESillMNpj0AppRxOA4FSSjmcBgKllHI4DQRKKeVwGgiUUsrh/j+YG9kmIvEYxwAAAABJRU5ErkJggg==\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":279},"id":"Y80RZXzKRPpc","executionInfo":{"status":"ok","timestamp":1634530190434,"user_tz":-600,"elapsed":528,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"04523ef5-c82f-4b02-ec9a-79f64eb243a2"},"source":["plt.plot(X, TRAIN_DICE, marker='.', markersize=10, label='train')\n","plt.plot(X, TEST_DICE, marker='.', markersize=10, label='test')\n","plt.xlabel('Epochs')\n","plt.ylabel('Dice Coeffecient')\n","plt.xticks(X_tick)\n","plt.legend()\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxU5b348c93JplsEAJhCSEgoDHsoiLuFqW0qL1Wr9WqldZbW+xttfZna6u3VVvbe9va1mttrV7rWpdai0VppQpF4s4OIhBi2BMCCZCEELLM9vz+OJNktoQJ5MwkM9/365VXcp45M89zQni+5zyrGGNQSimVuhyJLoBSSqnE0kCglFIpTgOBUkqlOA0ESimV4jQQKKVUiktLdAF6aujQoWbs2LGJLoZSSvUra9euPWiMGRbttX4XCMaOHcuaNWsSXQyllOpXRGR3V69p05BSSqU4DQRKKZXiNBAopVSK63d9BNF4PB6qqqpobW1NdFFslZmZSVFREenp6YkuilIqiSRFIKiqqmLgwIGMHTsWEUl0cWxhjOHQoUNUVVUxbty4RBdHKZVEkqJpqLW1lfz8/KQNAgAiQn5+ftI/9SilIvn8hmVlNTy8rIJlZTX4/L27WGhSPBEASR0E2qXCNSqlQvn8hnlPrmRDZQMtbh9ZLifTR+fx3M1n43T0Tp2QFE8ESinVX3R1d99V+vKtNazbU0+z24cBmt0+NlQ2UFpe22tlSpongkRqaGjgxRdf5Jvf/GaP3nfZZZfx4osvkpeXZ1PJlFJ9SVd398/8x0xuenpVSHrx8AFcUDyUF1fuodXjD/mcFrePLdWNzJ44olfKlZKBwOc3lJbXsrm6kcmFucwqGX5Cj1gNDQ384Q9/iAgEXq+XtLSuf8WLFy8+7jyVUsfveOqAnr4n2vntd/ftFXuz28fKnXVc9cj7lNccwRt4Cmh2+/io6jAbqw5TUjCQo21e3L7OfoEsl5NJhbm98JuwpFwgsKO97a677mL79u1Mnz6d9PR0MjMzGTx4MFu3buWTTz7hyiuvpLKyktbWVm6//Xbmz58PdC6X0dTUxKWXXsoFF1zABx98wKhRo3jttdfIysrqzUtXKuVEq4yBLusAIGpl39N6I/z8zHQHwwZm0NTqjbi79/kNn9R2BoFg3/jUeL732QlR826/lt6QdIHgJ3/fzJbqxi5fr292s622ifbfebPbx4odh7j0t+8wONsV9T2TCnO5798md/mZv/jFL9i0aRMbNmygtLSUyy+/nE2bNnUM83zqqacYMmQILS0tnHXWWVx99dXk5+eHfEZFRQV//vOf+eMf/8i1117LK6+8wo033tjDq1cqNcVa4U8uzGXu5ALW7q6nzdt5V75uTz1/W1fFwvV7Q84/ZfgArplRxNLNNXy44xAmqN5Yv6ee0vJaZpUMj8j7X2Whd/4tHj976loYOSgTlzP07j7b5eRrF4zjifd20uz2haTPGDsEp0N47uazKS2vZUt1I5N6oRUjXNIFgmNpbvMRHnj9xkofnN07ecycOTNkrP/DDz/MwoULAaisrKSioiIiEIwbN47p06cDcOaZZ7Jr167eKYxSSSSWCj8z3cFJ+TlMGZXLqp11Ic0tq3fVs3pXfcTntnr83LlgY0has9vHxkDzTEaag/Dt3Vs8fr6/4COyXGkcbGqjzeMnzSlku5wcbfNF3OELcN1Zo1m5sy7i7v7WS4pZs7u+y7t+p0OYPXFEr/UJhEu6QNDdnTvAsrIabvvz+ojI+5PPT+61X3JOTk7Hz6WlpfzrX//iww8/JDs7m1mzZkWdC5CRkdHxs9PppKWlpVfKolSyiNY8M6FgINOKBoVU+C0eP1v3H2Hr/iNRP2fm2MFs3Hs4pIkmI81BScFANlYdjjj/axeM45zxQ/j2SxtC6o10p+BKd1JV3/l/1eMzNLZ6mTZqEFv3H+l46gCrXX/KqEHceklx1Lt7u+/6u5Nyw0dnlQxn+ug8sl1OBCsInGh728CBAzlyJPof3eHDhxk8eDDZ2dls3bqVFStWHHc+SiWTng6jfCvKMMp1exp45oPdUe++L58ykmyXMyQ92+Xk6xeO54wxg0PqgDNPGsxtl5wS9fxzT87n4gkjIuqNs8YO4YszRhNRVRu4ZMJwzjxpcNR6pv3u/rbZxcyeOKKjsu8qPR6S7ongWOyIvPn5+Zx//vlMmTKFrKwsRozofLKYO3cujz32GBMnTqSkpIRzzjmnNy5DqX6jJx224cMoM9IdjMjN5OShOby3/RBurz/i8y+ZMIwVO+pC7tazXE6uPL2Q+hZ3RB6XTBzBJRNHRNQBANNH50Vtnumq3igtryXL5YzIu7s7/75ITHjDVx83Y8YME74xTVlZGRMnTkxQieIrla5V9S/dVfjr9zTQ6vHhSnMwNj+Hc04ewosr9+AJ6jR1OqBwUBZ7G1oi+vFG5GZQMmIgK3bWhQSDbJeT335xOk9/sKvbUUCxVsbt19CT8+2e9dtbRGStMWZGtNdS7olAKXVsXY2Z7y49pEJMdzI6P5uC3Ew+3H6I9nq9zeunvOYI5TWRTak+P9Q3eyKCgAA3nn0S37z4lKiVbld3+O0VcU86WXvaKZvotv3eooFAKRWiJ7NfJxbkcufcEpZvrWX1rrqOO/xmj4/y/UfYVtNEeJuDAHMmjeDdioO0eEIHbXz1/LERwyjbJ08dq9K1c1RNd+we0RMPGgiUUiFKy2sjZr9+sP0QJT/6Z0il3uz2sXZPPdc9Hn0AhACXTyvgX2W1ERX7NWcW0dTm7XPDKFOVBgKlUlh4U8/UUYP47bKKiNmvAKPysqhqiBzWfPUZo5hWlMcv/7mVZk9ohf9v0wo52BR7h22yNLX0NxoIlEpR4U1AaU7B7zf4DaQ5JGRIZrbLyb+fMSrq7NfLpo5kVslw3ty8v1fa7/WuP/5sDQQiMhf4LeAEnjDG/CLs9ZOAp4BhQB1wozGmys4yKZWKonXylpbXsn5PQ0c7vcdncAj8+IpJvLm5pkfNNn21/V7FxrZAICJO4BFgDlAFrBaRRcaYLUGn/Rr4kzHmWRG5BPg5MM+uMtnleJehBnjooYeYP38+2dm9tL6FUmHC7/wz0h0MHZBBm9cX0lkLYAw0tni7rNS7q+z1Tr7/snNm8UxgmzFmhzHGDbwEfD7snEnAW4Gfl0d53R5+H5S/AW8/YH33+479nm60L0N9PB566CGam5tPKH+VnI5ne8Jo71m+tYZ1uztn5LZ6/FTVt5DmENKdoW3vwSN0+trsV2UfO5uGRgGVQcdVwNlh53wE/DtW89FVwEARyTfGHAo+SUTmA/MBxowZc2Kl8vvguatg7xpwN4MrG0bNgHkLweE89vujCF6Ges6cOQwfPpyXX36ZtrY2rrrqKn7yk59w9OhRrr32WqqqqvD5fNxzzz3U1NRQXV3NxRdfzNChQ1m+fPmJXZvq03qynv3xTFSKXPrYydABLg63eGgNm5FrLYA2JuoCaL25vLHqHxLdWfw94PcichPwDrAXiLg9N8Y8DjwO1szibj/xn3fB/o+7fr25Dg5uBRP4j+E+CrvehUcvgOwh0d9TMBUu/UX01whdhnrJkiUsWLCAVatWYYzhiiuu4J133uHAgQMUFhby+uuvA9YaRIMGDeLBBx9k+fLlDB06tNvLUv1Hb6yB//rGfazZVY/b1zmEc+3uepZu2c+cSQVRA8ryrTWs31NPS8fSxz4q61soysui1esPmZHbH5dBUPaxMxDsBUYHHRcF0joYY6qxnggQkQHA1caYBhvLBO6mziDQURC/ld5VIOiBJUuWsGTJEk4//XQAmpqaqKio4MILL+S73/0uP/jBD/jc5z7HhRdeeMJ5qb6nqzv5L597Ukglba1n38CyLft55sPdHee70hzkZDhpiDLDts3r59YX1zEoy8WRNi8erx9XmoPhAzM4ZfgAVuyo6/j8dgJcM6Ooyzt/bddXYG8gWA0Ui8g4rABwHXBD8AkiMhSoM8b4gbuxRhCdmG7u3AGrT+CVr1pPAu1cOXDZr6Bk7glnb4zh7rvv5pZbbol4bd26dSxevJgf/ehHzJ49m3vvvfeE81OJ0VUzT/hdebPbx4fbD4VsatKuxePjlufXAYQswdDm9XNaUR7lNY0RSyUXDx/ApqCNl9q8firrW/AZwxlj8li9qy5iS0O981fHYlsgMMZ4ReRW4E2s4aNPGWM2i8j9wBpjzCJgFvBzETFYTUPfsqs8HYrnWH0C4X0ExXOO+yODl6H+7Gc/yz333MOXvvQlBgwYwN69e0lPT8fr9TJkyBBuvPFG8vLyeOKJJ0Leq01DiXUi7feuNAcjBmYwflgOK3bWRUzGMkDxsBx2H2rpaOoBaz37sfk5VNQ2hZwvWCtq5mQ4I+7iZ44bwubqxpAZvgJcf9aYLtfi0Tt/dSy29hEYYxYDi8PS7g36eQGwwM4yRHA4rY7hiqVWX0LBVCsIHGdHMYQuQ33ppZdyww03cO655wIwYMAAnn/+ebZt28add96Jw+EgPT2dRx99FID58+czd+5cCgsLtbM4Dnqj/X5ZWU3IVodtXj976lvw+A0zThrMqp31IRV+tsvJ9z87IeoKmf9x/lhuD9vwpLu7+K6WPY5lLZ5e4fcF/u9shIJpJ/x/R/UNugx1P5NK13oielLhXz9zDHcu+CjkTj7L5eThsOWN20fh1De7aWoLHdMgwB1zTu3yrryrJZG7KlOsm6LHddljG0bcqSDdBdleCMDdLUOtgaCfSaVrPV5dVZbXzCji7r99HFLhC0SsjtkuI82Bx+eP6LQdMySLmsa2kG0Is11Ofnf96cyeOOK41rS38/zjEq3iqVgKC74KnrD+tauf6pX+teMuV18NQl2VNVo6WEG2ag14miE9C4rOsoJs+2snGIB1PwKVlLrrsI22euYH2w9FfIYBJhYMZMfBoyEVe7pTKMjNZHdd6GQ/Aa4+o+tROHB8a9r32vk9qXy6qkTC7/zTMyG3yDo/OAiA9fr+jccXCHpaqXf3RAJ9K0B0VdYvLYAXvhD6ux00BgYVwc53gcDfoKcZdr4NvzsTBgyHvevA77Fecx+13l+xtNcCcNIEAmMMIsk9CqK/Pb3ZKdpdf/HwAZx3Sj4vraqMunrmlMJcKmqbIu7k75hzaq+03yd8FE5Xlc91L8GL10D1OvC0HPuOsmIpVK22KiOw3nOoAlwDwJEGfm/QyQY2LYSSy2D4xOMPNseq1P1e+OD3sPuD0Apxz4fw1n/DzlKoLYu8vmifdbwBoieBK/x36D4KO9+BX50MbUfoeA71tMDBcqjbTkcQCCYOOFjRec3t3M1WH6cGgk6ZmZkcOnSI/Pz8pA0GxhgOHTpEZmZmoovSJ5SW17KhsqGjkm52+/io6jAf7z1MScFAjrZ5Q4ZRZruc3D67OGqF390etqcXDSS3qpRi3w4qnONpLJp17FE4iWq+qFgCe1aAr806dh+17ip/PjL0PPdRq5KqWNrZ5NNe1jHnwIo/dFZgHQTOu82qiDvuZrMhtxCO7IPHLoCBI6G1IbbK+JM3oWqVdW57mfasgLd/CZ8ssSZ9elrBmW41P7lbwNcaec0+N7z3m8jr2/0+/O0WqNkE9bvA23pifRo96R8xBtY9G+V3aKwngLbGsHSBSf8On7weOaz9s/9j/RzRJJdtDXTpJUkRCIqKiqiqquLAgQOJLoqtMjMzKSoqSnQx4i68CejC4mG8tqGaVreHSxwbmCy72GzGUuqfzjc+Vcx3P1PSO1sa+n08n/FLfK7VOLwt+NOycGasRFiINSI6ivYKo2p1bHff3elJQKnbAW/+V2cQCJY3Fhp2haZ5muHNH8JbP4W6ndaxM92aXOn3gjjBBHWIu7Jh5HS46M7IEXeth2HhLVYgauc+agWNv3/H+l3U77QqY0e6FUA8zZF3ub42KxCEpLmhxQOnzoWCKfDhI6EVbHo2jDkXtr9FSG+P3wub/hr6We3BZtPfYMq/9yxYRwuy0YJpzjD4eAHsfs+6mw+evOrKgTNughWPhFX42TD5Kjha0/Ww9qLeHfIeLik6i1X/4vN6+fjtBbTsWU/WmNOZ+qkv4EyLfk8Sbc18hwger5fn0n/OdMc2MnHTiouNFNN87V+ZPbmwdzpUty6GBTeBN6hyPVbn6MaXYeE3QivR9Bz4Qg87VGNtOhk+EfZvgvf+N1Dx+KzKM7i853wrsvJxpIPTFdnmL0749H2wbVnPOifffgCW/w9dd70H5+GAgtOgdkto4ErPgtHnwo7lYZ8jcPEP4cI7ov9Ozv4G/O1rkXfTxZ+FzQujlyljEHhbwOc59vXVbIYXvwiHKyNfGzoBRKBhd2eAEqc1QXXLa8fuI4j67xplWHvHTcHxD3nXzmIVd11ucu71UvbAbIrbtpJJG627Mihb+SgTv78sajAoLa9lw55DnONbx2Sndef/jn86v5pSxYxtFWRgVXo5tHG6bCPd+RFQ2HXTTSydqcMnWXe5S+8NDQIQWJvqvchK3RjY9Ar8/duhQQCsynbNUzD2Auu9sXTkbvxr5B3o7g/gn9+30g9tt+6wrcxh0lXwmZ/Ba9+MrGQuuhMqV0amjz4H3nmAkIrS+MHr7vlcm4Jp1ucGV8bpOXDKp6FsUVgeBkouhczcyDLN/DpUrYy8Yy6Y2vUcIIg+SXTqNVDxZuhnpWVaTzaVKzvL5D4Kez6AdX+CM77c+W+RfwpUroJVj1tByukKDbKONGjYA96wJqC0DMgd1fXvsLvfbcnc6DcMDmfXr/UCfSJQJyTW8frTigbxnU+fyubSl7lu933kSGcFe9RkUHHRw0y9+IsdnzVx5ECcIvx00cf8tOleTndsI4s2PKRxlEwGSQvOsPUJDSAXfg9m3xO9sOHNNulZ1n/EK/8PXv2G9Z/f00zHoNLc0XC0NrK5xZkBF/+XVVHUboFBo2Dza1alM+QUOLK3s+0bOpsIHOnW3aPPY1UWw0rg0/fDv+6DA1sDTSdp1nneyC0hu5SWCdc8a1USXd05RkuvWBp9uZXjGQ7a1RNMV3frVz8V1KQSVqkfz1DJaNfX1WeddB6U/oKoTwrpOVZlH9xsdcaX4ZJ74ZWbIz9rzLmB5qwoTzCfurNnv0ObJf08AmW/aM05OJx8+YkPyK0spdi/g3LHOHYNPo+Z44fx0upKPL7Iv63bna/wnbRXCO7T9xnh/xxf5MXML3LwSButXn/H+P7PZX7EA+YhsoMCh98IR4ZMZtCRisg79oxcq4Nt2nWwfVnnXfawCfDur2HDC5GLDkaTlgFXPw2r/i/0P/+IKZCRB9veJHQWggM+cz/MvCX6o/+4i6ymk/CnhWjECWMvtO5agwNCeg6MnwXli+mViqe3J4j1pDLuLo9eaAbp9rOiBcD0bOsJaWdp6N/HsYJsbwZTm2nTkDoh0ZpzNn74Bx4r+jnfrLzTaqd3WO306+sX8+UVd+OPsufRF6fmclNtGXI4NN1NOjvSxlNV31npGcCV5uB746vI2hFW2QsMnPZv1uN8cAUztMSqRBfdCm/cZXUYelsjO+3C5Z8Khz4JTfO6rbv9aI/xFUtgV2loEErPgPxiSHNFf8+7v4lSBrE6QPdvIqJ55qTzrLTwCvT0G63KKlrTSU/19nIrXTVf9DSP3mwGifZZXa03NubsQP9EEG9b5zDNnnxWL3bkxoMGAhUi2p3/x28voLitrKM5J4dWpng2cfv2b3Cqo4o08QfS2zjdsY07xu7iD9XFIePvi12HuKfmPnKO7GCvczR53lqysD4vXXycXVLEK2tC73PP869j1K7IpagkPRspnG7dAYdXMOKAN38EK37f+Qbjt9p3z/gKfPRi5N3b5Cujj+Rob5cO/8+//2MrUATztHZfYURrQ3dlw6mXWiN+wtNHngYXfS/29vDjrXhsbnuOWx490VUArFga/d+ouyBrw9pliaCBQHWIvPN3sfv9/2aQ8ZNN6F15Gj5OSduH0x96l5tNG9fKMtYVTiSjei3Fvh34nBnMd/6dHLcg8xZSMOb8jmAzaPhoJu54lqu33M5K1y3UeTOZLLsYJQe5xllK88AJDMwdZI0HD1R80l7xdVXBZA0iYvEIn8ca2hetEu2qM7WryrWrSr27CqOrO8fu8u6tO2wVqTfv7vtaoDsO2kegOmxY9hLF73w7pCMXrM5cF17SxReStn/SzRRufYos0znRx4/gwGDEiUEQE5iFmpaJzH8bhk+IzLilHvPi9Ujlh7hNGul4EYHDMogBd36MM3NAzyq+rvac6KqDsqvO1OOZFdvTDs2e5q3slcT/FtpZrCKENAGNPo0p44qo/uudjG7ZGtKR6zewYvTXyK1dw7i2so4x+zszJjLxe0tw/PkafJVBE66KZiCnzIa37rf+U7VLz4YvPN31XdOWRZi/3oQEdaaa9Bykp+PvIT6rZCZxhaGSk3YWqxDtTUAlbVuscfi7wPEejDBOfDhIC1rzpIUMssedxcSbfhl9Eti8haQFKkRHcMdoWJMRnpbu10Y5sBUJ60wVz3GupxKPdtskaA5Qqp0GghT08dsLmNi2mQzpHCvdatJZOOa/mFLzGuPD7vzbK/3ps6/D2nE0SE86RrtrQz+e93RHK2qlYqaBIBn0cJGzjLKFuAhd5yUdL2MdNUz6/rKYl3/o0vF0uiXJMDyl+iMNBP1JLBtaHKM9vHHzEk45uBQ/gjNoVE0rLrLGnN71nX9PHE/TTJIMw1OqP9JA0F9E6wAtOA1GnobZ9V5nJ6v7KKZqNRJl04rKDcsY+uqNbDeFuNNyOdm7LaIJqNccT9OMNucolRAaCPqLiqWBIBBoQ29fKGvPB5Hneprxr/sTZtzFfPzuQlr2rMftyOKMHY9SI/l4v7SQyePHnXgTkFIqKej//P6iekNoR2rAwYKLyNq3MmTsv98IzvLXafmfMUwwPlx4EKCNdNK/8ipTxhUDnHgTkFIqKWgg6IvC+wIGFsDGlyLPc+XwweArGLL3EKcHrcu/3n8Km/xjmZ/2OsFL8BsjHNixnlHjSuJ3LUqpPk8DQV8T3hfgSLOWxM3Kt9bJb9jd0UfQNuIMHt9XzBbP3cxybGCS7GaLOYmVzjO4f+gbmIbQZRZceGjZsx59ClBKBdNAkEjRRgGF9wX4PVYwuPSX+CZd1dGuX5N9Kj/dWkiTp5lxwway4vBZLHef0bEt4/hx59H67svk0Ln8Q/vIIKWUCqaBIFHC7/zTsyH/ZKvSD+8L8Pvw1+1k3tNr2FCZR7P7IgCyXcJr3zqf4hEDIzde98+gbNVjEctC9OrIIKVUUtBAkCgVSwNj/wOVvueo9WQgaVE3Dt/oG8OGPQ00e0I3Ntnb0MKEkbmR2zI60pjYG5PDlFJJT2sFu0Vr/qndYu2WFb5xOAIXfMfaSjFshu2bbVNo9uwOObvF7WNLdWPkvrwBvTI5TCmV9DQQ2Cm8+ceZbm2Q4m6ymoCi3PlTdJa1H27QDNvaERfy6qMrIj4+y+VkUmFuHC9IKZWMIvcTVL0npOPXWJtiu5vhzP+AO7bC2AusdfIR63v4hiSfupO9Iz7FtX9cRUOzm8mFuWS7nAiQHegUbt8sXimljpc+Edhp/0ar4g9hIHcUDBjW5do6Pr+htLyW97cd5NUN1bi9Pl74+jmcVpQX0SnsDJ4ooJRSx0EDgZ0KpgV2oPJ2pgUtrezDQan/dDZ7T2ayP5dZOMBvmPfkStbvqafFY63Pf1rRIE4rysPpkMhOYaWUOkEaCOyUMdAKAo5063vQ0sq+jgq/gVaPj3SnkD8ggyHZLrbsawzZxL2itonS8loNAEopWxwzEIjIb4CnjDGb41Ce5OF1w+t3QG4RfOZncGhbSPNPaVkNa3fX0+a17vrdPsO+w600u72Ebx56rNFBSil1ImJ5IigDHheRNOBp4M/GmMP2FisJfPBbOLAVrv9L1GWVV+2s6wgC7QS4uGQ4S7bU0OzuHE2ko4OUUnY65qghY8wTxpjzgS8DY4GNIvKiiFxsd+H6rUPb4e1fwaTPRw0Cfr/hvW0HI9KzXE4unzqS6aPzdHSQUipuYuojEBEnMCHwdRD4CLhDRG4xxuhspWDGwD++A2kZMPeXUU954r0dbK5uZPzQHPY3ttLi9nWsEXTJxBFcMnGEjg5SSsVNLH0E/wt8DngL+B9jzKrAS78UkXI7C9evtM8gXv887HwHLvsV5I6MOO2jygYeeKOcuZML+P0Np/P2JweiVvg6OkgpFS+xPBFsBH5kjIncFQVmdvdGEZkL/BZwAk8YY34R9voY4FkgL3DOXcaYxbEUvE9pn0FctdraN1gcUPZ3mHFzyJ67TW1evv3SeoYPzOAXV08lzenQCl8plXCxBIKG4PNEJA+YZYx5tbtO40Bz0iPAHKAKWC0ii4wxW4JO+xHwsjHmURGZBCzG6ofoX9pnEHsCk8eMH/auhYql+Io/S2l5LZurG/lg+0H2HGrmL7ecS162K7FlVkqpgFgCwX3GmIXtB8aYBhG5D3j1GO+bCWwzxuwAEJGXgM8DwYHAAO3DYQYB1bEWvE+JNoPY3Yx/30bmvZPHhsqGjlFAowdnceZJgxNQSKWUii6WtYainRNLABkFVAYdVwXSgv0YuFFEqrCeBm6L9kEiMl9E1ojImgMHDsSQdZwVTAUJ68xtXzo6KAgAHDrqprS8Ns4FVEqprsUSCNaIyIMicnLg60FgbS/lfz3wjDGmCLgMeE5EIspkjHncGDPDGDNj2LBhvZR1L2o9bDUHOTMIXkDuXTOdFnfo/gHtk8OUUqqviOXO/jbgHuAvgeOlwLdieN9eYHTQcVEgLdjNwFwAY8yHIpIJDAX6zy1zWxP868dQcBrMugtqNnfMIJ5UfpCMNAetQRPHdHKYUqqvOWYgCIwWuus4Pns1UCwi47ACwHXADWHn7AFmA8+IyEQgE+iDbT/deP8hOLIPrnkGxpwDEy7reOmi4mE4nYIE1pzL0slhSqk+KJZ5BKcC38MazdNxvjHmku7eZ4zxisitwJtYQ0OfMsZsFpH7gTXGmEXAd4E/isj/w+o4vskYE77UTt9VvwvefximXmMFgTCLN+3jaJuPm88fR152uk4OU0r1SbE0Df0VeAx4AvAd49wQgTkBi8PS7iMMslsAABqNSURBVA36eQtwfk8+s09Zco81T+DTP4l4qdXj44E3ypk0MpcfXj4Rh1b+Sqk+KpZA4DXGPGp7SfqL9hnEZYusr1l3w6DwwVDwpw93sbehhQe+ME2DgFKqT4slEPxdRL4JLATa2hONMXW2laqv6phBvCaw8bzArves9KAZxA3Nbn7/1jZmlQzj/FOGJq68SikVg1gCwVcC3+8MSjPA+N4vTh/XMYO4fbUNA9XrrPSgVUZ/99Y2mtq83H3pxMSUUymleiCWUUPj4lGQfqGLGcTs/7hjKYn3tx3k2Q938YUziygpGJiQYiqlVE/EMmooG7gDGGOMmS8ixUCJMeYftpeurymYBmmZ4G3pTHNl4xsxhXlPrgyZRbzzwFF8fqMjhJRSfV4sM4ufBtzAeYHjvcDPbCtRX1Y8Bwa0zwHonEFc6jstYimJzfsadSkJpVS/EEsgONkY8wDgATDGNGPtqph6HE5wDYRhE+DiH8LVT8G8hWzef1SXklBK9VuxdBa7RSQLq4MYETmZoNFDKaV+N9Rugjk/hfO/3ZE8uTCXzHQHLR5dSkIp1f/E8kRwH/AGMFpEXgCWAd+3tVR9Vfk/re8TLg9JnlUyvGN/Ad1nWCnV38QyamipiKwDzsGq5243xkTuvJ4Kyl+HoSWQf3JIcqvHx5EWD+eMG8L5pwzVpSSUUv1Kl4FARCYYY7aKyBmBpH2B72NEZIwxZp39xetDWuph1/shTULt/rauiia3jx9cOoHTx+imM0qp/qW7J4I7gPnAb6K8ZoBuF51LOhVLwfigJLRZyBjDsx/uZlrRIKaPzktQ4ZRS6vh1GQiMMfMD3y+OX3H6sK2vw4ARMOrMkOT3tx1iW20Tv7nmNCR8lzKllOoHjtlZLCLfCmxY3348OLD2UOrwtsG2f8Gpc8ER+it75oNd5Oe4+NxpIxNUOKWUOjGxjBr6ujGmof3AGFMPfN2+IvVBO98Bd1PEaKHKumaWba3h+pljyEhzdvFmpZTq22IJBE4JavMQESfgsq9IfdDW1yE9B8Z9KiT5+RW7cYjwpXPGJKhgSil14mKZUPYG8BcR+b/A8S2BtNTg91vzB06ZDemZHcktbh8vra5k7uQCRg7KSmABlVLqxMQSCH6AVfn/Z+B4KdZuZamhej007Y9oFnptw14Ot3j48rknJahgSinVO2KZUOYXkWeAt4wx5fYXqY8pfx3ECcWfAcDnNyzfWsOvl5RTlJfFmSfpvAGlVP8Wy6ihK4ANBJqDRGS6iCyyu2B9xtbFcNJ5kD0En98w78mV3Prieg42uak90saXn1qFz28SXUqllDpusa41NBNoADDGbABSY7Oauh1woAxKLgOgtLyWDZUNtHqtxeXcPj8bKht0uWmlVL8WSyDwGGMOh6Ul/y2w3wfvPmj97MoBv4/N1Y263LRSKunEEgg2i8gNWMNIi0Xkd8AHNpcrsdo3qd/wgnX85t3w3FVMLsghIz30V6bLTSul+rtYAsFtwGSsPQheBA4D37GzUAlXsRSqVoMJ7C/gPgp71zDL+REFudYQUl1uWimVLLpbffQ5Y8w8rJnFPwR+GL9iJdj+jeBpCU1zN+Os2cQpw2fR7PYx75yTdLlppVRS6G746JkiUgh8VUT+RNj2lMaYOltLlkgF08CZDj53Z5orG/+IKax5u57PTBrBbbOLE1c+pZTqRd0FgsewdiMbD6wlNBCYQHpyKp4DGbnQfMg6dmXDqBlU5J5LQ/P7zByXn9jyKaVUL+ouEPzdGPOwiDxqjPnPbs5LPg4npGXB6LPhlE9DwVQonsOqlZUAnD1uSIILqJRSvae7QLAAOBM4NU5l6TuOHoTGSjj763D+7R3JK3fWMXJQJkWDdW0hpVTy6C4QOETkv4BTReSO8BeNMQ/aV6wEq15vfS88oyPJGMPqXXWcMz5fN6BRSiWV7oaPXgf4sILFwChfyWvvOkBg5GkdSXvqmqlpbGOmNgsppZJMd1tVlgO/FJGNxph/xrFMiVe9DoYWQ2bnRLGVO61BUto/oJRKNrFMKFsnIk+KyD8BRGSSiNxsc7kSxxiraSioWQhg1c46huS4OHnYgAQVTCml7BFLIHgGeBMoDBx/QjLPLG6shqYaGBUZCGaOHaL9A0qppBNLIBhqjHkZ8AMYY7xYfQfJqXqd9T3oiWDf4Rb21DVr/4BSKinFEgiOikg+gRVHReQcrPWGktPedeBIg4IpHUmrAv0DGgiUUskolq0q7wAWASeLyPvAMOALtpYqkarXwfCJkN45V2DVzjoGZqQxcaSuMqqUSj6xbFW5TkQ+BZRgLTNRbozx2F6yRGjvKJ50ZUjyqp11zBg7WBeXU0olpVi2qkwHvgn8BPgxcEsg7ZhEZK6IlIvINhG5K8rr/ysiGwJfn4hIQw/L37vqdkDr4ZCO4kNNbVTUNun6QkqppBVL09CjQDrwh8DxvEDa17p7k4g4gUeAOUAVsFpEFhljtrSfY4z5f0Hn3wac3qPS97aOGcWdxVi9qx7Q/gGlVPKKJRCcZYw5Lej4LRH5KIb3zQS2GWN2AIjIS8DngS1dnH891v7IibN3HaRlwvBJHUmrdtaRme5g6qhBCSyYUkrZJ5ZRQz4RObn9QETGE9vw0VFAZdBxVSAtgoicBIwD3uri9fkiskZE1hw4cCCGrI9T9TprpVFnZ8vXql2HOGPMYFxpsfyqlFKq/4mldrsTWC4ipSLyNlZl/d1eLsd1wAJjTNQAY4x53BgzwxgzY9iwYb2cdYDfB/s+Cpk/0NjqYUt1ozYLKaWSWiyjhpaJSDHWqCGwRg21xfDZe4HRQcdFgbRorgO+FcNn2udAOXiaQzqK1+6ux2+0f0Apldy6fCIQkRtFZB6AMabNGLPRGLMRuFZEbojhs1cDxSIyTkRcWJX9oij5TAAGAx8e1xX0lo4ZxVZHsc9veHl1JQ6BhmYPPr9JYOGUUso+3TUN3QYsjJL+N2JoGgosRXEr1jpFZcDLxpjNInK/iFwRdOp1wEvGmMTWtHvXgWsg5Bfj8xvmPbmSNzfvx2/ge3/9iHlPrtRgoJRKSt01DaUbY5rCE40xR2OdR2CMWQwsDku7N+z4x7F8lu2q10PhdHA4KC2rYUNlA+31frPbx4bKBkrLa5k9cURiy6mUUr2suyeCLBHJCU8UkYGAy74iJYDXDTWbOpqFNlc30uIO7bducfvYUt2YiNIppZStugsETwILAkM7ARCRscBLgdeSR80m8Lk7OoonF+aS7gz91WS5nEwq1LWGlFLJp7sdyn4tIk3AOyLSvhtLE/ALY8yjcSldvIR1FM8qGU7+ABf7DrciWEFg+ug8ZpUMT1wZlVLKJt0OHzXGPAY8FmgOwhhzJC6lire96yFrCORZDz9Oh1CUl0W2y8mV00cxqTCXWSXDddE5pVRSimWJieQNAGBNJNv5DmTlwSdvQvEcjDjYWnOEz08v5LbZxYkuoVJK2SqmQJC0/D549go4vMc6fuWrMGoGVZe/wJFWL5NG6vpCSqnkl9oL6FQshb1rOo/dR2HvGg6s/wcAE0cOTFDBlFIqfmLZjyBbRO4RkT8GjotF5HP2Fy0O9m8Eb2tomruZ1soNOAQmFOgoIaVU8ovlieBpoA04N3C8F/iZbSWKp4Jp1v7EwVzZrG0rYuzQHLJczsSUSyml4iiWQHCyMeYBwANgjGnG2rKy/yueA64BIA5AwJUDo2awoHECk3R/YqVUioils9gtIlmAAQjsTRDL6qN9n8NpPRGMvQjGXgAFU2kcPYvd9y/j2pkaCJRSqSGWQHAf8AYwWkReAM4HbrKzUHFz9BA0H4TiT8N5twGwdWcdgD4RKKVSRiz7ESwVkXXAOVhNQrcbYw7aXrJ4OFBmfR82sSNpS/VhAF1OQimVMmIZNXQV4DXGvG6M+QfgFZEr7S9aHNQGAsHwCR1JZfuOMCTHxfCBGQkqlFJKxVcsncX3GWMOtx8YYxpI9CbzveXAVsjIhdzOrZS37Gtk0shcRJKjP1wppY4llkAQ7ZzkmJFcuxWGTYBApe/1+SmvOaITyZRSKSWWQLBGRB4UkZMDXw8Ca+0uWFwcKAtpFtpx8Chur1/7B5RSKSWWQHAb4Ab+EvhqI9EbzfeGpgPQfCiko7hsn7XxzEQdMaSUSiGxjBo6CtwVh7LEV+0W63vQE8GWfY24nA5OHjagizcppVTy6TIQiMhDxpjviMjfCUwmC2aMuSLK2/qPA1ut7yFDRxspHjEgYncypZRKZt09ETwX+P7reBQk7mrLIHMQDCzoSCrbd4RZJcMSWCillIq/7raqXBv4/raIDAv8fCBeBbPdga0wfFLHiKHaI60cbGrTGcVKqZTTbRuIiPxYRA4C5cAnInJARO6NT9FsZIz1RDAsdCIZaEexUir1dBkIROQOrHWFzjLGDDHGDAbOBs4Xkf8XrwLaoqkGWhtgeGj/AOgaQ0qp1NPdE8E84HpjzM72BGPMDuBG4Mt2F8xW7UtLhDwRNDIqL4tB2ekJKpRSSiVGd4EgPdricoF+gv5dW7aPGAp+ItjXqDOKlVIpqbtA4D7O1/q+2jLIGgI51gihVo+PHQeatFlIKZWSuhs+epqINEZJFyDTpvLER22Z9TQQGDFUvv8IfqMdxUqp1NTd8NHk3LDXGKtpaNq1HUntS0voGkNKqVSUelNoG6uhrTGko3jLvkZyXE5GD85OYMGUUioxUi8QtO9KFugo9vkNH24/yKCsdJaX1+LzR6ymoZRSSS31AkFt5xpDPr9h3pMrqag9SvXhVm7783rmPblSg4FSKqWkXiA4UGaNFsrJp7S8lvV76jteanb72FDZQGl5bQILqJRS8ZV6gaB9VzJgc3UjrR5/yMstbl/HLGOllEoFqRUI2kcMBfoHJhfmku4M3Zs4y+XU0UNKqZSSWoHgcCW4mzoCwayS4eQPyACsyRHZLifTR+cxq2R4AguplFLxlRyb0MeqNnQzGqdDmBy4+79h5hgmFeYyq2Q4Tod09QlKKZV0UisQdAwd7ZxDUFXfwsSRudw2uzhBhVJKqcSytWlIROaKSLmIbBORqPsei8i1IrJFRDaLyIt2lofarTCgALIGA2CMoaq+hTFDdCKZUip12fZEICJO4BFgDlAFrBaRRcaYLUHnFAN3A+cbY+pFxN7G+QNlIU8D9c0emtq8FA3OsjVbpZTqy+x8IpgJbDPG7DDGuIGXgM+HnfN14BFjTD2AMca+Afx+PxwoD9msvrKuGYDR+kSglEphdgaCUUBl0HFVIC3YqcCpIvK+iKwQkbm2lMTvg/XPgacZjM86BirrrUCgTUNKqVSW6M7iNKAYmAUUAe+IyFRjTEPwSSIyH5gPMGbMmJ7l4PfBc1dB5UrreN2frCeDeQuprGsB9IlAKZXa7Hwi2AuMDjouCqQFqwIWGWM8gS0xP8EKDCGMMY8bY2YYY2YMGzasZ6WoWAp714C31Tr2tlrHFUvZU9fM4Ox0BmQkOh4qpVTi2BkIVgPFIjJORFzAdcCisHNexXoaQESGYjUV7ejVUuzfCO7m0DR3M+z/mKr6Zm0WUkqlPNsCgTHGC9wKvAmUAS8bYzaLyP0ickXgtDeBQyKyBVgO3GmMOdSrBSmYBq6wyt6VDQVTqaxrpkgDgVIqxdnaJmKMWQwsDku7N+hnA9wR+LJH8RwYNcNqDnI3W0Fg1Ax8J3+avQ1LmDtlpG1ZK6VUf5D8jeMOJ8xbaPUV7P8YCqZC8Rz2N7rx+Iw2DSmlUl7yBwKwgkHJXOsroHMOgU4mU0qlttRafTTInvZAoPsUK6VSXMoGgqq6ZhwChXn6RKCUSm0pGwgq61sYOSgLV1rK/gqUUgpI4UCwp65ZF5tTSilSOBBU1ulkMqWUghQNBK0eH7VH2nSNIaWUIkUDQVW9Dh1VSql2KRkI2lcd1aYhpZRK1UBQr3MIlFKqXUoGgj2HmslIczBsYEaii6KUUgmXkoGgsr6Z0UOyEZFEF0UppRIuNQNBXQujdQ6BUkoBKRgIjDFU1jXr0FGllApIuUBwuMXDkTavdhQrpVRAygUC3bBeKaVCpV4g0MlkSikVIuUCQcc+BPpEoJRSQAoGgsq6ZvKy08nNTE90UZRSqk9IvUBQ36IdxUopFST1AkFds/YPKKVUkJQKBH6/YW99i/YPKKVUkJQKBDVHWnH7/No0pJRSQVIqEOw5pCOGlFIqXEoFgsp63YdAKaXCpVYgqGtGBArzMhNdFKWU6jNSLhAU5GaSkeZMdFGUUqrPSK1AUK+rjiqlVLjUCgR1OplMKaXCpUwgaPX4qDnSqpPJlFIqTEoEAp/fsGBtFcbAkVYvPr9JdJGUUqrPSEt0Aezm8xvmPbmStbvrAXhhxW7K9jXy3M1n43TonsVKKZX0TwSl5bVsqGygzesHoNXrZ0NlA6XltQkumVJK9Q1JHwg2VzfS4vaFpLW4fWypbkxQiZRSqm9J+kAwuTCXLFfovIEsl5NJhbkJKpFSSvUtSR8IZpUMZ/roPLJdTgTIdjmZPjqPWSXDE100pZTqE5K+s9jpEJ67+WxKy2vZUt3IpMJcZpUM145ipZQKSPpAAFYwmD1xBLMnjkh0UZRSqs+xtWlIROaKSLmIbBORu6K8fpOIHBCRDYGvr9lZHqWUUpFseyIQESfwCDAHqAJWi8giY8yWsFP/Yoy51a5yKKWU6p6dTwQzgW3GmB3GGDfwEvB5G/NTSil1HOwMBKOAyqDjqkBauKtFZKOILBCR0dE+SETmi8gaEVlz4MABO8qqlFIpK9HDR/8OjDXGTAOWAs9GO8kY87gxZoYxZsawYcPiWkCllEp2do4a2gsE3+EXBdI6GGMOBR0+ATxwrA9du3btQRHZfYzThgIHYyxnb9O8NW/NO7nz7695n9TVC3YGgtVAsYiMwwoA1wE3BJ8gIiONMfsCh1cAZcf6UGPMMR8JRGSNMWZGz4t84jRvzVvzTu78kzFv2wKBMcYrIrcCbwJO4CljzGYRuR9YY4xZBHxbRK4AvEAdcJNd5VFKKRWdrRPKjDGLgcVhafcG/Xw3cLedZVBKKdW9RHcW2+VxzVvz1ryTNu9E5590eYsxuluXUkqlsmR9IlBKKRUjDQRKKZXiki4QHGuhO5vz3iUiHwcW0Ftjc15PiUitiGwKShsiIktFpCLwfXAc8/6xiOwNWkDwMpvyHi0iy0Vki4hsFpHbA+m2X3s3edt+7SKSKSKrROSjQN4/CaSPE5GVgb/3v4iIK455PyMiO4Oue3pv5x1UBqeIrBeRfwSObb/ubvKOy3VHq09s+zs3xiTNF9Yw1e3AeMAFfARMimP+u4ChccrrIuAMYFNQ2gPAXYGf7wJ+Gce8fwx8Lw7XPRI4I/DzQOATYFI8rr2bvG2/dkCAAYGf04GVwDnAy8B1gfTHgP+MY97PAF+w+988kO8dwIvAPwLHtl93N3nH5bqj1Sd2/Z0n2xNByix0Z4x5B2vuRbDP07lMx7PAlXHMOy6MMfuMMesCPx/BmoQ4ijhcezd5285YmgKH6YEvA1wCLAik23XdXeUdFyJSBFyOtfoAIiLE4bqj5d0H2PJ3nmyBINaF7uxigCUislZE5scx33YjTOdM7f1AvHfiuTWwgOBTdjVLBRORscDpWHeocb32sLwhDtceaKLYANRirc21HWgwxngDp9j29x6etzGm/br/O3Dd/ysiGXbkDTwEfB/wB47zidN1R8m7XTyuO1p9YsvfebIFgkS7wBhzBnAp8C0RuShRBTHWs2M8xwY/CpwMTAf2Ab+xMzMRGQC8AnzHGNMY/Jrd1x4l77hcuzHGZ4yZjrVu10xggh35xJK3iEzBmgw6ATgLGAL8oLfzFZHPAbXGmLW9/dknkLft1x3QbX3Sm3/nyRYIjrnQnZ2MMXsD32uBhVj/WeOpRkRGgrWOE9bdW1wYY2oClYUf+CM2XruIpGNVxC8YY/4WSI7LtUfLO57XHsivAVgOnAvkiUj7CgG2/70H5T030FRmjDFtwNPYc93nA1eIyC6spt5LgN8Sn+uOyFtEno/TdXdVn9jyd55sgaBjobvAKILrgEXxyFhEckRkYPvPwGeATd2/q9ctAr4S+PkrwGvxyrj9jzPgKmy69kD78JNAmTHmwaCXbL/2rvKOx7WLyDARyQv8nIW1818ZVqX8hcBpdl13tLy3BlVIgtVW3evXbYy52xhTZIwZi/X/+S1jzJeIw3V3kfeN8bjubuoTe/7O7e75jvcXcBnWaI7twA/jmO94rFFKHwGb7c4b+DNWM4QHq430Zqy202VABfAvYEgc834O+BjYGPhjHWlT3hdgPQ5vBDYEvi6Lx7V3k7ft1w5MA9YH8tgE3Bv0d7cK2Ab8FciIY95vBa57E/A8gZFFNv7Nz6Jz5I7t191N3rZfd1f1iV1/57rEhFJKpbhkaxpSSinVQxoIlFIqxWkgUEqpFKeBQCmlUpwGAqWUSnEaCJQKEBFf0IqSG6QXV68VkbEStFqrUn2JrXsWK9XPtBhrGQWlUoo+ESh1DIF14R8IrA2/SkROCaSPFZG3AouPLRORMYH0ESKyMLB+/0cicl7go5wi8kex1vRfEpili4h8W6w9DjaKyEsJukyVwjQQKNUpK6xp6ItBrx02xkwFfo+1IiXA74BnjTHTgBeAhwPpDwNvG2NOw9q3YXMgvRh4xBgzGWgArg6k3wWcHvicb9h1cUp1RWcWKxUgIk3GmAFR0ncBlxhjdgQWndtvjMkXkYNYy0l4Aun7jDFDReQAUGSsRcnaP2Ms1vLNxYHjHwDpxpificgbQBPwKvCq6Vz7X6m40CcCpWJjuvi5J9qCfvbR2Ud3OfAI1tPD6qBVNZWKCw0ESsXmi0HfPwz8/AHWqpQAXwLeDfy8DPhP6NjQZVBXHyoiDmC0MWY51rr2g4CIpxKl7KR3Hkp1ygrswtXuDWNM+xDSwSKyEeuu/vpA2m3A0yJyJ3AA+I9A+u3A4yJyM9ad/39irdYajRN4PhAsBHjYWGv+KxU32keg1DEE+ghmGGMOJrosStlBm4aUUirF6ROBUkqlOH0iUEqpFKeBQCmlUpwGAqWUSnEaCJRSKsVpIFBKqRT3/wFs8M8dV7QgmwAAAABJRU5ErkJggg==\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"f0oyHRCkQ331"},"source":["# Segmentation"]},{"cell_type":"code","metadata":{"id":"V3Ahm7ecTST4","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1634541481872,"user_tz":-600,"elapsed":940,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"7607bfba-d530-42f2-dc0c-4f752e538500"},"source":["#load model\n","new_model = ImprovedUnet(feature_size=feature_size)\n","\n","filename = \"Unet_ISIC2.pth\"\n","checkpoint = torch.load(filename)\n","\n","new_model.load_state_dict(checkpoint)"],"execution_count":137,"outputs":[{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":137}]},{"cell_type":"code","metadata":{"id":"BZYl7y1XIJFr","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1634541488207,"user_tz":-600,"elapsed":4036,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"a28afd14-4fc1-4013-f790-2a64af890567"},"source":["for batch in test_loader:\n"," x, y = batch\n"," print(x.shape, y.shape)\n"," break"],"execution_count":138,"outputs":[{"output_type":"stream","name":"stdout","text":["torch.Size([64, 3, 128, 128]) torch.Size([64, 1, 128, 128])\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"8mo7-6wPsboG","executionInfo":{"status":"ok","timestamp":1634541495022,"user_tz":-600,"elapsed":4545,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"6839af64-3b89-4a4f-b8ba-6b7db113e9ae"},"source":["p = new_model(x)"],"execution_count":139,"outputs":[{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.7/dist-packages/torch/nn/functional.py:1805: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n"," warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n"]}]},{"cell_type":"code","metadata":{"id":"O-lkaeAvKayG","executionInfo":{"status":"ok","timestamp":1634541510585,"user_tz":-600,"elapsed":454,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["def segment_pred_mask(imgs=x, pred_masks=p, idx=0, alpha=10):\n"," seg_img = x[idx].clone()\n"," image_r = seg_img[0] #C: red\n"," image_r = image_r*(1-alpha*p[idx])+(p[idx]*p[idx]*alpha)\n"," segment_image = image_r.detach().squeeze()\n"," seg_img[0] = segment_image\n"," return seg_img"],"execution_count":140,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":666},"id":"KPJtsairAkc6","executionInfo":{"status":"ok","timestamp":1634541514338,"user_tz":-600,"elapsed":1288,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"660e1be6-dae2-478b-e0c0-633a0cadbc77"},"source":["#visualise\n","import matplotlib.pyplot as plt\n","\n","n_col = 4\n","n_row = 6\n","\n","def plot_gallery(images=x, mask=y, pred_mask = p, n_row=n_row, n_col=n_col):\n"," idxs = n_col*n_row\n"," plt.figure(figsize=(1.5*n_col, 1.5*n_row))\n"," plt.subplots_adjust(bottom=0, left=0.01, right=0.99, top=0.9, hspace=0.35) #adjust layout parameters\n"," plt.suptitle('Segmentation', fontsize=15)\n","\n"," for i in range(0, idxs, 4):\n"," #image\n"," plt.subplot(n_row, n_col, i+1)\n"," plt.imshow(x[i].permute(1,2,0))\n"," plt.title('image', fontsize = 10)\n"," plt.axis('off')\n","\n"," #target mask\n"," plt.subplot(n_row, n_col, i+2)\n"," plt.imshow(y[i].detach().squeeze(), cmap='gray')\n"," plt.title('target mask', fontsize = 10)\n"," plt.axis('off')\n"," \n"," #predicted mask\n"," plt.subplot(n_row, n_col, i+3)\n"," plt.imshow(p[i].detach().squeeze(), cmap='gray')\n"," plt.title('predicted mask', fontsize = 10)\n"," plt.axis('off')\n","\n"," #segmentation\n"," seg_img = segment_pred_mask(imgs=x, pred_masks=p, idx=i, alpha=0.5)\n"," plt.subplot(n_row, n_col, i+4)\n"," plt.imshow(seg_img.permute(1,2,0))\n"," plt.title('segmentation', fontsize = 10)\n"," plt.axis('off')\n","\n","plot_gallery()\n","plt.show()"],"execution_count":141,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"id":"9GxVJPOpKK-G","executionInfo":{"status":"ok","timestamp":1634541523500,"user_tz":-600,"elapsed":786,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}}},"source":["seg_img= segment_pred_mask(imgs=x, pred_masks=p, idx=10, alpha=10)"],"execution_count":142,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":302},"id":"2qNx8jmVJxbF","executionInfo":{"status":"ok","timestamp":1634541525522,"user_tz":-600,"elapsed":13,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"510d6761-517c-4f90-d345-064a87ce6859"},"source":["plt.imshow(seg_img.permute(1,2,0))"],"execution_count":143,"outputs":[{"output_type":"stream","name":"stderr","text":["Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n"]},{"output_type":"execute_result","data":{"text/plain":[""]},"metadata":{},"execution_count":143},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"d29ABXmtBDPc","executionInfo":{"status":"ok","timestamp":1634520579438,"user_tz":-600,"elapsed":470,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"51258823-64d3-499f-8cd2-26868e33c009"},"source":["print(torch.__version__)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["1.9.0+cu111\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"XwYGPWVxBLjQ","executionInfo":{"status":"ok","timestamp":1634520681440,"user_tz":-600,"elapsed":470,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"55b03581-ae27-4f77-94e5-9911ca207fd5"},"source":["!python --version"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Python 3.7.12\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"1NiyOl3MBXb8","executionInfo":{"status":"ok","timestamp":1634520779592,"user_tz":-600,"elapsed":489,"user":{"displayName":"Wakayama Hideki","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14GgX8nPmXxUwee3ETuvhR0wO18p4u7HNRL2KAZ97=s64","userId":"16567349205826503190"}},"outputId":"7b9abc74-9e0c-4df8-e10b-1385fc9dfd24"},"source":["!nvidia-smi -L"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["GPU 0: Tesla P100-PCIE-16GB (UUID: GPU-3a7e6110-e668-9d4e-bb61-02d20470e114)\n"]}]}]} \ No newline at end of file diff --git a/recognition/s4633139/README.md b/recognition/s4633139/README.md new file mode 100644 index 0000000000..524e880dc5 --- /dev/null +++ b/recognition/s4633139/README.md @@ -0,0 +1,117 @@ +# Improved UNet for ISIC2018 image segmentation +The project is the practical work for COMP3710 in 2021. This report will summarise the information with the improved UNet model in the repository. + + +## Objective +The project objective is to implement the improved UNet for ISIC2018 image segmentation. UNet is a developed model for biomedical image segmentation, which automatically identifies the tumour area.[1] The automatic image segmentation without objective will support the medical and experimental works, while the higher accurate image segmentation performance is also required. This project aimed to implement the improved UNet model for Brain tumours into the ISIC2018 image dataset. + + +## Model Architecture +Figure 1 shows the improved UNet architecture for Brain tumours.[2] The improved model utilises the context module, 3x3 convolution layer with stride = 2 instead of max-pooling layer, localisation module, and segmentation layer extracted from localisation layer. In down-sampling part, context block works as residual blocks of ResNet. The context block consists of 3x3 convolution layer, batch normalisation layer, dropout layer, and activity function layer. LeakyReLu is applied as the activation function in the model. The output through the context block is concatenated to the input for the localisation modules in up-sampling block. After that, the output features are decreased with 3x3 convolution layer for the following context block. + +In up-sampling, the concatenated input is fed into the localization block. Then, the output from the localization is fed into the convolutional layer to transform into a segmentation layer to add to the next segmentation layer and the up-sampling block, respectively. + +

+ +

+ +

+ Figure1: The improved UNet model architecture[2] +

+ +In terms of the loss function, dice loss is utilised for UNet. The loss function is represented as + +

+ +

+ +Dice coefficient is represented as + +

+ +

+ +Dice coefficient measures the similarity between the target mask and the predicted mask from the model. + + +## Files +This repository includes the below files for the improved UNet. + +**criterion.py:** This file consists of the two criterion functions: dice coefficient and dice loss. The functions are utilised for training and evaluating the model through the forward and backpropagation steps. + +**dataloader.py:** This file is concerning data preparation for UNet model, which works for data loading, image augmentation, transformation into data loader. + +**model_train_val.py:** This file works to train the model and to assess the segmentation performance with dice coefficient and dice loss. The function in the file returns lists recorded the criteria values by epochs: TRAIN_DICE, VAL_DICE, TRAIN_LOSS, VAL_LOSS. + +**model.py:** This file includes the classes to build the improved UNet model. The classes with Context, Localization, Up-sampling, Segmentation, and Convolution to down-sampling, and Improved UNet are provided. In this model, Sigmoid function for the binary classification between mask and non-mask areas is utilised instead of softmax function. + +**driver.py:** The file performs all procedures for the project, data preparation, training model, and model evaluation. The file includes the parameters with the improved UNet: FEATURE_SIZE, IN_CHANEL, OUT_CHANEL, IMG_TF, MASK_TF, BATCH_SIZE, EPOCHS, and LR. The image size is resized into 128x128 as the initial parameter. Also, random_split() is set to split the dataset into train set, validation set, and test set by 50:25:25. Adam is applied as an optimizer to train the model. + +**visualise.py:** The file contains the five functions for plotting the test result and training dice coefficient and dice loss by epochs, and output the segmented images with the predicted mask. + + +## Dataset +ISIC 2018 Task1 is a dataset with skin cancer images shared by the International Skin Imaging Collaboration (ISIC). [3] The dataset consists of 2594 images and mask images, respectively. The dataset is split into the train set, validation, and test set by ratio: 0.5: 0.25: 0.25. + + +## How to run +“driver.py” calls all files in the repository to train the model and to evaluate the performance. ISIC dataset is needed to be set in the same directory including the files. After that, put the command ‘python driver.py’ in the terminal and execute the command. + + +## Dependencies +The model training and evaluation was executed under the environment. +* Pytorch 1.9.0+cu111 +* Python 3.7.12 +* Matplotlib 3.3.4 + + + +## Results +#### Dice coefficient and loss +The figure is about train and validation dice coefficient and losses by 50 epochs. The validation dice coefficient was approximately 0.85 and it was stable after 15 epochs. + + +

+ +

+ +

+Figure2. Dice coefficient +

+ + +The validation dice loss was stable at roughly 0.15 while train loss declined after epoch 15. + + +

+ +

+ + +

+Figure3. Dice loss +

+ + + +#### Segmentation +The trained UNet predict the mask from the image in test set. The segmentations in the right-hand side column are the images covered with the predicted mask. The dice coefficient of the image is provided in the label. The dice coefficients in the figure recorded over 0.87. + + +

+ +

+ + +

+Figure4. Segmentation +

+ + + +## References +[1] Ronneberger, O., Fischer, P., & Brox, T. (2015, October). U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention (pp. 234-241). Springer, Cham. https://arxiv.org/abs/1505.04597 + +[2] Isensee, F., Kickingereder, P., Wick, W., Bendszus, M., & Maier-Hein, K. H. (2017, September). Brain tumor segmentation and radiomics survival prediction: Contribution to the brats 2017 challenge. In International MICCAI Brainlesion Workshop (pp. 287-297). Springer, Cham. https://arxiv.org/pdf/1802.10508v1.pdf + +[3] ISIC 2018 Task1 https://paperswithcode.com/dataset/isic-2018-task-1 diff --git a/recognition/s4633139/criterion.py b/recognition/s4633139/criterion.py new file mode 100644 index 0000000000..b0b3813b99 --- /dev/null +++ b/recognition/s4633139/criterion.py @@ -0,0 +1,42 @@ +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +# Copyright (c) 2021, H.WAKAYAMA, All rights reserved. +# File: criterion.py +# Author: Hideki WAKAYAMA +# Contact: h.wakayama@uq.net.au +# Platform: macOS Big Sur Ver 11.2.1, Pycharm pro 2021.1 +# Time: 20/10/2021, 09:52 +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +#dice coefficient +def dice_coef(pred, target): + """ + function to compute the dice coefficient + param---- + pred(tensor[B,C,W,H]): predicted mask images + target(tensor[B,C,W,H]: target mask images + return--- + dice coefficient + """ + batch_size = len(pred) + somooth = 1. + + pred_flat = pred.view(batch_size, -1) + target_flat = target.view(batch_size, -1) + + intersection = (pred_flat*target_flat).sum() + dice_coef = (2.*intersection+somooth)/(pred_flat.sum()+target_flat.sum()+somooth) + return dice_coef + + +#loss +def dice_loss(pred, target): + """ + function to compute dice loss + param---- + pred(tensor[B,C,W,H]): predicted mask images + target(tensor[B,C,W,H]): target mask images + return---- + dice loss + """ + dice_loss = 1 - dice_coef(pred, target) + return dice_loss \ No newline at end of file diff --git a/recognition/s4633139/dataloader.py b/recognition/s4633139/dataloader.py new file mode 100644 index 0000000000..24d8fce742 --- /dev/null +++ b/recognition/s4633139/dataloader.py @@ -0,0 +1,47 @@ +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +# Copyright (c) 2021, H.WAKAYAMA, All rights reserved. +# File: dataloader.py +# Author: Hideki WAKAYAMA +# Contact: h.wakayama@uq.net.au +# Platform: macOS Big Sur Ver 11.2.1, Pycharm pro 2021.1 +# Time: 19/10/2021, 15:47 +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +import os +from torch.utils.data import Dataset +from PIL import Image + +os.chdir("./ISIC2018_Task1-2_Training_Data") + +class UNet_dataset(Dataset): + def __init__(self, + img_dir='./ISIC2018_Task1-2_Training_Input_x2', + mask_dir='./ISIC2018_Task1_Training_GroundTruth_x2', + img_transforms=None, + mask_transforms=None, + ): + + self.img_dir = img_dir + self.mask_dir = mask_dir + self.img_transforms = img_transforms + self.mask_transforms = mask_transforms + self.imgs = [file for file in sorted(os.listdir(self.img_dir)) if file.endswith('.jpg')] + self.masks = [file for file in sorted(os.listdir(self.mask_dir)) if file.endswith('.png')] + + def load_data(self, idx): + img_path = os.path.join(self.img_dir, self.imgs[idx]) + mask_path = os.path.join(self.mask_dir, self.masks[idx]) + img = Image.open(img_path).convert('RGB') + mask = Image.open(mask_path).convert('L') + return img, mask + + def __getitem__(self, idx): + img, mask = self.load_data(idx) + if self.img_transforms is not None: + img = self.img_transforms(img) + if self.mask_transforms is not None: + mask = self.mask_transforms(mask) + return img, mask + + def __len__(self): + return len(self.imgs) \ No newline at end of file diff --git a/recognition/s4633139/driver.py b/recognition/s4633139/driver.py new file mode 100644 index 0000000000..b31d798904 --- /dev/null +++ b/recognition/s4633139/driver.py @@ -0,0 +1,89 @@ +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +# Copyright (c) 2021, H.WAKAYAMA, All rights reserved. +# File: driver.py +# Author: Hideki WAKAYAMA +# Contact: h.wakayama@uq.net.au +# Platform: macOS Big Sur Ver 11.2.1, Pycharm pro 2021.1 +# Time: 19/10/2021, 17:30 +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +from dataloader import UNet_dataset +from model import IUNet +from model_train_val import model_train_val +from visualse import dice_coef_vis, segment_pred_mask, plot_gallery + +import torch +from torch.utils.data import DataLoader, Dataset, random_split +import torchvision.transforms as transforms +import torch.optim as optim + +import matplotlib.pyplot as plt + +def main(): + """execute model training and return dice coefficient plots""" + + #PARAMETERS + FEATURE_SIZE=[16, 32, 64, 128] + IN_CHANEL=3 + OUT_CHANEL=1 + + IMG_TF = transforms.Compose([ + transforms.Resize((FEATURE_SIZE[-1], FEATURE_SIZE[-1])), + transforms.ToTensor(), + transforms.Normalize(mean=[0, 0, 0], std=[1, 1, 1]), + ]) + + MASK_TF = transforms.Compose([ + transforms.Resize((FEATURE_SIZE[-1],FEATURE_SIZE[-1])), + transforms.ToTensor(), + ]) + + BATCH_SIZE = 64 + EPOCHS = 20 + LR = 0.001 + + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + #DATA PREPARATION + dataset = UNet_dataset(img_transforms=IMG_TF, mask_transforms=MASK_TF) + + #shuffle index + sample_size = len(dataset.imgs) + train_size = int(sample_size * 0.5) + split_size = sample_size - train_size + + val_size = split_size//2 + test_size = split_size - val_size + + #train, validation, test + train_set, split_set = random_split(dataset, [train_size, split_size], generator=torch.Generator().manual_seed(123)) + val_set, test_set = random_split(split_set, [val_size, test_size], generator=torch.Generator().manual_seed(123)) + + #data loader + train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True) + val_loader = DataLoader(val_set, batch_size=BATCH_SIZE, shuffle=False) + test_loader = DataLoader(test_set, batch_size=BATCH_SIZE, shuffle=False) + + #MODEL + model = IUNet(in_channels=IN_CHANEL, out_channels=OUT_CHANEL, feature_size=FEATURE_SIZE) + model = model.to(device) + optimizer = optim.Adam(model.parameters(), lr=LR) + + #train,test + TRAIN_DICE, VAL_DICE, VAL_LOSS, VAL_LOSS = model_train_val(model, optimizer, EPOCHS, train_loader, val_loader) + + #plot dice coefficient + dice_coef_vis(EPOCHS, TRAIN_DICE, VAL_DICE) + + #segmentation + for batch in test_loader: + images, masks = batch + break + + model.eval() + pred_masks = model(images) + + plot_gallery(images, masks, pred_masks, n_row=5, n_col=4) + +if __name__ == main(): + main() \ No newline at end of file diff --git a/recognition/s4633139/model.py b/recognition/s4633139/model.py new file mode 100644 index 0000000000..6eabad5253 --- /dev/null +++ b/recognition/s4633139/model.py @@ -0,0 +1,166 @@ +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +# Copyright (c) 2021, H.WAKAYAMA, All rights reserved. +# File: model.py +# Author: Hideki WAKAYAMA +# Contact: h.wakayama@uq.net.au +# Platform: macOS Big Sur Ver 11.2.1, Pycharm pro 2021.1 +# Time: 20/10/2021, 13:09 +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +import torch +import torch.nn as nn +import torch.nn.functional as F + + +class Context(nn.Module): + """context""" + def __init__(self, in_channels, out_channels): + super(Context, self).__init__() + self.context = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False), + nn.BatchNorm2d(out_channels), + nn.Dropout2d(p=0.3), + nn.LeakyReLU(negative_slope=0.02, inplace=True), + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False), + nn.BatchNorm2d(out_channels), + nn.LeakyReLU(negative_slope=0.02, inplace=True), + ) + + def forward(self, x): + x = self.context(x) + x + return x + + +class Localization(nn.Module): + """localization""" + def __init__(self, in_channels, out_channels): + super(Localization, self).__init__() + self.localization = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False), + nn.BatchNorm2d(out_channels), + nn.LeakyReLU(negative_slope=0.02, inplace=True), + nn.Conv2d(out_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False), + nn.BatchNorm2d(out_channels), + nn.LeakyReLU(negative_slope=0.02, inplace=True), + ) + + def forward(self, x): + return self.localization(x) + + +class Upsampling(nn.Module): + """upsampling""" + def __init__(self, in_channels, out_channels): + super(Upsampling, self).__init__() + self.upsampling = nn.Sequential( + nn.Upsample(scale_factor=2, mode='nearest'), + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False), + nn.BatchNorm2d(out_channels), + nn.LeakyReLU(negative_slope=0.02, inplace=True), + ) + + def forward(self, x): + return self.upsampling(x) + + +class Segment(nn.Module): + """segmentation layer""" + def __init__(self, in_channels, out_channels): + super(Segment, self).__init__() + self.segment = nn.Sequential( + nn.Conv2d(in_channels, out_channels=1, kernel_size=1, stride=1, padding=0, bias=False), + nn.BatchNorm2d(out_channels), + nn.LeakyReLU(negative_slope=0.02, inplace=True) + ) + + def forward(self, x): + return self.segment(x) + + +class Conv2(nn.Module): + """convolution stride=2""" + def __init__(self, in_channels, out_channels): + super(Conv2, self).__init__() + self.conv2 = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=2, padding=1, bias=False), + nn.BatchNorm2d(out_channels), + nn.LeakyReLU(negative_slope=0.02, inplace=True), + ) + + def forward(self, x): + return self.conv2(x) + + +class IUNet(nn.Module): + """Improved Unet (International MICCAI Brainlesion Workshop(pp. 287-297). Springer, Cham.)""" + def __init__(self, in_channels=3, out_channels=1, feature_size=[16, 32, 64, 128]): + super(IUNet, self).__init__() + self.Conv1 = nn.Conv2d(in_channels=3, out_channels=feature_size[0], kernel_size=3, stride=1, padding=1, bias=False) + self.Downs = nn.ModuleList() + self.Convs = nn.ModuleList() + self.Ups = nn.ModuleList() + self.Segmentations = nn.ModuleList() + + self.upscale = nn.Upsample(scale_factor=2, mode='nearest') + self.bottleneck = Context(feature_size[-1] * 2, feature_size[-1] * 2) + + #Downsampling frame + for feature in feature_size: + self.Downs.append(Context(feature, feature)) + self.Convs.append(Conv2(feature, feature * 2)) + + #Upsampleing frame + for feature in reversed(feature_size): + #Upsampling + self.Ups.append(Upsampling(feature * 2, feature)) + + #Localization + if feature != feature_size[0]: + self.Ups.append(Localization(feature * 2, feature)) + else: + self.Ups.append(Localization(feature * 2, feature * 2)) + + #Segmentation + self.Segmentations.append(Segment(feature, 1)) + + self.final_conv = nn.Conv2d(feature_size[0] * 2, out_channels, kernel_size=1, stride=1, bias=False) + + def forward(self, x): + skip_connections = [] + segmentation_layers = [] + idxs = [idx for idx in range(0, len(self.Ups),2)] + + x = self.Conv1(x) + + #Downsampling steps + for i, (context_i, conv_i) in enumerate(zip(self.Downs, self.Convs)): + x = context_i(x) + #preserve location + skip_connections.append(x) + x = conv_i(x) + + x = self.bottleneck(x) + x + skip_connections = skip_connections[:: -1] + + #Upsampling steps + for idx in range(0, len(self.Ups), 2): + #upsampling + x = self.Ups[idx](x) + + #localization + skip_connection = skip_connections[idx // 2] + concatnate_skip = torch.cat((skip_connection, x), dim=1) + x = self.Ups[idx + 1](concatnate_skip) + + #segmentation + if idx != idxs[0] and idx != idxs[-1]: + x_segment = self.Segmentations[idx // 2](x) + segmentation_layers.append(x_segment) + + seg_scale1 = self.upscale(segmentation_layers[0]) + seg_scale2 = self.upscale(segmentation_layers[1] + seg_scale1) + x = self.final_conv(x) + x = x + seg_scale2 + output = torch.sigmoid(x) + + return output \ No newline at end of file diff --git a/recognition/s4633139/model_train_val.py b/recognition/s4633139/model_train_val.py new file mode 100644 index 0000000000..f553b0eef9 --- /dev/null +++ b/recognition/s4633139/model_train_val.py @@ -0,0 +1,81 @@ +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +# Copyright (c) 2021, H.WAKAYAMA, All rights reserved. +# File: model_train_val.py +# Author: Hideki WAKAYAMA +# Contact: h.wakayama@uq.net.au +# Platform: macOS Big Sur Ver 11.2.1, Pycharm pro 2021.1 +# Time: 20/10/2021, 09:52 +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +from criterion import dice_coef, dice_loss +from tqdm import tqdm +import torch + +def model_train_val(model, optimizer, EPOCHS, train_loader, val_loader): + """ + function for model training and validation + :param---- + model: model + optimizer: optimizer + EPOCHS(int):number of epochs + train_loader: train loader + val_loader: validation loader + :return---- + list of train and validation dice coefficients and dice losses by epochs + """ + + TRAIN_LOSS = [] + TRAIN_DICE = [] + VAL_LOSS =[] + VAL_DICE = [] + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + for epoch in range(1, EPOCHS+1): + print('EPOCH {}/{}'.format(epoch, EPOCHS)) + running_loss = 0 + running_dicecoef = 0 + running_loss_val = 0 + running_dicecoef_val = 0 + BATCH_NUM = len(train_loader) + BATCH_NUM_VAL = len(val_loader) + + #train + with tqdm(train_loader, unit='batch') as tbatch: + for batch_idx, (x, y) in enumerate(tbatch): + x, y = x.to(device), y.to(device) + tbatch.set_description(f'Batch: {batch_idx}') + + optimizer.zero_grad() + output = model(x) + loss = dice_loss(output, y) + dicecoef = dice_coef(output, y) + loss.backward() + optimizer.step() + + running_loss += loss.item() + running_dicecoef += dicecoef.item() + + tbatch.set_postfix(loss=loss.item(), dice_coef=dicecoef.item()) + + epoch_loss = running_loss/BATCH_NUM + epoch_dicecoef = running_dicecoef/BATCH_NUM + TRAIN_LOSS.append(epoch_loss) + TRAIN_DICE.append(epoch_dicecoef) + + #validation + with tqdm(val_loader, unit='batch') as valbatch: + for batch_idx, (x, y) in enumerate(valbatch): + x, y = x.to(device), y.to(device) + valbatch.set_description(f'Batch: {batch_idx}') + output_val = model(x) + loss_val = dice_loss(output_val, y) + dicecoef_val = dice_coef(output_val, y) + valbatch.set_postfix(loss=loss_val.item(), dice_coef=dicecoef_val.item()) + + running_loss_val += loss_val.item() + running_dicecoef_val += dicecoef_val.item() + + VAL_LOSS.append(running_loss_val/BATCH_NUM_VAL) + VAL_DICE.append(running_dicecoef_val/BATCH_NUM_VAL) + + return TRAIN_DICE, VAL_DICE, TRAIN_LOSS, VAL_LOSS \ No newline at end of file diff --git a/recognition/s4633139/visualse.py b/recognition/s4633139/visualse.py new file mode 100644 index 0000000000..50d7288abc --- /dev/null +++ b/recognition/s4633139/visualse.py @@ -0,0 +1,136 @@ +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +# Copyright (c) 2021, H.WAKAYAMA, All rights reserved. +# File: visualse.py +# Author: Hideki WAKAYAMA +# Contact: h.wakayama@uq.net.au +# Platform: macOS Big Sur Ver 11.2.1, Pycharm pro 2021.1 +# Time: 20/10/2021, 12:49 +# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +import matplotlib.pyplot as plt +import numpy as np + + +def dice_coef_vis(EPOCHS, TRAIN_COEFS, VAL_COEFS): + """ + function for dice coefficient + param---- + EPOCHS(array): epochs + TRAIN_COEFS(array): train dice coefficients + VAL_COEFS(array): validation dice coefficients + return---- + plot with dice coefficients by epochs + """ + X = np.arange(1, EPOCHS+1) + plt.plot(X, TRAIN_COEFS, marker='.', markersize=10, label='train') + plt.plot(X, VAL_COEFS, marker='.', markersize=10, label='validation') + plt.xlabel('Epochs') + plt.ylabel('Dice coefficient') + plt.xticks(X) + plt.legend() + plt.show() + + +def dice_loss_vis(EPOCHS, TRAIN_LOSS, VAL_LOSS): + """ + function for dice loss + param---- + EPOCHS(array): epochs + TRAIN_LOSS(array): train dice losses + VAL_LOSS(array): validation dice losses + return---- + plot with dice loss by epochs + """ + X = np.arange(1, EPOCHS+1) + plt.plot(X, TRAIN_LOSS, marker='.', markersize=10, label='train') + plt.plot(X, VAL_LOSS, marker='.', markersize=10, label='validation') + plt.xlabel('Epochs') + plt.ylabel('Dice Loss') + plt.xticks(X) + plt.legend() + plt.show() + + +def eval_dice_coef(target, pred_masks, idx): + """ + function to return dice coefficient of the image + param---- + target(tensor[B,C,W,H]):target mask images + pred_masks:(tensor[B,C,W,H]):predicted mask images + idx(int): index + return---- + dice coefficient + """ + batch_size = len(pred_masks) + somooth = 1. + + pred_flat = pred_masks.view(batch_size, -1) + target_flat = target.view(batch_size, -1) + + intersection = (pred_flat*target_flat) + dice_coef = (2.*intersection.sum(dim=1)+somooth)/(pred_flat.sum(dim=1)+target_flat.sum(dim=1)+somooth) + return dice_coef[idx] + + +def segment_pred_mask(imgs, pred_masks, idx, alpha): + """ + function to make a covered image with the predicted mask + param---- + imgs(tensor[B,C,W,H]): 3 channels image + pred_masks(tensor[B,C,W,H]): predicted mask + idx(int): image index + alpha(float): ratio for segmentation + return---- + segmentation image + """ + seg_img = imgs[idx].clone() + image_r = seg_img[0] + image_r = image_r*(1-alpha*pred_masks[idx])+(pred_masks[idx]*pred_masks[idx]*alpha) + segment_image = image_r.detach().squeeze() + seg_img[0] = segment_image + return seg_img + + +def plot_gallery(images, masks, pred_masks, n_row=5, n_col=4): + """ + function to generate gallery + parameters---- + images(tensor[B,C,W,H]): images + masks(tensor[B,C,W,H]): target masks + pred_masks(tensor[B,C,W,H]): predicted masks + n_row: number of the row for the gallery + n_col: number of the column for the gallery + return---- + gallery images + """ + idxs = n_col * n_row + plt.figure(figsize=(1.5 * n_col, 1.5 * n_row)) + plt.subplots_adjust(bottom=0, left=0.01, right=0.99, top=0.9, hspace=0.35) # adjust layout parameters + plt.suptitle('Segmentation', fontsize=15) + + for i in range(0, idxs, 4): + # image + plt.subplot(n_row, n_col, i + 1) + plt.imshow(images[i].permute(1, 2, 0)) + plt.title('image', fontsize=10) + plt.axis('off') + + # target mask + plt.subplot(n_row, n_col, i + 2) + plt.imshow(masks[i].detach().squeeze(), cmap='gray') + plt.title('target mask', fontsize=10) + plt.axis('off') + + # predicted mask + plt.subplot(n_row, n_col, i + 3) + plt.imshow(pred_masks[i].detach().squeeze(), cmap='gray') + plt.title('predicted mask', fontsize=10) + plt.axis('off') + + # segmentation + seg_img = segment_pred_mask(imgs=images, pred_masks=pred_masks, idx=i, alpha=0.5) + plt.subplot(n_row, n_col, i + 4) + plt.imshow(seg_img.permute(1, 2, 0)) + plt.title('dice_coef: {:.2f}'.format(eval_dice_coef(masks, pred_masks, i)), fontsize=10) + plt.axis('off') + plt.show() \ No newline at end of file