_lb0-68-one-fold-stacked-unet-train.ipynb

{"cells":[{"attachments":{},"cell_type":"markdown","metadata":{},"source":["for dicsussion, refer to https://www.kaggle.com/competitions/vesuvius-challenge-ink-detection/discussion/407972#2272189"]},{"cell_type":"code","execution_count":19,"metadata":{},"outputs":[],"source":["# import sys\n","# sys.path.append('/kaggle/input/ink-00/my_lib')\n","# sys.path.append('/kaggle/input/pretrainedmodels/pretrainedmodels-0.7.4')\n","# sys.path.append('/kaggle/input/efficientnet-pytorch/EfficientNet-PyTorch-master')\n","# sys.path.append('/kaggle/input/timm-pytorch-image-models/pytorch-image-models-master')\n","# sys.path.append('/kaggle/input/segmentation-models-pytorch/segmentation_models.pytorch-master')\n","# sys.path.append('/kaggle/input/einops/einops-master')"]},{"cell_type":"code","execution_count":20,"metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","execution":{"iopub.execute_input":"2023-05-23T14:27:12.625278Z","iopub.status.busy":"2023-05-23T14:27:12.624772Z","iopub.status.idle":"2023-05-23T14:27:19.728486Z","shell.execute_reply":"2023-05-23T14:27:19.727509Z","shell.execute_reply.started":"2023-05-23T14:27:12.625239Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["import ok !!!\n"]}],"source":["import hashlib\n","import numpy as np\n","import pandas as pd\n","from dotdict import dotdict\n","from time import time\n","\n","\n","from collections import defaultdict\n","from glob import glob\n","import PIL.Image as Image\n","Image.MAX_IMAGE_PIXELS = 10000000000  # Ignore PIL warnings about large images\n","\n","import cv2\n","\n","import torch\n","import torch.nn as nn\n","import torch.nn.functional as F\n","\n","from einops import rearrange, reduce, repeat\n","import segmentation_models_pytorch as smp\n","from segmentation_models_pytorch.decoders.unet.decoder import UnetDecoder, DecoderBlock\n","from timm.models.resnet import resnet10t, resnet34d\n","\n","import numpy as np\n","import torch\n","import torch.nn as nn\n","import torchvision\n","import datetime\n","# import cupy\n","import albumentations as A\n","from albumentations.pytorch import ToTensorV2\n","import pytorch_lightning\n","import segmentation_models_pytorch as smp\n","import pytorch_lightning as pl\n","import pytorch_lightning.plugins\n","from skimage.transform import resize as resize_ski\n","from pytorch_lightning.strategies.ddp import DDPStrategy\n","from pytorch_lightning.loggers import WandbLogger\n","import os\n","\n","\n","from scipy.ndimage import distance_transform_edt\n","\n","import glob\n","import time\n","import PIL.Image as Image\n","import matplotlib.pyplot as plt\n","import matplotlib.pyplot as plt\n","from matplotlib.patches import Rectangle\n","import matplotlib.patches as patches\n","from sklearn.model_selection import KFold\n","from tqdm import tqdm\n","import cv2\n","import torch\n","import torch.nn as nn\n","import torch.optim as optim\n","import torch.utils.data\n","\n","import matplotlib\n","import matplotlib.pyplot as plt\n","#matplotlib.use('TkAgg')\n","%matplotlib inline \n","  \n","print('import ok !!!')"]},{"cell_type":"code","execution_count":21,"metadata":{},"outputs":[],"source":["def time_to_str(time):\n","    h = time // 3600\n","    m = (time % 3600) // 60\n","    s = time % 60\n","    return f\"{h:02f}, {m:02f}, {s:02f}\""]},{"cell_type":"code","execution_count":22,"metadata":{"execution":{"iopub.execute_input":"2023-05-23T14:27:19.731309Z","iopub.status.busy":"2023-05-23T14:27:19.730717Z","iopub.status.idle":"2023-05-23T14:27:19.741486Z","shell.execute_reply":"2023-05-23T14:27:19.740450Z","shell.execute_reply.started":"2023-05-23T14:27:19.731273Z"},"trusted":true},"outputs":[{"ename":"TabError","evalue":"inconsistent use of tabs and spaces in indentation (2396625376.py, line 13)","output_type":"error","traceback":["\u001b[0;36m  Input \u001b[0;32mIn [22]\u001b[0;36m\u001b[0m\n\u001b[0;31m    batch_size = 64\u001b[0m\n\u001b[0m                   ^\u001b[0m\n\u001b[0;31mTabError\u001b[0m\u001b[0;31m:\u001b[0m inconsistent use of tabs and spaces in indentation\n"]}],"source":["class Config(object):\n","\tmode = [\n","\t\t'train', #\n","\t\t# 'test', 'skip_fake_test',\n","\t]\n","\tcrop_fade  = 56\n","\tcrop_size  = 384\n","\tcrop_depth = 5\n","\tinfer_fragment_z = [28, 37]\n","\tthreshold = 0.5\n","\tbatch_size = 64\n","\tlr = 1e-4\n","\tbatch_size = 64\n","\tnum_workers = 8\n","\n","\n","CFG = Config()\n","CFG.is_tta = True #True\n","\n","\n","if 'train' in CFG.mode:\n","\tCFG.stride = CFG.crop_size//2\n","if 'test' in CFG.mode:\n","\tCFG.stride = CFG.crop_size//2\n","\n","\n","def cfg_to_text():\n","    d = Config.__dict__\n","    text = [f'\\t{k} : {v}' for k,v in d.items() if not (k.startswith('__') and k.endswith('__'))]\n","    d = CFG.__dict__\n","    text += [f'\\t{k} : {v}' for k,v in d.items() if not (k.startswith('__') and k.endswith('__'))]\n","    return 'CFG\\n'+'\\n'.join(text)\n","\n","print(cfg_to_text())"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-05-23T14:27:19.744030Z","iopub.status.busy":"2023-05-23T14:27:19.743332Z","iopub.status.idle":"2023-05-23T14:27:19.764990Z","shell.execute_reply":"2023-05-23T14:27:19.763996Z","shell.execute_reply.started":"2023-05-23T14:27:19.743998Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["data_dir /home/fummicc1/codes/Kaggle/kaggle-ink-detection/train\n","valid_id ['1']\n","data ok !!!\n"]}],"source":["## dataset ##\n","if 'train' in CFG.mode:\n","\tdata_dir = '/home/fummicc1/codes/Kaggle/kaggle-ink-detection/train'\n","\tvalid_id =[\n","\t    '1',#'2b',\n","\t]\n","\ttrain_id = [\n","\t\t\"2\", \"3\"\n","  \t]\n","\n","if 'test' in CFG.mode: \n","\tdata_dir = '/kaggle/input/vesuvius-challenge-ink-detection/test'\n","\tvalid_id = glob(f'{data_dir}/*')\n","\tvalid_id = sorted(valid_id)\n","\tvalid_id = [f.split('/')[-1] for f in valid_id]\n","    \n","\t# https://www.kaggle.com/competitions/vesuvius-challenge-ink-detection/discussion/410985\n","\ta_file = f'{data_dir}/a/mask.png'\n","\twith open(a_file,'rb') as f:\n","\t\thash_md5 = hashlib.md5(f.read()).hexdigest()\n","\tis_skip_test = hash_md5 == '0b0fffdc0e88be226673846a143bb3e0'\n","\tprint('is_skip_test:',is_skip_test)\n","\n","#---\n","print('data_dir', data_dir)\n","print('valid_id', valid_id)\n","\n","def do_binarise(m, threshold=0.5):\n","    m = m-m.min()\n","    m = m/(m.max()+1e-7)\n","    m = (m>threshold).astype(np.float32)\n","    return m\n","\n","def read_data(fragment_id, z0=CFG.infer_fragment_z[0], z1=CFG.infer_fragment_z[1]):\n","    volume = []\n","    start_timer = time()\n","    for i in range(z0,z1):\n","        v = np.array(Image.open(f'{data_dir}/{fragment_id}/surface_volume/{i:02d}.tif'), dtype=np.uint16)\n","        v = (v >> 8).astype(np.uint8)\n","        #v = (v / 65535.0 * 255).astype(np.uint8)\n","        volume.append(v)\n","        print(f'\\r @ read_data(): volume{fragment_id}  {time_to_str(time() - start_timer)}', end='', flush=True)\n","    #print('')\n","    volume = np.stack(volume, -1)\n","    height, width, depth = volume.shape\n","    #print(f'fragment_id={fragment_id} volume: {volume.shape}')\n","\n","    #---\n","    mask = cv2.imread(f'{data_dir}/{fragment_id}/mask.png',cv2.IMREAD_GRAYSCALE)\n","    mask = do_binarise(mask)\n","\n","    if 'train' in CFG.mode:\n","        ir    = cv2.imread(f'{data_dir}/{fragment_id}/ir.png',cv2.IMREAD_GRAYSCALE)\n","        label = cv2.imread(f'{data_dir}/{fragment_id}/inklabels.png',cv2.IMREAD_GRAYSCALE)\n","        ir    = ir/255\n","        label = do_binarise(label)\n","\n","    if 'test' in CFG.mode:\n","        ir = None\n","        label = None\n","\n","    d = dotdict(\n","        fragment_id = fragment_id,\n","        volume = volume,\n","        ir     = ir,\n","        label  = label,\n","        mask   = mask,\n","    )\n","    return d\n","\n","def read_data1(fragment_id):\n","\tif fragment_id=='2a':\n","\t\ty = 9456\n","\t\td = read_data('2') \n","\t\td = dotdict(\n","\t\t\tfragment_id='2a',\n","\t\t\tvolume  = d.volume[:y],\n","\t\t\tir      = d.ir[:y],\n","\t\t\tlabel   = d.label[:y],\n","\t\t\tmask    = d.mask[:y],\n","\t\t)\n","\telif  fragment_id=='2b':\n","\t\ty = 9456\n","\t\td = read_data('2') \n","\t\td = dotdict(\n","\t\t\tfragment_id='2b',\n","\t\t\tvolume  = d.volume[y:],\n","\t\t\tir      = d.ir[y:],\n","\t\t\tlabel   = d.label[y:],\n","\t\t\tmask    = d.mask[y:],\n","\t\t)\n","\telse:\n","\t\td = read_data(fragment_id)\n","\treturn d\n","\n","def run_check_data():\n","    d=read_data1(valid_id[0])#valid_id[0]\n","    print('')\n","    print('fragment_id:', d.fragment_id)\n","    print('volume:', d.volume.shape, d.volume.min(), d.volume.max())\n","    print('mask  :', d.mask.shape, d.mask.min(), d.mask.max())\n","    if 'train' in CFG.mode:\n","        print('ir    :', d.ir.shape, d.ir.min(), d.ir.max())\n","        print('label :', d.label.shape, d.label.min(), d.label.max())\n","\n","#run_check_data()\n","print('data ok !!!')"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["def load_mask(split, index):\n","    img = cv2.imread(f\"{data_dir}/{split}/{index}/mask.png\", 0) // 255\n","    return img\n","\n","\n","def load_labels(split, index):\n","    img = cv2.imread(f\"{data_dir}/{split}/{index}/inklabels.png\", 0) // 255\n","    return img"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# ref - https://www.kaggle.com/competitions/vesuvius-challenge-ink-detection/discussion/397288\n","def fbeta_score(preds, targets, threshold, beta=0.5, smooth=1e-5):\n","    preds_t = torch.where(preds > threshold, 1.0, 0.0).float()\n","    y_true_count = targets.sum()\n","\n","    ctp = preds_t[targets == 1].sum()\n","    cfp = preds_t[targets == 0].sum()\n","    beta_squared = beta * beta\n","\n","    c_precision = ctp / (ctp + cfp + smooth)\n","    c_recall = ctp / (y_true_count + smooth)\n","    dice = (\n","        (1 + beta_squared)\n","        * (c_precision * c_recall)\n","        / (beta_squared * c_precision + c_recall + smooth)\n","    )\n","\n","    return dice"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["def extract(location, volume):\n","    global printed\n","    x = location[0]\n","    y = location[1]\n","    subvolume = volume[x - CFG.crop_size : x + CFG.crop_size, y - CFG.crop_size : y + CFG.crop_size, :].astype(\n","        np.float32\n","    )\n","\n","    return subvolume"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["import torch\n","from torch.utils.data import Dataset, DataLoader\n","from sklearn.preprocessing import OneHotEncoder\n","\n","from albumentations.core.transforms_interface import ImageOnlyTransform\n","\n","\n","class SubvolumeDataset(Dataset):\n","    def __init__(\n","        self,\n","        locations,\n","        volume,\n","        labels,\n","        masks,\n","        buffer,\n","        is_train: bool,\n","        return_location: bool = False,\n","    ):\n","        self.locations = locations\n","        self.volume = volume\n","        self.labels = labels\n","        self.masks = masks\n","        self.buffer = buffer\n","        self.is_train = is_train\n","        self.return_location = return_location\n","\n","    def __len__(self):\n","        return len(self.locations)\n","\n","    def __getitem__(self, idx):\n","        label = None\n","        location = np.array(self.locations[idx])\n","        y, x = location[0], location[1]\n","\n","        subvolume = extract(location, self.volume)\n","        mask = extract(location, self.masks)\n","        mask = np.stack([mask], axis=-1)\n","\n","        if self.labels is not None:\n","            label = self.labels[\n","                y - self.buffer : y + self.buffer, x - self.buffer : x + self.buffer\n","            ]\n","            label = np.stack([label], axis=-1)\n","\n","        if self.is_train and label is not None:\n","            transformed = A.Compose(\n","                [\n","                    A.HorizontalFlip(p=0.5),\n","                    A.VerticalFlip(p=0.5),\n","                    A.Transpose(p=0.5),\n","                    A.RandomScale(p=0.5),\n","                    A.RandomRotate90(p=0.5),\n","                    A.ShiftScaleRotate(p=0.75),\n","                    A.GridDropout(p=0.15),\n","                    A.Resize(height=self.buffer * 2, width=self.buffer * 2),\n","                ]\n","            )(image=subvolume, mask=label)\n","            subvolume = transformed[\"image\"]\n","            label = transformed[\"mask\"]\n","            subvolume = np.transpose(subvolume, (2, 0, 1))\n","            label = np.transpose(label, (2, 0, 1))\n","            subvolume /= 255.0\n","            subvolume = (subvolume - 0.45) / 0.225\n","            return subvolume, label\n","        else:\n","            # print(\"subvolume in val dataset (before aug)\", subvolume, file=open(\"before-val-aug.log\", \"w\"))\n","            subvolume = np.transpose(subvolume, (2, 0, 1))\n","            label = np.transpose(label, (2, 0, 1))\n","            mask = np.transpose(mask, (2, 0, 1))\n","            subvolume /= 255.0\n","            subvolume = (subvolume - 0.45) / 0.225\n","        return subvolume, label, mask"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-05-23T14:27:19.768197Z","iopub.status.busy":"2023-05-23T14:27:19.767528Z","iopub.status.idle":"2023-05-23T14:27:26.346770Z","shell.execute_reply":"2023-05-23T14:27:26.345867Z","shell.execute_reply.started":"2023-05-23T14:27:19.768163Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["batch\n","                          volume : torch.Size([3, 9, 384, 384]) \n","output\n","                             ink : torch.Size([3, 1, 384, 384]) \n","net ok !!!\n"]}],"source":["## model ##\n","class SmpUnetDecoder(nn.Module):\n","    def __init__(\n","        self,\n","        in_channel,\n","        skip_channel,\n","        out_channel,\n","    ):\n","        super().__init__()\n","        self.center = nn.Identity()\n","\n","        i_channel = [\n","            in_channel,\n","        ] + out_channel[:-1]\n","        s_channel = skip_channel\n","        o_channel = out_channel\n","        block = [\n","            DecoderBlock(i, s, o, use_batchnorm=True, attention_type=None)\n","            for i, s, o in zip(i_channel, s_channel, o_channel)\n","        ]\n","        self.block = nn.ModuleList(block)\n","\n","    def forward(self, feature, skip):\n","        d = self.center(feature)\n","        decode = []\n","        for i, block in enumerate(self.block):\n","            s = skip[i]\n","            d = block(d, s)\n","            decode.append(d)\n","\n","        last = d\n","        return last, decode\n","\n","\n","class Net(nn.Module):\n","    def __init__(\n","        self,\n","    ):\n","        super().__init__()\n","        self.output_type = [\"inference\", \"loss\"]\n","\n","        conv_dim = 64\n","        encoder1_dim = [\n","            conv_dim,\n","            64,\n","            128,\n","            256,\n","            512,\n","        ]\n","        decoder1_dim = [\n","            256,\n","            128,\n","            64,\n","            64,\n","        ]\n","\n","        self.encoder1 = resnet34d(pretrained=False, in_chans=CFG.crop_depth)\n","\n","        self.decoder1 = SmpUnetDecoder(\n","            in_channel=encoder1_dim[-1],\n","            skip_channel=encoder1_dim[:-1][::-1],\n","            out_channel=decoder1_dim,\n","        )\n","        # -- pool attention weight\n","        self.weight1 = nn.ModuleList(\n","            [\n","                nn.Sequential(\n","                    nn.Conv2d(dim, dim, kernel_size=3, padding=1),\n","                    nn.ReLU(inplace=True),\n","                )\n","                for dim in encoder1_dim\n","            ]\n","        )\n","        self.logit1 = nn.Conv2d(decoder1_dim[-1], 1, kernel_size=1)\n","\n","        # --------------------------------\n","        #\n","        encoder2_dim = [64, 128, 256, 512]  #\n","        decoder2_dim = [\n","            128,\n","            64,\n","            32,\n","        ]\n","        self.encoder2 = resnet10t(pretrained=False, in_chans=decoder1_dim[-1])\n","\n","        self.decoder2 = SmpUnetDecoder(\n","            in_channel=encoder2_dim[-1],\n","            skip_channel=encoder2_dim[:-1][::-1],\n","            out_channel=decoder2_dim,\n","        )\n","        self.logit2 = nn.Conv2d(decoder2_dim[-1], 1, kernel_size=1)\n","\n","    def forward(self, batch):\n","        v = batch[\"volume\"]\n","        B, C, H, W = v.shape\n","        vv = [\n","            v[:, i : i + CFG.crop_depth]\n","            for i in [\n","                0,\n","                2,\n","                4,\n","            ]\n","        ]\n","        K = len(vv)\n","        x = torch.cat(vv, 0)\n","        # x = v\n","\n","        # ----------------------\n","        encoder = []\n","        e = self.encoder1\n","        x = e.conv1(x)\n","        x = e.bn1(x)\n","        x = e.act1(x)\n","        encoder.append(x)\n","        x = F.avg_pool2d(x, kernel_size=2, stride=2)\n","        x = e.layer1(x)\n","        encoder.append(x)\n","        x = e.layer2(x)\n","        encoder.append(x)\n","        x = e.layer3(x)\n","        encoder.append(x)\n","        x = e.layer4(x)\n","        encoder.append(x)\n","        # print('encoder', [f.shape for f in encoder])\n","\n","        for i in range(len(encoder)):\n","            e = encoder[i]\n","            f = self.weight1[i](e)\n","            _, c, h, w = e.shape\n","            f = rearrange(f, \"(K B) c h w -> B K c h w\", K=K, B=B, h=h, w=w)  #\n","            e = rearrange(e, \"(K B) c h w -> B K c h w\", K=K, B=B, h=h, w=w)  #\n","            w = F.softmax(f, 1)\n","            e = (w * e).sum(1)\n","            encoder[i] = e\n","\n","        feature = encoder[-1]\n","        skip = encoder[:-1][::-1]\n","        last, decoder = self.decoder1(feature, skip)\n","        logit1 = self.logit1(last)\n","\n","        # ----------------------\n","        x = last  # .detach()\n","        # x = F.avg_pool2d(x,kernel_size=2,stride=2)\n","        encoder = []\n","        e = self.encoder2\n","        x = e.layer1(x)\n","        encoder.append(x)\n","        x = e.layer2(x)\n","        encoder.append(x)\n","        x = e.layer3(x)\n","        encoder.append(x)\n","        x = e.layer4(x)\n","        encoder.append(x)\n","\n","        feature = encoder[-1]\n","        skip = encoder[:-1][::-1]\n","        last, decoder = self.decoder2(feature, skip)\n","        logit2 = self.logit2(last)\n","        logit2 = F.interpolate(\n","            logit2, size=(H, W), mode=\"bilinear\", align_corners=False, antialias=True\n","        )\n","\n","        output = {\n","            \"ink\": torch.sigmoid(logit2),\n","        }\n","        return output\n","\n","\n","def run_check_net():\n","    height, width = CFG.crop_size, CFG.crop_size\n","    depth = CFG.infer_fragment_z[1] - CFG.infer_fragment_z[0]\n","    batch_size = 3\n","\n","    batch = {\n","        \"volume\": torch.from_numpy(\n","            np.random.choice(256, (batch_size, depth, height, width))\n","        )\n","        .cuda()\n","        .float(),\n","    }\n","    net = Net().cuda()\n","\n","    with torch.no_grad():\n","        with torch.cuda.amp.autocast(enabled=True):\n","            output = net(batch)\n","\n","    # ---\n","    print(\"batch\")\n","    for k, v in batch.items():\n","        print(f\"{k:>32} : {v.shape} \")\n","\n","    print(\"output\")\n","    for k, v in output.items():\n","        print(f\"{k:>32} : {v.shape} \")\n","\n","\n","run_check_net()\n","print(\"net ok !!!\")"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["###### infer here !!!!\n","# https://gist.github.com/janpaul123/ca3477c1db6de4346affca37e0e3d5b0\n","def mask_to_rle(mask):\n","    m = mask.reshape(-1)\n","    # m = np.where(mask > threshold, 1, 0).astype(np.uint8)\n","\n","    s = np.array((m[:-1] == 0) & (m[1:] == 1))\n","    e = np.array((m[:-1] == 1) & (m[1:] == 0))\n","\n","    s_index = np.where(s)[0] + 2\n","    e_index = np.where(e)[0] + 2\n","    length = e_index - s_index\n","    rle = \" \".join(map(str, sum(zip(s_index, length), ())))\n","    return rle"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["def metric_to_text(ink, label, mask):\n","    text = []\n","\n","    p = ink.reshape(-1)\n","    t = label.reshape(-1)\n","    pos = np.log(np.clip(p, 1e-7, 1))\n","    neg = np.log(np.clip(1 - p, 1e-7, 1))\n","    bce = -(t * pos + (1 - t) * neg).mean()\n","    text.append(f\"bce={bce:0.5f}\")\n","\n","    mask_sum = mask.sum()\n","    # print(f'{threshold:0.1f}, {precision:0.3f}, {recall:0.3f}, {fpr:0.3f},  {dice:0.3f},  {score:0.3f}')\n","    text.append(\"p_sum  th   prec   recall   fpr   dice   score\")\n","    text.append(\"-----------------------------------------------\")\n","    for threshold in [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]:\n","        p = ink.reshape(-1)\n","        t = label.reshape(-1)\n","        p = (p > threshold).astype(np.float32)\n","        t = (t > 0.5).astype(np.float32)\n","\n","        tp = p * t\n","        precision = tp.sum() / (p.sum() + 0.0001)\n","        recall = tp.sum() / t.sum()\n","\n","        fp = p * (1 - t)\n","        fpr = fp.sum() / (1 - t).sum()\n","\n","        beta = 0.5\n","        #  0.2*1/recall + 0.8*1/prec\n","        score = (\n","            beta * beta / (1 + beta * beta) * 1 / recall\n","            + 1 / (1 + beta * beta) * 1 / precision\n","        )\n","        score = 1 / score\n","\n","        dice = 2 * tp.sum() / (p.sum() + t.sum())\n","        p_sum = p.sum() / mask_sum\n","\n","        # print(fold, threshold, precision, recall, fpr,  score)\n","        text.append(\n","            f\"{p_sum:0.2f}, {threshold:0.2f}, {precision:0.3f}, {recall:0.3f}, {fpr:0.3f},  {dice:0.3f},  {score:0.3f}\"\n","        )\n","    text = \"\\n\".join(text)\n","    return text"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["def make_infer_mask():\n","    s = CFG.crop_size\n","    f = CFG.crop_fade\n","    x = np.linspace(-1, 1, s)\n","    y = np.linspace(-1, 1, s)\n","    xx, yy = np.meshgrid(x, y)\n","    d = 1 - np.maximum(np.abs(xx), np.abs(yy))\n","    d1 = np.clip(d, 0, f / s * 2)\n","    d1 = d1 / d1.max()\n","    infer_mask = d1\n","    return infer_mask"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["class Model(pl.LightningModule):\n","    training_step_outputs = []\n","    validation_step_outputs = []\n","    test_step_outputs = [[], []]\n","\n","    def __init__(self, encoder_name, in_channels, out_classes, **kwargs):\n","        super().__init__()\n","\n","        self.model = Net()\n","\n","        self.segmentation_loss_fn = smp.losses.TverskyLoss(\n","            smp.losses.BINARY_MODE,\n","            log_loss=False,\n","            from_logits=False,\n","            smooth=1e-6,\n","            alpha=0.5,\n","            beta=0.6,\n","        )\n","\n","    def forward(self, image, stage):\n","        mask = self.model(image)[\"ink\"]\n","        return mask\n","\n","    def shared_step(self, batch, stage):\n","        if stage == \"train\":\n","            subvolumes, labels = batch\n","        else:\n","            subvolumes, labels, masks = batch\n","\n","        image, labels = subvolumes.float(), labels.float()\n","        assert image.ndim == 4\n","\n","        h, w = image.shape[2:]\n","        assert h % 32 == 0 and w % 32 == 0\n","\n","        # print(\"labels\", labels.max(), labels.min())\n","\n","        assert labels.max() <= 1.0 and labels.min() >= 0\n","\n","        segmentation_out = self.forward(image, stage)\n","\n","        loss = self.segmentation_loss_fn(segmentation_out, labels)\n","        \n","        score = fbeta_score(segmentation_out, labels, CFG.threshold)\n","\n","        pred_mask = (segmentation_out > CFG.threshold).float()\n","\n","        tp, fp, fn, tn = smp.metrics.get_stats(\n","            pred_mask.long(), labels.long(), mode=\"binary\"\n","        )\n","\n","        m = {\n","            \"loss\": loss,        \n","            \"tp\": tp,\n","            \"fp\": fp,\n","            \"fn\": fn,\n","            \"tn\": tn,    \n","            \"score\": score,\n","        }\n","        return m\n","\n","    def shared_epoch_end(self, outputs, stage):\n","        # aggregate step metics\n","        tp = torch.cat([x[\"tp\"] for x in outputs])\n","        fp = torch.cat([x[\"fp\"] for x in outputs])\n","        fn = torch.cat([x[\"fn\"] for x in outputs])\n","        tn = torch.cat([x[\"tn\"] for x in outputs])\n","        loss = torch.mean(torch.Tensor([x[\"loss\"] for x in outputs]))\n","        loss = torch.mean(torch.Tensor([x[\"loss\"] for x in outputs]))\n","        fbeta_score = torch.mean(torch.Tensor([x[\"score\"] for x in outputs]))\n","        \n","        per_image_iou = smp.metrics.iou_score(\n","            tp, fp, fn, tn, reduction=\"micro-imagewise\"\n","        )\n","\n","        dataset_iou = smp.metrics.iou_score(tp, fp, fn, tn, reduction=\"micro\")\n","        \n","        metrics = {\n","            f\"{stage}_per_image_iou\": per_image_iou,\n","            f\"{stage}_dataset_iou\": dataset_iou,\n","            f\"{stage}_loss\": loss.item(),\n","            f\"{stage}_tp\": tp.sum().int().item(),\n","            f\"{stage}_fp\": fp.sum().int().item(),\n","            f\"{stage}_fn\": fn.sum().int().item(),\n","            f\"{stage}_tn\": tn.sum().int().item(),\n","            f\"{stage}_score\": fbeta_score.item(),\n","            f\"{stage}_score\": fbeta_score.item(),\n","        }\n","\n","        self.log_dict(metrics, prog_bar=True, sync_dist=True)\n","\n","    def training_step(self, batch, batch_idx):\n","        out = self.shared_step(batch, \"train\")\n","        self.training_step_outputs.append(out)\n","        return out\n","\n","    def on_train_epoch_end(self):\n","        out = self.shared_epoch_end(self.training_step_outputs, \"train\")\n","        self.training_step_outputs.clear()\n","        return out\n","\n","    def validation_step(self, batch, batch_idx):\n","        out = self.shared_step(batch, \"valid\")\n","        self.validation_step_outputs.append(out)\n","        return out\n","\n","    def on_validation_epoch_end(self):\n","        out = self.shared_epoch_end(self.validation_step_outputs, \"valid\")\n","        self.validation_step_outputs.clear()\n","        return out\n","\n","    def test_step(self, batch, batch_idx):\n","        pass\n","\n","    def on_test_epoch_end(self):\n","        pass\n","\n","    def configure_optimizers(self):\n","        optimizer = optim.AdamW(self.parameters(), lr=CFG.lr)\n","\n","        scheduler = optim.lr_scheduler.ReduceLROnPlateau(\n","            optimizer,\n","            mode=\"min\",\n","            factor=0.05,\n","            patience=5,\n","        )\n","        return {\n","            \"optimizer\": optimizer,\n","            \"lr_scheduler\": {\"scheduler\": scheduler, \"monitor\": \"valid_loss\"},\n","        }"]},{"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["def train_one(net, d, val_d):\n","\n","\t#get coord\n","\tcrop_size  = CFG.crop_size\n","\tstride = CFG.stride\n","\tH,W,D  = d.volume.shape\n","\n","\t##pad #assume H,W >size\n","\tpx, py = W % stride, H % stride\n","\tif (px != 0) or (py != 0):\n","\t\tpx = stride - px\n","\t\tpy = stride - py\n","\t\tpad_volume = np.pad(d.volume, [(0, py), (0, px), (0, 0)], constant_values=0)\n","  \t\tpad_label = np.pad(d.label, [(0, py), (0, px), (0, 0)], constant_values=0)\n","\telse:\n","\t\tpad_volume = d.volume\n","\n","\tpH, pW, _  = pad_volume.shape\n","\tx = np.arange(0,pW-crop_size+1,stride)\n","\ty = np.arange(0,pH-crop_size+1,stride)\n","\tx,y = np.meshgrid(x,y)\n","\txy  = np.stack([x,y],-1).reshape(-1,2)\n","\tprint('H,W,pH,pW,len(xy)',H,W,pH,pW,len(xy))\n"," \n"," \tval_H,val_W,val_D  = d.volume.shape\n","\n","\t##pad #assume H,W >size\n","\tval_px, val_py = val_W % stride, val_H % stride\n","\tif (val_px != 0) or (val_py != 0):\n","\t\tval_px = stride - val_px\n","\t\tval_py = stride - val_py\n","\t\tpad_val_volume = np.pad(val_d.volume, [(0, py), (0, px), (0, 0)], constant_values=0)\n","  \t\tpad_val_label = np.pad(val_d.label, [(0, py), (0, px), (0, 0)], constant_values=0)\n","\telse:\n","\t\tpad_val_volume = val_d.volume\n","\n","\tval_pH, val_pW, _  = pad_val_volume.shape\n","\tval_x = np.arange(0,val_pW-crop_size+1,stride)\n","\tval_y = np.arange(0,val_pH-crop_size+1,stride)\n","\tval_x,val_y = np.meshgrid(val_x,val_y)\n","\tval_xy  = np.stack([val_x,val_y],-1).reshape(-1,2)\n"," \n","\ttrain_ds = SubvolumeDataset(\n","\t\tlocations=xy,\n","\t\tvolume=pad_volume,\n","\t\tlabels=pad_label,\n","\t\tBUFFER=crop_size,\n","\t\tis_train=True,\n","\t)\n","\tval_ds = SubvolumeDataset(\n","\t\tval_xy,\n","\t\tpad_val_volume,\n","\t\tpad_val_label,\n","\t\tcrop_size,\n","\t\tis_train=False,\n","\t)\n","\n","\t# Define data loaders for training and testing data in this fold\n","\ttrain_loader = torch.utils.data.DataLoader(\n","\t\ttrain_ds,\n","\t\tbatch_size=CFG.batch_size,\n","\t\tnum_workers=CFG.num_workers,\n","\t\tshuffle=True,\n","\t)\n","\tval_loader = torch.utils.data.DataLoader(\n","\t\tval_ds,\n","\t\tbatch_size=CFG.batch_size,\n","\t\tnum_workers=CFG.num_workers,\n","\t\tshuffle=False,\n","\t)"]},{"cell_type":"code","execution_count":null,"metadata":{"execution":{"iopub.execute_input":"2023-05-23T14:27:26.348719Z","iopub.status.busy":"2023-05-23T14:27:26.348382Z","iopub.status.idle":"2023-05-23T14:28:40.442741Z","shell.execute_reply":"2023-05-23T14:28:40.441801Z","shell.execute_reply.started":"2023-05-23T14:27:26.348686Z"},"trusted":true},"outputs":[{"name":"stdout","output_type":"stream","text":["CFG\n","\tmode : ['train']\n","\tcrop_fade : 56\n","\tcrop_size : 384\n","\tcrop_depth : 5\n","\tinfer_fragment_z : [28, 37]\n","\tis_tta : True\n","\tstride : 192\n","\n"," @ read_data(): volume1  0.000000, 0.000000, 1.366579==================================\n","fragment_id 1\n","\tmask (8181, 6330)\n","\tvolume (8181, 6330, 9)\n","CFG.stride 192\n","CFG.crop_size 384\n","\n","H,W,pH,pW,len(xy) 8181 6330 8256 6336 1344\n"," @infer_one(): 223 / 224 : 0.000000, 0.000000, 38.398234\n","probability (8181, 6330)\n"]},{"name":"stderr","output_type":"stream","text":["/tmp/ipykernel_4078876/3891300560.py:46: RuntimeWarning: divide by zero encountered in divide\n","  score = beta * beta / (1 + beta * beta) * 1 / recall + 1 / (1 + beta * beta) * 1 / precision\n","/tmp/ipykernel_4078876/3891300560.py:46: RuntimeWarning: divide by zero encountered in scalar divide\n","  score = beta * beta / (1 + beta * beta) * 1 / recall + 1 / (1 + beta * beta) * 1 / precision\n"]},{"name":"stdout","output_type":"stream","text":["bce=0.40077\n","p_sum  th   prec   recall   fpr   dice   score\n","-----------------------------------------------\n","1.00, 0.10, 0.183, 1.000, 0.512,  0.310,  0.219\n","1.00, 0.20, 0.183, 1.000, 0.512,  0.310,  0.219\n","1.00, 0.30, 0.183, 1.000, 0.512,  0.310,  0.219\n","1.00, 0.40, 0.183, 1.000, 0.512,  0.310,  0.219\n","1.00, 0.50, 0.183, 1.000, 0.512,  0.310,  0.219\n","0.00, 0.60, 0.000, 0.000, 0.000,  0.000,  0.000\n","0.00, 0.70, 0.000, 0.000, 0.000,  0.000,  0.000\n","0.00, 0.80, 0.000, 0.000, 0.000,  0.000,  0.000\n","0.00, 0.90, 0.000, 0.000, 0.000,  0.000,  0.000\n","\n","\n","\n","CFG\n","\tmode : ['train']\n","\tcrop_fade : 56\n","\tcrop_size : 384\n","\tcrop_depth : 5\n","\tinfer_fragment_z : [28, 37]\n","\tis_tta : True\n","\tstride : 192\n","  Id Predicted\n","0  1          \n","submission.csv ok!!!\n"]},{"data":{"text/plain":["'\\n \\n\\n'"]},"execution_count":48,"metadata":{},"output_type":"execute_result"},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["######################################\n","if (\"skip_fake_test\" in CFG.mode) and (is_skip_test):\n","    submit_df = pd.DataFrame({\"Id\": valid_id, \"Predicted\": [\"1 2\", \"1 2\"]})\n","else:\n","    checkpoint = [\n","        #'/kaggle/input/ink-01-weight/bug-00007920.model.pth',\n","        # '/kaggle/input/ink-01-weight/fix-rot-00005904.model.pth',\n","    ]\n","\n","    # ----\n","    net = []\n","    if len(checkpoint) == 0:\n","        net = [Net()]\n","    for i, f in enumerate(checkpoint):\n","        print(i, f)\n","        n = Net()\n","        f = torch.load(f, map_location=lambda storage, loc: storage)\n","        print(n.load_state_dict(f[\"state_dict\"], strict=True))  # True\n","        net.append(n)\n","\n","    # ----\n","    print(cfg_to_text())\n","    print(\"\")\n","    submission = defaultdict(list)\n","    for t, fragment_id in enumerate(valid_id):\n","        d = read_data1(fragment_id)\n","\n","        print(\"==================================\")\n","        print(\"fragment_id\", d.fragment_id)\n","        print(\"\\tmask\", d.mask.shape)\n","        print(\"\\tvolume\", d.volume.shape)\n","        print(\"CFG.stride\", CFG.stride)\n","        print(\"CFG.crop_size\", CFG.crop_size)\n","        print(\"\")\n","\n","        probability = infer_one(net, d)\n","        print(\"probability\", probability.shape)\n","\n","        probability = d.mask * probability\n","        predict = (probability > 0.55).astype(np.uint8)\n","\n","        # ----\n","        submission[\"Id\"].append(fragment_id)\n","        submission[\"Predicted\"].append(mask_to_rle(predict))\n","\n","        # ----\n","        probability8 = (probability * 255).astype(np.uint8)\n","        plt.figure(t), plt.imshow(probability8, cmap=\"gray\")\n","        # plt.waitforbuttonpress()\n","        if \"train\" in CFG.mode:\n","            text = metric_to_text(probability, d.label, d.mask)\n","            print(text)\n","        print(\"\")\n","\n","    print(\"\")\n","    submit_df = pd.DataFrame.from_dict(submission)\n","\n","print(\"\")\n","print(cfg_to_text())\n","submit_df.to_csv(\"submission.csv\", index=False)\n","print(submit_df)\n","print(\"submission.csv ok!!!\")\n","\n","\"\"\"\n"," \n","\n","\"\"\""]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.16"}},"nbformat":4,"nbformat_minor":4}