hubmap-effnet-b7-unet-train_mod1.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"papermill":{"duration":0.007246,"end_time":"2022-08-16T19:02:52.302567","exception":false,"start_time":"2022-08-16T19:02:52.295321","status":"completed"},"tags":[]},"source":["## Imports"]},{"cell_type":"code","execution_count":8,"metadata":{},"outputs":[{"name":"stdout","output_type":"stream","text":["Sun Aug 21 21:32:31 2022       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 470.141.03   Driver Version: 470.141.03   CUDA Version: 11.4     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|                               |                      |               MIG M. |\n","|===============================+======================+======================|\n","|   0  NVIDIA GeForce ...  Off  | 00000000:01:00.0  On |                  N/A |\n","| 28%   40C    P8    30W / 250W |   1618MiB / 11016MiB |      5%      Default |\n","|                               |                      |                  N/A |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                                  |\n","|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n","|        ID   ID                                                   Usage      |\n","|=============================================================================|\n","|    0   N/A  N/A      2668      G   /usr/lib/xorg/Xorg                 18MiB |\n","|    0   N/A  N/A      2777      G   /usr/bin/gnome-shell               71MiB |\n","|    0   N/A  N/A      3347      G   /usr/lib/xorg/Xorg                152MiB |\n","|    0   N/A  N/A      3511      G   /usr/bin/gnome-shell               29MiB |\n","|    0   N/A  N/A      4257      G   ...isable-features=EventPath       25MiB |\n","|    0   N/A  N/A     18325      G   ...RendererForSitePerProcess       76MiB |\n","|    0   N/A  N/A     31470      C   ...p_kaggle/.venv/bin/python     1237MiB |\n","+-----------------------------------------------------------------------------+\n"]}],"source":["!nvidia-smi"]},{"cell_type":"code","execution_count":9,"metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","execution":{"iopub.execute_input":"2022-08-19T12:46:21.814868Z","iopub.status.busy":"2022-08-19T12:46:21.814303Z","iopub.status.idle":"2022-08-19T12:46:28.590110Z","shell.execute_reply":"2022-08-19T12:46:28.588744Z","shell.execute_reply.started":"2022-08-19T12:46:21.814757Z"},"papermill":{"duration":5.945852,"end_time":"2022-08-16T19:02:58.254572","exception":false,"start_time":"2022-08-16T19:02:52.308720","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["import numpy as np\n","import pandas as pd\n","import os\n","import cv2\n","import matplotlib.pyplot as plt\n","import time\n","import random\n","\n","import torch\n","from torch import nn\n","import torch.cuda.amp as amp\n","from torch.utils.data import Dataset\n","from torch.utils.data import DataLoader\n","from torch.utils.data import RandomSampler \n","from torch.utils.data import SequentialSampler\n","import torch.nn.functional as F\n","# from torchmetrics.functional import dice_score\n","from torch.optim.lr_scheduler import StepLR\n","import tifffile\n","from fastai.vision.all import *\n","\n","from collections import defaultdict\n","\n","import torch\n","from torch.optim.optimizer import Optimizer\n","import itertools as it\n","\n","is_amp = True\n","import logging\n","\n","from sklearn.model_selection import KFold\n","\n","\n","from itertools import repeat\n","import collections.abc\n","import math\n","import torch\n","from torch import Tensor\n","from torch.optim.optimizer import Optimizer, required\n","from collections import defaultdict\n","\n","import warnings\n","warnings.filterwarnings('ignore')\n","\n","import sys\n","sys.path.append('/home/lakshita/somusan/hubmap_kaggle/nbs/timm-pytorch-image-models/pytorch-image-models-master')\n","import timm\n","\n","sys.path.append('/home/lakshita/somusan/hubmap_kaggle/nbs/efficientnet-pytorch/EfficientNet-PyTorch/EfficientNet-PyTorch-master')\n","\n","from efficientnet_pytorch import EfficientNet\n","from efficientnet_pytorch.utils import url_map, url_map_advprop, get_model_params"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.005742,"end_time":"2022-08-16T19:02:58.266495","exception":false,"start_time":"2022-08-16T19:02:58.260753","status":"completed"},"tags":[]},"source":["## Directory"]},{"cell_type":"code","execution_count":10,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:28.594512Z","iopub.status.busy":"2022-08-19T12:46:28.593089Z","iopub.status.idle":"2022-08-19T12:46:31.460897Z","shell.execute_reply":"2022-08-19T12:46:31.459271Z","shell.execute_reply.started":"2022-08-19T12:46:28.594469Z"},"papermill":{"duration":2.014493,"end_time":"2022-08-16T19:03:00.286680","exception":false,"start_time":"2022-08-16T19:02:58.272187","status":"completed"},"tags":[],"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["mkdir: cannot create directory ‘/home/lakshita/somusan/hubmap_kaggle/nbs/result’: File exists\n","mkdir: cannot create directory ‘/home/lakshita/somusan/hubmap_kaggle/nbs/checkpoint’: File exists\n"]}],"source":["!mkdir /home/lakshita/somusan/hubmap_kaggle/nbs/result\n","!mkdir /home/lakshita/somusan/hubmap_kaggle/nbs/checkpoint\n","\n","root_dir = '/home/lakshita/somusan/hubmap_kaggle/nbs'\n","#pretrain_dir = '/kaggle/input/swin-tiny-small-22k-pretrained/'\n","\n","TRAIN = '/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train_images'\n","LABELS = '/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train.csv'"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.005637,"end_time":"2022-08-16T19:03:00.299522","exception":false,"start_time":"2022-08-16T19:03:00.293885","status":"completed"},"tags":[]},"source":["## Utility"]},{"cell_type":"code","execution_count":11,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.470144Z","iopub.status.busy":"2022-08-19T12:46:31.467698Z","iopub.status.idle":"2022-08-19T12:46:31.513189Z","shell.execute_reply":"2022-08-19T12:46:31.511960Z","shell.execute_reply.started":"2022-08-19T12:46:31.470100Z"},"papermill":{"duration":0.053647,"end_time":"2022-08-16T19:03:00.359131","exception":false,"start_time":"2022-08-16T19:03:00.305484","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["def image_to_tensor(image, mode='bgr'): #image mode\n","    if mode=='bgr':\n","        image = image[:,:,::-1]\n","    x = image\n","    x = x.transpose(2,0,1)\n","    x = np.ascontiguousarray(x)\n","    x = torch.tensor(x, dtype = torch.float)\n","    return x\n","\n","def mask_to_tensor(mask):\n","    x = mask\n","    #x = x.transpose(2, 0, 1)\n","    x = torch.tensor(x, dtype = torch.float)\n","    return x\n","\n","\n","class RGB(nn.Module):\n","    IMAGE_RGB_MEAN = [0.485, 0.456, 0.406] #[0.5, 0.5, 0.5]\n","    IMAGE_RGB_STD  = [0.229, 0.224, 0.225] #[0.5, 0.5, 0.5]\n","\n","    def __init__(self,):\n","        super(RGB, self).__init__()\n","        self.register_buffer('mean', torch.zeros(1,3,1,1))\n","        self.register_buffer('std', torch.ones(1,3,1,1))\n","        self.mean.data = torch.FloatTensor(self.IMAGE_RGB_MEAN).view(self.mean.shape)\n","        self.std.data = torch.FloatTensor(self.IMAGE_RGB_STD).view(self.std.shape)\n","\n","    def forward(self, x):\n","        x = (x-self.mean)/self.std\n","        return x\n","\n","def message(mode='print'):\n","    asterisk = ' '\n","    if mode==('print'):\n","        loss = batch_loss\n","    if mode==('log'):\n","        loss = train_loss\n","        if (iteration % iter_save == 0): asterisk = '*'\n","\n","    text = \\\n","        ('%0.2e   %08d%s %6.2f | '%(rate, iteration, asterisk, epoch,)).replace('e-0','e-').replace('e+0','e+') + \\\n","        '%4.3f  %4.3f   | '%(*valid_loss,) + \\\n","        '%4.3f   | '%(loss) + \\\n","        '%s' % ((time.time() - start_timer))\n","\n","    return text\n","\n","def rle_decode(mask_rle, shape):\n","    '''\n","    mask_rle: run-length as string formated (start length)\n","    shape: (height,width) of array to return \n","    Returns numpy array, 1 - mask, 0 - background\n","\n","    '''\n","    s = mask_rle.split()\n","    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]\n","    starts -= 1\n","    ends = starts + lengths\n","    img = np.zeros(shape[0]*shape[1], dtype=np.uint8)\n","    for lo, hi in zip(starts, ends):\n","        img[lo:hi] = 1\n","    return img.reshape(shape).T\n","\n","\n","# ref.: https://www.kaggle.com/stainsby/fast-tested-rle\n","def rle_encode(img):\n","    '''\n","    img: numpy array, 1 - mask, 0 - background\n","    Returns run length as string formated\n","    '''\n","    pixels = img.flatten()\n","    pixels = np.concatenate([[0], pixels, [0]])\n","    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1\n","    runs[1::2] -= runs[::2]\n","    return ' '.join(str(x) for x in runs)\n","\n","\n","\n","def get_learning_rate(optimizer):\n","    return optimizer.param_groups[0]['lr']"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.005519,"end_time":"2022-08-16T19:03:00.370356","exception":false,"start_time":"2022-08-16T19:03:00.364837","status":"completed"},"tags":[]},"source":["## Augments"]},{"cell_type":"code","execution_count":12,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.523416Z","iopub.status.busy":"2022-08-19T12:46:31.520663Z","iopub.status.idle":"2022-08-19T12:46:31.536781Z","shell.execute_reply":"2022-08-19T12:46:31.535284Z","shell.execute_reply.started":"2022-08-19T12:46:31.523377Z"},"papermill":{"duration":0.016754,"end_time":"2022-08-16T19:03:00.392910","exception":false,"start_time":"2022-08-16T19:03:00.376156","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["def valid_augment5(image, mask, organ):\n","    #image, mask  = do_crop(image, mask, image_size, xy=(None,None))\n","    return image, mask\n","\n","def train_augment5b(image, mask, organ):\n","    image, mask = do_random_flip(image, mask)\n","    image, mask = do_random_rot90(image, mask)\n","\n","    for fn in np.random.choice([\n","        lambda image, mask: (image, mask),\n","        #lambda image, mask: do_random_noise(image, mask, mag=0.1),\n","        #lambda image, mask: do_random_contast(image, mask, mag=0.40),\n","        lambda image, mask: do_random_hsv(image, mask, mag=[0.40, 0.40, 0])\n","    ], 2): image, mask = fn(image, mask)\n","\n","    for fn in np.random.choice([\n","        lambda image, mask: (image, mask),\n","        lambda image, mask: do_random_rotate_scale(image, mask, angle=45, scale=[0.50, 2.0]),\n","    ], 1): image, mask = fn(image, mask)\n","\n","    return image, mask"]},{"cell_type":"code","execution_count":13,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.547718Z","iopub.status.busy":"2022-08-19T12:46:31.544535Z","iopub.status.idle":"2022-08-19T12:46:31.579294Z","shell.execute_reply":"2022-08-19T12:46:31.578081Z","shell.execute_reply.started":"2022-08-19T12:46:31.547681Z"},"papermill":{"duration":0.024978,"end_time":"2022-08-16T19:03:00.423769","exception":false,"start_time":"2022-08-16T19:03:00.398791","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["def do_random_flip(image, mask):\n","    if np.random.rand()>0.5:\n","        image = cv2.flip(image,0)\n","        mask = cv2.flip(mask,0)\n","    if np.random.rand()>0.5:\n","        image = cv2.flip(image,1)\n","        mask = cv2.flip(mask,1)\n","    if np.random.rand()>0.5:\n","        image = image.transpose(1,0,2)\n","        mask = mask.transpose(1,0)\n","    \n","    image = np.ascontiguousarray(image)\n","    mask = np.ascontiguousarray(mask)\n","    return image, mask\n","\n","def do_random_rot90(image, mask):\n","    r = np.random.choice([\n","        0,\n","        cv2.ROTATE_90_CLOCKWISE,\n","        cv2.ROTATE_90_COUNTERCLOCKWISE,\n","        cv2.ROTATE_180,\n","    ])\n","    if r==0:\n","        return image, mask\n","    else:\n","        image = cv2.rotate(image, r)\n","        mask = cv2.rotate(mask, r)\n","        return image, mask\n","    \n","def do_random_contast(image, mask, mag=0.3): #this thing kills the image and sets all pixels to 1\n","    alpha = 1 + random.uniform(-1,1)*mag\n","    image = image * alpha\n","    image = np.clip(image,0,1)\n","    return image, mask\n","\n","def do_random_hsv(image, mask, mag=[0.15,0.25,0.25]):\n","    image = (image*255).astype(np.uint8)\n","    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\n","\n","    h = hsv[:, :, 0].astype(np.float32)  # hue\n","    s = hsv[:, :, 1].astype(np.float32)  # saturation\n","    v = hsv[:, :, 2].astype(np.float32)  # value\n","    h = (h*(1 + random.uniform(-1,1)*mag[0]))%180\n","    s =  s*(1 + random.uniform(-1,1)*mag[1])\n","    v =  v*(1 + random.uniform(-1,1)*mag[2])\n","\n","    hsv[:, :, 0] = np.clip(h,0,180).astype(np.uint8)\n","    hsv[:, :, 1] = np.clip(s,0,255).astype(np.uint8)\n","    hsv[:, :, 2] = np.clip(v,0,255).astype(np.uint8)\n","    image = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)\n","    image = image.astype(np.float32)/255\n","    return image, mask\n","\n","def do_random_noise(image, mask, mag=0.1): #also seems to kill the image and set to 1\n","    height, width = image.shape[:2]\n","    noise = np.random.uniform(-1,1, (height, width,1))*mag\n","    image = image + noise\n","    image = np.clip(image,0,1)\n","    return image, mask\n","\n","def do_random_rotate_scale(image, mask, angle=30, scale=[0.8,1.2] ):\n","    angle = np.random.uniform(-angle, angle)\n","    scale = np.random.uniform(*scale) if scale is not None else 1\n","    \n","    height, width = image.shape[:2]\n","    center = (height // 2, width // 2)\n","    \n","    transform = cv2.getRotationMatrix2D(center, angle, scale)\n","    image = cv2.warpAffine( image, transform, (width, height), flags=cv2.INTER_LINEAR,\n","                            borderMode=cv2.BORDER_CONSTANT, borderValue=(0,0,0))\n","    mask  = cv2.warpAffine( mask, transform, (width, height), flags=cv2.INTER_LINEAR,\n","                            borderMode=cv2.BORDER_CONSTANT, borderValue=0)\n","    return image, mask"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.005493,"end_time":"2022-08-16T19:03:00.454279","exception":false,"start_time":"2022-08-16T19:03:00.448786","status":"completed"},"tags":[]},"source":["## Dataset"]},{"cell_type":"code","execution_count":14,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.606689Z","iopub.status.busy":"2022-08-19T12:46:31.603776Z","iopub.status.idle":"2022-08-19T12:46:31.628815Z","shell.execute_reply":"2022-08-19T12:46:31.627585Z","shell.execute_reply.started":"2022-08-19T12:46:31.606617Z"},"papermill":{"duration":0.02051,"end_time":"2022-08-16T19:03:00.480870","exception":false,"start_time":"2022-08-16T19:03:00.460360","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["image_size = 768 #512 # 256 #changed\n","\n","class HubmapDataset(Dataset):\n","    def __init__(self, df, augment=None):\n","\n","        self.df = df\n","        self.augment = augment\n","        self.length = len(self.df)\n","        self.organ_to_label = {'kidney' : 0,\n","                               'prostate' : 1,\n","                               'largeintestine' : 2,\n","                               'spleen' : 3,\n","                               'lung' : 4}\n","\n","    def __str__(self):\n","        string = ''\n","        string += '\\tlen = %d\\n' % len(self)\n","\n","        d = self.df.organ.value_counts().to_dict()\n","        for k in ['kidney', 'prostate', 'largeintestine', 'spleen', 'lung']:\n","            string +=  '%24s %3d (%0.3f) \\n'%(k, d.get(k,0), d.get(k,0)/len(self.df))\n","        return string\n","\n","    def __len__(self):\n","        return self.length\n","\n","    def __getitem__(self, index):\n","        d = self.df.iloc[index]\n","        img_height = self.df.loc[index, 'img_height']\n","        img_width = self.df.loc[index, 'img_width']\n","        organ = self.organ_to_label[d.organ]\n","\n","        image = cv2.cvtColor(tifffile.imread(os.path.join(TRAIN, f'{d.id}.tiff')), cv2.COLOR_BGR2RGB)\n","        \n","        rle_mask = self.df.loc[index, 'rle']\n","        mask = rle_decode(rle_mask, (img_height, img_width))\n","        #mask = cv2.cvtColor(mask, cv2.IMREAD_GRAYSCALE)\n","        #mask = cv2.imread(os.path.join(MASKS,fname),cv2.IMREAD_GRAYSCALE)\n","        mask = np.expand_dims(mask, axis = 2)\n","        #print(mask.shape)\n","        \n","        image = image.astype(np.float32)/255\n","        #mask  = mask.astype(np.float32)/255\n","        mask = mask.astype(np.float32)\n","\n","        s = d.pixel_size/0.4 * (image_size/3000)\n","        image = cv2.resize(image,dsize=(image_size,image_size),interpolation=cv2.INTER_LINEAR)\n","        mask  = cv2.resize(mask, dsize=(image_size,image_size),interpolation=cv2.INTER_LINEAR)\n","\n","        if self.augment is not None:\n","            image, mask = self.augment(image, mask, organ)\n","\n","\n","        r ={}\n","        r[\"id\"] = d.id\n","        r['index']= index\n","        r['organ'] = torch.tensor([organ], dtype=torch.long)\n","        r['image'] = image_to_tensor(image)\n","        r['mask' ] = mask_to_tensor(mask)\n","        return r"]},{"cell_type":"code","execution_count":23,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.639410Z","iopub.status.busy":"2022-08-19T12:46:31.635098Z","iopub.status.idle":"2022-08-19T12:46:31.644827Z","shell.execute_reply":"2022-08-19T12:46:31.642880Z","shell.execute_reply.started":"2022-08-19T12:46:31.639382Z"},"papermill":{"duration":0.01215,"end_time":"2022-08-16T19:03:00.498755","exception":false,"start_time":"2022-08-16T19:03:00.486605","status":"completed"},"tags":[],"trusted":true},"outputs":[{"data":{"text/plain":["<matplotlib.image.AxesImage at 0x7fc48991e390>"]},"execution_count":23,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 432x288 with 2 Axes>"]},"metadata":{"needs_background":"light"},"output_type":"display_data"}],"source":["df = pd.read_csv('/home/lakshita/somusan/hubmap_kaggle/hubmap_data/hubmap-organ-segmentation/train.csv')\n","train_dataset = HubmapDataset(df, train_augment5b)\n","\n","# train_dataset[0][\"image\"].permute(1,2,0).numpy().shape\n","plt.subplot(1,2,1)\n","plt.imshow(train_dataset[0][\"image\"].permute(1,2,0).numpy())\n","plt.subplot(1,2,2)\n","plt.imshow(train_dataset[0][\"mask\"].numpy())\n"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.00545,"end_time":"2022-08-16T19:03:00.509765","exception":false,"start_time":"2022-08-16T19:03:00.504315","status":"completed"},"tags":[]},"source":["## Model"]},{"cell_type":"code","execution_count":9,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.647171Z","iopub.status.busy":"2022-08-19T12:46:31.646790Z","iopub.status.idle":"2022-08-19T12:46:31.728517Z","shell.execute_reply":"2022-08-19T12:46:31.727427Z","shell.execute_reply.started":"2022-08-19T12:46:31.647136Z"},"papermill":{"duration":0.049669,"end_time":"2022-08-16T19:03:00.565172","exception":false,"start_time":"2022-08-16T19:03:00.515503","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["class FPN(nn.Module):\n","    def __init__(self, input_channels:list, output_channels:list):\n","        super().__init__()\n","        self.convs = nn.ModuleList(\n","            [nn.Sequential(nn.Conv2d(in_ch, out_ch*2, kernel_size=3, padding=1),\n","             nn.ReLU(inplace=True), nn.BatchNorm2d(out_ch*2),\n","             nn.Conv2d(out_ch*2, out_ch, kernel_size=3, padding=1))\n","            for in_ch, out_ch in zip(input_channels, output_channels)])\n","        \n","    def forward(self, xs:list, last_layer):\n","        hcs = [F.interpolate(c(x),scale_factor=2**(len(self.convs)-i),mode='bilinear') \n","               for i,(c,x) in enumerate(zip(self.convs, xs))]\n","        hcs.append(last_layer)\n","        return torch.cat(hcs, dim=1)\n","\n","class UnetBlock(nn.Module):\n","    def __init__(self, up_in_c:int, x_in_c:int, nf:int=None, blur:bool=False,\n","                 self_attention:bool=False, **kwargs):\n","        super().__init__()\n","        self.shuf = PixelShuffle_ICNR(up_in_c, up_in_c//2, blur=blur, **kwargs)\n","        self.bn = nn.BatchNorm2d(x_in_c)\n","        ni = up_in_c//2 + x_in_c\n","        nf = nf if nf is not None else max(up_in_c//2,32)\n","        self.conv1 = ConvLayer(ni, nf, norm_type=None, **kwargs)\n","        self.conv2 = ConvLayer(nf, nf, norm_type=None,\n","            xtra=SelfAttention(nf) if self_attention else None, **kwargs)\n","        self.relu = nn.ReLU(inplace=True)\n","\n","    def forward(self, up_in:Tensor, left_in:Tensor) -> Tensor:\n","        s = left_in\n","        up_out = self.shuf(up_in)\n","        cat_x = self.relu(torch.cat([up_out, self.bn(s)], dim=1))\n","        return self.conv2(self.conv1(cat_x))\n","        \n","class _ASPPModule(nn.Module):\n","    def __init__(self, inplanes, planes, kernel_size, padding, dilation, groups=1):\n","        super().__init__()\n","        self.atrous_conv = nn.Conv2d(inplanes, planes, kernel_size=kernel_size,\n","                stride=1, padding=padding, dilation=dilation, bias=False, groups=groups)\n","        self.bn = nn.BatchNorm2d(planes)\n","        self.relu = nn.ReLU()\n","\n","        self._init_weight()\n","\n","    def forward(self, x):\n","        x = self.atrous_conv(x)\n","        x = self.bn(x)\n","\n","        return self.relu(x)\n","\n","    def _init_weight(self):\n","        for m in self.modules():\n","            if isinstance(m, nn.Conv2d):\n","                torch.nn.init.kaiming_normal_(m.weight)\n","            elif isinstance(m, nn.BatchNorm2d):\n","                m.weight.data.fill_(1)\n","                m.bias.data.zero_()\n","\n","class ASPP(nn.Module):\n","    def __init__(self, inplanes=768, mid_c=256, dilations=[6, 12, 18, 24], out_c=None): #changed\n","        super().__init__()\n","        self.aspps = [_ASPPModule(inplanes, mid_c, 1, padding=0, dilation=1)] + \\\n","            [_ASPPModule(inplanes, mid_c, 3, padding=d, dilation=d,groups=4) for d in dilations]\n","        self.aspps = nn.ModuleList(self.aspps)\n","        self.global_pool = nn.Sequential(nn.AdaptiveMaxPool2d((1, 1)),\n","                        nn.Conv2d(inplanes, mid_c, 1, stride=1, bias=False),\n","                        nn.BatchNorm2d(mid_c), nn.ReLU())\n","        out_c = out_c if out_c is not None else mid_c\n","        self.out_conv = nn.Sequential(nn.Conv2d(mid_c*(2+len(dilations)), out_c, 1, bias=False),\n","                                    nn.BatchNorm2d(out_c), nn.ReLU(inplace=True))\n","        self.conv1 = nn.Conv2d(mid_c*(2+len(dilations)), out_c, 1, bias=False)\n","        self._init_weight()\n","\n","    def forward(self, x):\n","        x0 = self.global_pool(x)\n","        xs = [aspp(x) for aspp in self.aspps]\n","        x0 = F.interpolate(x0, size=xs[0].size()[2:], mode='bilinear', align_corners=True)\n","        x = torch.cat([x0] + xs, dim=1)\n","        return self.out_conv(x)\n","    \n","    def _init_weight(self):\n","        for m in self.modules():\n","            if isinstance(m, nn.Conv2d):\n","                torch.nn.init.kaiming_normal_(m.weight)\n","            elif isinstance(m, nn.BatchNorm2d):\n","                m.weight.data.fill_(1)\n","                m.bias.data.zero_()\n","\n","\n","class config:\n","    pretrained_root = '/home/lakshita/somusan/hubmap_kaggle/nbs/efficientnet-pytorch/'\n","    efficient_net_encoders = {\n","        \"efficientnet-b0\": {\n","            \"out_channels\": (3, 32, 24, 40, 112, 320),\n","            \"stage_idxs\": (3, 5, 9, 16),\n","            \"weight_path\": pretrained_root + \"efficientnet-b0-08094119.pth\"\n","        },\n","        \"efficientnet-b1\": {\n","            \"out_channels\": (3, 32, 24, 40, 112, 320),\n","            \"stage_idxs\": (5, 8, 16, 23),\n","            \"weight_path\": pretrained_root + \"efficientnet-b1-dbc7070a.pth\"\n","        },\n","        \"efficientnet-b2\": {\n","            \"out_channels\": (3, 32, 24, 48, 120, 352),\n","            \"stage_idxs\": (5, 8, 16, 23),\n","            \"weight_path\": pretrained_root + \"efficientnet-b2-27687264.pth\"\n","        },\n","        \"efficientnet-b3\": {\n","            \"out_channels\": (3, 40, 32, 48, 136, 384),\n","            \"stage_idxs\": (5, 8, 18, 26),\n","            \"weight_path\": pretrained_root + \"efficientnet-b3-c8376fa2.pth\"\n","        },\n","        \"efficientnet-b4\": {\n","            \"out_channels\": (3, 48, 32, 56, 160, 448),\n","            \"stage_idxs\": (6, 10, 22, 32),\n","            \"weight_path\": pretrained_root + \"efficientnet-b4-e116e8b3.pth\"\n","        },\n","        \"efficientnet-b5\": {\n","            \"out_channels\": (3, 48, 40, 64, 176, 768), #changed\n","            \"stage_idxs\": (8, 13, 27, 39),\n","            \"weight_path\": pretrained_root + \"efficientnet-b5-586e6cc6.pth\"\n","        },\n","        \"efficientnet-b6\": {\n","            \"out_channels\": (3, 56, 40, 72, 200, 576),\n","            \"stage_idxs\": (9, 15, 31, 45),\n","            \"weight_path\": pretrained_root + \"efficientnet-b6-c76e70fd.pth\"\n","        },\n","        \"efficientnet-b7\": {\n","            \"out_channels\": (3, 64, 48, 80, 224, 640),\n","            \"stage_idxs\": (11, 18, 38, 55),\n","            \"weight_path\": pretrained_root + \"efficientnet-b7-dcc49843.pth\"\n","        }\n","    }\n","    model = 'efficientnet-b7'\n","    \n","class EfficientNetEncoder(EfficientNet):\n","    def __init__(self, stage_idxs, out_channels, model_name, depth=5):\n","\n","        blocks_args, global_params = get_model_params(model_name, override_params=None)\n","        super().__init__(blocks_args, global_params)\n","        \n","        cfg = config.efficient_net_encoders[model_name]\n","\n","        self._stage_idxs = stage_idxs\n","        self._out_channels = out_channels\n","        self._depth = depth\n","        self._in_channels = 3\n","\n","        del self._fc\n","        self.load_state_dict(torch.load(cfg['weight_path']))\n","\n","    def get_stages(self):\n","        return [\n","            nn.Identity(),\n","            nn.Sequential(self._conv_stem, self._bn0, self._swish),\n","            self._blocks[:self._stage_idxs[0]],\n","            self._blocks[self._stage_idxs[0]:self._stage_idxs[1]],\n","            self._blocks[self._stage_idxs[1]:self._stage_idxs[2]],\n","            self._blocks[self._stage_idxs[2]:],\n","        ]\n","\n","    def forward(self, x):\n","        stages = self.get_stages()\n","\n","        block_number = 0.\n","        drop_connect_rate = self._global_params.drop_connect_rate\n","\n","        features = []\n","        for i in range(self._depth + 1):\n","\n","            # Identity and Sequential stages\n","            if i < 2:\n","                x = stages[i](x)\n","\n","            # Block stages need drop_connect rate\n","            else:\n","                for module in stages[i]:\n","                    drop_connect = drop_connect_rate * block_number / len(self._blocks)\n","                    block_number += 1.\n","                    x = module(x, drop_connect)\n","\n","            features.append(x)\n","\n","        return features\n","\n","    def load_state_dict(self, state_dict, **kwargs):\n","        state_dict.pop(\"_fc.bias\")\n","        state_dict.pop(\"_fc.weight\")\n","        super().load_state_dict(state_dict, **kwargs)  \n","        \n","\n","class EffUnet(nn.Module):\n","    def __init__(self, model_name, stride=1):\n","        super().__init__()\n","        \n","        cfg = config.efficient_net_encoders[model_name]\n","        stage_idxs = cfg['stage_idxs']\n","        out_channels = cfg['out_channels']\n","        \n","        self.encoder = EfficientNetEncoder(stage_idxs, out_channels, model_name)\n","\n","        #aspp with customized dilatations\n","        self.aspp = ASPP(out_channels[-1], 256, out_c=384, \n","                         dilations=[stride*1, stride*2, stride*3, stride*4])\n","        self.drop_aspp = nn.Dropout2d(0.5)\n","        #decoder\n","        self.dec4 = UnetBlock(384, out_channels[-2], 256)\n","        self.dec3 = UnetBlock(256, out_channels[-3], 128)\n","        self.dec2 = UnetBlock(128, out_channels[-4], 64)\n","        self.dec1 = UnetBlock(64, out_channels[-5], 32)\n","        self.fpn = FPN([384, 256, 128, 64], [16]*4)\n","        self.drop = nn.Dropout2d(0.1)\n","        self.final_conv = ConvLayer(32+16*4, 1, ks=1, norm_type=None, act_cls=None)\n","        \n","        self.rgb = RGB()\n","        \n","    def forward(self, batch):\n","        x = batch['image']\n","        B, C, H, W = x.shape\n","        x = self.rgb(x)\n","        enc0, enc1, enc2, enc3, enc4 = self.encoder(x)[-5:]\n","        enc5 = self.aspp(enc4)\n","        dec3 = self.dec4(self.drop_aspp(enc5), enc3)\n","        dec2 = self.dec3(dec3,enc2)\n","        dec1 = self.dec2(dec2,enc1)\n","        dec0 = self.dec1(dec1,enc0)\n","        x = self.fpn([enc5, dec3, dec2, dec1], dec0)\n","        x = self.final_conv(self.drop(x))\n","        x = F.interpolate(x, size = 768, mode = 'bilinear') #changed\n","        return x"]},{"cell_type":"code","execution_count":10,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.739119Z","iopub.status.busy":"2022-08-19T12:46:31.736421Z","iopub.status.idle":"2022-08-19T12:46:31.745978Z","shell.execute_reply":"2022-08-19T12:46:31.744667Z","shell.execute_reply.started":"2022-08-19T12:46:31.739080Z"},"papermill":{"duration":0.013343,"end_time":"2022-08-16T19:03:00.584292","exception":false,"start_time":"2022-08-16T19:03:00.570949","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["# net = EffUnet(config.model)\n","# del net"]},{"cell_type":"code","execution_count":11,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.754885Z","iopub.status.busy":"2022-08-19T12:46:31.752116Z","iopub.status.idle":"2022-08-19T12:46:31.768438Z","shell.execute_reply":"2022-08-19T12:46:31.767288Z","shell.execute_reply.started":"2022-08-19T12:46:31.754848Z"},"papermill":{"duration":0.016373,"end_time":"2022-08-16T19:03:00.606286","exception":false,"start_time":"2022-08-16T19:03:00.589913","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["def run_check_net():\n","    batch_size = 2\n","    image_size = 768 #512 #256 #changed\n","\n","    #---\n","    batch = {\n","        'image' : torch.from_numpy( np.random.uniform(-1,1,(batch_size,3,image_size,image_size)) ).float(),\n","        'mask'  : torch.from_numpy( np.random.choice(2,(batch_size,1,image_size,image_size)) ).float(),\n","        'organ' : torch.from_numpy( np.random.choice(5,(batch_size)) ).long(),\n","    }\n","    \n","    batch = {k:v.cuda() for k,v in batch.items()}\n","\n","    net = EffUnet(config.model).cuda()\n","\n","    with torch.no_grad():\n","        with torch.cuda.amp.autocast(enabled=True):\n","            output = net(batch)\n","\n","    print('batch')\n","    for k,v in batch.items():\n","        print('%32s :'%k, v.shape)\n","\n","    print('output')\n","    print( (' '*35 + f'{output.shape}'))\n","\n","#run_check_net()"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.00547,"end_time":"2022-08-16T19:03:00.617292","exception":false,"start_time":"2022-08-16T19:03:00.611822","status":"completed"},"tags":[]},"source":["## Folds"]},{"cell_type":"code","execution_count":12,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.778079Z","iopub.status.busy":"2022-08-19T12:46:31.774802Z","iopub.status.idle":"2022-08-19T12:46:31.797603Z","shell.execute_reply":"2022-08-19T12:46:31.793385Z","shell.execute_reply.started":"2022-08-19T12:46:31.778043Z"},"papermill":{"duration":0.017484,"end_time":"2022-08-16T19:03:00.640381","exception":false,"start_time":"2022-08-16T19:03:00.622897","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["def make_fold(fold = 3):\n","    df = pd.read_csv(LABELS)\n","\n","    num_fold = 4\n","    skf = KFold(n_splits = num_fold, shuffle = True,random_state = 42)\n","\n","    df.loc[:,'fold']=-1\n","    for f,(t_idx, v_idx) in enumerate(skf.split(X=df['id'], y=df['organ'])):\n","        df.iloc[v_idx,-1]=f\n","\n","    #check\n","    if 0:\n","        for f in range(num_fold):\n","            train_df=df[df.fold!=f].reset_index(drop=True)\n","            valid_df=df[df.fold==f].reset_index(drop=True)\n","\n","            print('fold %d'%f)\n","            t = train_df.organ.value_counts().to_dict()\n","            v = valid_df.organ.value_counts().to_dict()\n","            for k in ['kidney', 'prostate', 'largeintestine', 'spleen', 'lung']:\n","                print('%32s %3d (%0.3f)  %3d (%0.3f)'%(k,t.get(k,0),t.get(k,0)/len(train_df),v.get(k,0),v.get(k,0)/len(valid_df)))\n","\n","            print('')\n","            zz=0\n","\n","    train_df=df[df.fold!=fold].reset_index(drop=True)\n","    valid_df=df[df.fold==fold].reset_index(drop=True)\n","    return train_df,valid_df"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.005895,"end_time":"2022-08-16T19:03:00.651958","exception":false,"start_time":"2022-08-16T19:03:00.646063","status":"completed"},"tags":[]},"source":["## Competition metric"]},{"cell_type":"code","execution_count":13,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.799520Z","iopub.status.busy":"2022-08-19T12:46:31.798756Z","iopub.status.idle":"2022-08-19T12:46:31.809293Z","shell.execute_reply":"2022-08-19T12:46:31.807888Z","shell.execute_reply.started":"2022-08-19T12:46:31.799483Z"},"papermill":{"duration":0.013577,"end_time":"2022-08-16T19:03:00.671364","exception":false,"start_time":"2022-08-16T19:03:00.657787","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["def compute_dice_score(probability, mask, smooth = 1):\n","    N = len(probability)\n","    p = probability.reshape(N,-1)\n","    t = mask.reshape(N,-1)\n","\n","    p = p>0.5\n","    t = t>0.5\n","    uion = p.sum(-1) + t.sum(-1)\n","    overlap = (p*t).sum(-1)\n","    dice = 2*overlap/(uion+0.0001)\n","    return dice"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.005378,"end_time":"2022-08-16T19:03:00.682366","exception":false,"start_time":"2022-08-16T19:03:00.676988","status":"completed"},"tags":[]},"source":["## Validation"]},{"cell_type":"code","execution_count":14,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.811352Z","iopub.status.busy":"2022-08-19T12:46:31.810889Z","iopub.status.idle":"2022-08-19T12:46:31.831948Z","shell.execute_reply":"2022-08-19T12:46:31.830506Z","shell.execute_reply.started":"2022-08-19T12:46:31.811305Z"},"papermill":{"duration":0.01812,"end_time":"2022-08-16T19:03:00.706195","exception":false,"start_time":"2022-08-16T19:03:00.688075","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["def validate(net, valid_loader, debug = False):\n","    \n","    valid_num = 0\n","    valid_probability = []\n","    valid_mask = []\n","    valid_loss = 0\n","    \n","    criterion = nn.BCEWithLogitsLoss()\n","    \n","    net = net.eval()\n","    start_timer = time.time()\n","    \n","    for t, batch in enumerate(valid_loader):\n","        \n","        with torch.no_grad():\n","            with amp.autocast(enabled = is_amp):\n","                \n","                batch_size = len(batch['index'])\n","                batch['image'] = batch['image'].cuda()\n","                batch['mask' ] = batch['mask' ].cuda()\n","                batch['organ'] = batch['organ'].cuda()\n","\n","                output = net(batch)\n","                \n","                batch['mask'] = batch['mask'].unsqueeze(1)\n","                loss = criterion(output, batch['mask'])\n","        \n","        valid_probability.append(output.data.cpu().numpy())\n","        valid_mask.append(batch['mask'].data.cpu().numpy())\n","        valid_num += batch_size\n","        valid_loss += batch_size * loss.item()\n","        \n","        print('\\r %8d / %d  %s'%(valid_num, len(valid_loader.dataset),(time.time() - start_timer)),end='',flush=True)\n","    \n","    assert(valid_num == len(valid_loader.dataset))\n","\n","    probability = np.concatenate(valid_probability)\n","    mask = np.concatenate(valid_mask)\n","\n","    loss = valid_loss/valid_num\n","\n","    dice = compute_dice_score(probability, mask)\n","    dice = dice.mean()\n","    \n","    return [dice, loss]"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.00551,"end_time":"2022-08-16T19:03:00.717363","exception":false,"start_time":"2022-08-16T19:03:00.711853","status":"completed"},"tags":[]},"source":["## Initialize"]},{"cell_type":"code","execution_count":15,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:31.839475Z","iopub.status.busy":"2022-08-19T12:46:31.837043Z","iopub.status.idle":"2022-08-19T12:46:41.546150Z","shell.execute_reply":"2022-08-19T12:46:41.545047Z","shell.execute_reply.started":"2022-08-19T12:46:31.839439Z"},"papermill":{"duration":8.210001,"end_time":"2022-08-16T19:03:08.932978","exception":false,"start_time":"2022-08-16T19:03:00.722977","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["criterion = nn.BCEWithLogitsLoss()\n","\n","fold = 3\n","\n","out_dir = root_dir + '/result/effnetb7/fold-%d' % (fold)\n","initial_checkpoint = None\n","\n","start_lr = 5e-5\n","batch_size = 8\n","\n","## setup  ----------------------------------------\n","for f in ['checkpoint','train','valid','backup'] : os.makedirs(out_dir +'/'+f, exist_ok=True)\n","\n","\n","log = open(out_dir+'/log.train.txt',mode='a')\n","log.write('\\n--- [START %s] %s\\n\\n' % ('EfficientNet-b7', '-' * 64))\n","log.write('\\n')\n","\n","## dataset ----------------------------------------\n","log.write('** dataset setting **\\n')\n","\n","train_df, valid_df = make_fold(fold)\n","\n","train_dataset = HubmapDataset(train_df, train_augment5b)\n","valid_dataset = HubmapDataset(valid_df, valid_augment5)\n","\n","train_loader  = DataLoader(\n","    train_dataset,\n","    sampler = RandomSampler(train_dataset),\n","    batch_size  = 2,\n","    drop_last   = True,\n","    num_workers = 8,\n","    pin_memory  = False,\n","    worker_init_fn = lambda id: np.random.seed(torch.initial_seed() // 2 ** 32 + id)\n",")\n","\n","valid_loader = DataLoader(\n","    valid_dataset,\n","    sampler = SequentialSampler(valid_dataset),\n","    batch_size  = 2,\n","    drop_last   = False,\n","    num_workers = 4,\n","    pin_memory  = False\n",")\n","\n","\n","log.write('fold = %s\\n'%str(fold))\n","log.write('train_dataset : \\n%s\\n'%(train_dataset))\n","log.write('valid_dataset : \\n%s\\n'%(valid_dataset))\n","log.write('\\n')\n","\n","\n","## net ----------------------------------------\n","log.write('** net setting **\\n')\n","\n","scaler = amp.GradScaler(enabled = is_amp)\n","net = EffUnet(config.model).cuda()\n","\n","if initial_checkpoint is not None:\n","    f = torch.load(initial_checkpoint, map_location=lambda storage, loc: storage)\n","    start_iteration = f['iteration']\n","    start_epoch = f['epoch']\n","    state_dict  = f['state_dict']\n","    net.load_state_dict(state_dict,strict=False)  #True\n","else:\n","    start_iteration = 0\n","    start_epoch = 0\n","\n","\n","log.write('\\tinitial_checkpoint = %s\\n' % initial_checkpoint)\n","log.write('\\n')\n","\n","\n","## optimiser ----------------------------------\n","if 0: ##freeze\n","    for p in net.stem.parameters():   p.requires_grad = False\n","    pass\n","\n","def freeze_bn(net):\n","    for m in net.modules():\n","        if isinstance(m, nn.BatchNorm2d):\n","            m.eval()\n","            m.weight.requires_grad = False\n","            m.bias.requires_grad = False\n","            \n","#freeze_bn(net)\n","\n","#-----------------------------------------------\n","\n","optimizer = torch.optim.AdamW(filter(lambda p: p.requires_grad, net.parameters()),lr=start_lr)\n","#optimizer = Lookahead(RAdam(filter(lambda p: p.requires_grad, net.parameters()),lr=start_lr), alpha=0.5, k=5)\n","\n","log.write('optimizer\\n  %s\\n'%(optimizer))\n","log.write('\\n')\n","\n","#num_iteration = 1000*len(train_loader)\n","num_iteration = 9000\n","iter_log   = len(train_loader)*3 #479\n","iter_valid = iter_log\n","iter_save  = iter_log"]},{"cell_type":"code","execution_count":16,"metadata":{},"outputs":[{"data":{"text/plain":["torch.Size([2, 3, 768, 768])"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["next(iter(valid_loader))[\"image\"].shape"]},{"cell_type":"markdown","metadata":{"papermill":{"duration":0.006146,"end_time":"2022-08-16T19:03:08.945358","exception":false,"start_time":"2022-08-16T19:03:08.939212","status":"completed"},"tags":[]},"source":["## Training"]},{"cell_type":"code","execution_count":17,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:46:41.552290Z","iopub.status.busy":"2022-08-19T12:46:41.551585Z","iopub.status.idle":"2022-08-19T12:58:32.521263Z","shell.execute_reply":"2022-08-19T12:58:32.519298Z","shell.execute_reply.started":"2022-08-19T12:46:41.552251Z"},"papermill":{"duration":2131.600859,"end_time":"2022-08-16T19:38:40.552279","exception":false,"start_time":"2022-08-16T19:03:08.951420","status":"completed"},"tags":[],"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["5.00e-5   00000131    0.99 | 0.000  0.498   | 0.012   | 68.2176632881164648   | 0.099   | 8.708357572555542\n","5.00e-5   00000263    1.99 | 0.000  0.498   | 0.037   | 129.66104507446297\n","5.00e-5   00000395    2.99 | 0.000  0.498   | 0.012   | 191.17116212844852\n","5.00e-5   00000402    3.05 | 0.068  0.233   | 0.036   | 205.044605016708373   | 0.024   | 202.3205623626709"]},{"ename":"KeyboardInterrupt","evalue":"","output_type":"error","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m/tmp/ipykernel_16082/337430377.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     68\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m             \u001b[0mscaler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscale\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m~/somusan/hubmap_kaggle/.venv/lib/python3.7/site-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m    394\u001b[0m                 \u001b[0mcreate_graph\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    395\u001b[0m                 inputs=inputs)\n\u001b[0;32m--> 396\u001b[0;31m         \u001b[0mtorch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mautograd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    397\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    398\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mregister_hook\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhook\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m~/somusan/hubmap_kaggle/.venv/lib/python3.7/site-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m    173\u001b[0m     Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass\n\u001b[1;32m    174\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 175\u001b[0;31m         allow_unreachable=True, accumulate_grad=True)  # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m    176\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    177\u001b[0m def grad(\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "]}],"source":["log.write('** start training here! **\\n')\n","log.write('   batch_size = %d \\n'%(batch_size))\n","log.write('                     |-------------- VALID ---------|---- TRAIN/BATCH ----------------\\n')\n","log.write('rate     iter  epoch | dice   loss   tp     tn     | loss           | time           \\n')\n","log.write('-------------------------------------------------------------------------------------\\n')\n","\n","valid_loss = np.zeros(2,np.float32)\n","best_val_dice = 0.0\n","train_loss = 0\n","batch_loss = 0\n","sum_train_loss = 0\n","sum_train = 0\n","\n","start_timer = time.time()\n","iteration = start_iteration\n","epoch = start_epoch\n","rate = 0\n","accum_iter = 8 \n","\n","while iteration < num_iteration:\n","    for t, batch in enumerate(train_loader):\n","        \n","#         print(\"#------------------\")\n","#         print(\"valid losss\", valid_loss[0])\n","#         print(\"best val dice\", best_val_dice)\n","#         print(\"#------------------\")\n","        \n","        if iteration%iter_save==0:\n","            if iteration != start_iteration:\n","                torch.save({\n","                    'state_dict': net.state_dict(),\n","                    'iteration': iteration,\n","                    'epoch': epoch,\n","                }, out_dir + '/checkpoint/%08d.model.pth' %  (iteration))\n","                pass\n","\n","\n","        if (iteration%iter_valid==0):\n","            valid_loss = validate(net, valid_loader)\n","            pass\n","\n","\n","        if (iteration%iter_log==0) or (iteration%iter_valid==0):\n","            print('\\r', end='', flush=True)\n","            log.write(message(mode='log') + '\\n')\n","\n","\n","        # learning rate schduler ------------\n","        rate = get_learning_rate(optimizer)\n","\n","        # one iteration update  -------------\n","        batch_size = len(batch['index'])\n","        \n","        #print(batch_size, iteration, epoch)\n","        batch['image'] = batch['image'].half().cuda()\n","        batch['mask' ] = batch['mask' ].half().cuda()\n","        batch['organ'] = batch['organ'].cuda()\n","        \n","        \n","        net.train()\n","        net.output_type = ['loss']\n","        if 1:\n","            with amp.autocast(enabled = is_amp):\n","                output = net(batch)\n","                batch['mask'] = batch['mask'].unsqueeze(1)\n","                loss = criterion(output, batch['mask'])\n","                loss = loss / accum_iter \n","                \n","            \n","            scaler.scale(loss).backward()\n","\n","            \n","            \n","            if ((t + 1) % accum_iter == 0) or (t + 1 == len(train_loader)):\n","                scaler.unscale_(optimizer)\n","                scaler.step(optimizer)\n","                scaler.update()\n","                optimizer.zero_grad()\n","                \n","                \n","        # print statistics  --------\n","        batch_loss = loss.item()\n","        sum_train_loss += batch_loss\n","        sum_train += 1\n","        if t % 100 == 0:\n","            train_loss = sum_train_loss / (sum_train + 1e-12)\n","            sum_train_loss = 0\n","            sum_train = 0\n","\n","        print('\\r', end='', flush=True)\n","        print(message(mode='print'), end='', flush=True)\n","        \n","        epoch += 1 / len(train_loader)\n","        iteration += 1\n","    print()\n","    torch.cuda.empty_cache()\n","    \n","log.write('\\n')\n","log.close()"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2022-08-19T12:58:38.277233Z","iopub.status.busy":"2022-08-19T12:58:38.276761Z","iopub.status.idle":"2022-08-19T12:58:39.622813Z","shell.execute_reply":"2022-08-19T12:58:39.621520Z","shell.execute_reply.started":"2022-08-19T12:58:38.277193Z"},"trusted":true},"outputs":[],"source":["!tree ."]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.status.busy":"2022-08-19T12:58:32.526476Z","iopub.status.idle":"2022-08-19T12:58:32.527264Z","shell.execute_reply":"2022-08-19T12:58:32.527027Z","shell.execute_reply.started":"2022-08-19T12:58:32.527003Z"},"papermill":{"duration":0.110188,"end_time":"2022-08-16T19:38:40.786715","exception":false,"start_time":"2022-08-16T19:38:40.676527","status":"completed"},"tags":[],"trusted":true},"outputs":[],"source":["import gc\n","import torch\n","gc.collect()\n","torch.cuda.empty_cache()"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":[]},{"cell_type":"markdown","metadata":{},"source":["# Ideas to try:\n","\n","- use different loss ------------------------------------------------------------ [ ]\n","- use swa  --------------------------------------------------------------------------- [x]\n","- use LR sch ----------------------------------------------------------------------- [ ]\n","- try different ways of doing grad accum ---------------------------- [ ]\n","- train on patches -------------------------------------------------------------- [ ]\n","- change opt ---------------------------------------------------------------------- [ ]\n","- move to unet+swin --------------------------------------------------------- [ ]\n","- train on different folds ---------------------------------------------------- [ ]"]},{"cell_type":"markdown","metadata":{},"source":[]},{"cell_type":"markdown","metadata":{},"source":[]}],"metadata":{"kernelspec":{"display_name":"Python 3.7.0 ('.venv': venv)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.0"},"vscode":{"interpreter":{"hash":"21a2a557654fc1676068684031cf9bb9dfda94e124d3623f4e9c9ed764d794ac"}}},"nbformat":4,"nbformat_minor":4}