{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.10","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceType":"competition","sourceId":23823,"databundleVersionId":1920183},{"sourceType":"datasetVersion","sourceId":2215761,"datasetId":1330639,"databundleVersionId":2257404},{"sourceType":"datasetVersion","sourceId":2153167,"datasetId":1229677,"databundleVersionId":2194269},{"sourceType":"datasetVersion","sourceId":2185494,"datasetId":1136885,"databundleVersionId":2226909},{"sourceType":"datasetVersion","sourceId":2182061,"datasetId":1136931,"databundleVersionId":2223452},{"sourceType":"datasetVersion","sourceId":2167436,"datasetId":1149113,"databundleVersionId":2208662},{"sourceType":"datasetVersion","sourceId":1983975,"datasetId":1182793,"databundleVersionId":2023128},{"sourceType":"datasetVersion","sourceId":2194412,"datasetId":1317588,"databundleVersionId":2235923},{"sourceType":"datasetVersion","sourceId":2188154,"datasetId":1313589,"databundleVersionId":2229604},{"sourceType":"datasetVersion","sourceId":2211937,"datasetId":1328360,"databundleVersionId":2253568},{"sourceType":"datasetVersion","sourceId":2211395,"datasetId":1325931,"databundleVersionId":2253025},{"sourceType":"datasetVersion","sourceId":2211693,"datasetId":1328208,"databundleVersionId":2253323},{"sourceType":"datasetVersion","sourceId":2165946,"datasetId":1300160,"databundleVersionId":2207150},{"sourceType":"datasetVersion","sourceId":2211791,"datasetId":1328270,"databundleVersionId":2253422},{"sourceType":"datasetVersion","sourceId":12285780,"datasetId":7742754,"databundleVersionId":12836666},{"sourceType":"datasetVersion","sourceId":12285881,"datasetId":7742827,"databundleVersionId":12836780},{"sourceType":"datasetVersion","sourceId":12285818,"datasetId":7742780,"databundleVersionId":12836710},{"sourceType":"datasetVersion","sourceId":3075714,"datasetId":849808,"databundleVersionId":3124377},{"sourceType":"datasetVersion","sourceId":2214724,"datasetId":1330046,"databundleVersionId":2256362},{"sourceType":"datasetVersion","sourceId":12285770,"datasetId":7742744,"databundleVersionId":12836656},{"sourceType":"datasetVersion","sourceId":14478588,"datasetId":9247771,"databundleVersionId":15301743},{"sourceType":"modelInstanceVersion","sourceId":322709,"databundleVersionId":11710258,"modelInstanceId":271933,"modelId":292921},{"sourceType":"modelInstanceVersion","sourceId":406432,"databundleVersionId":12405423,"modelInstanceId":332113,"modelId":353026},{"sourceType":"modelInstanceVersion","sourceId":368554,"databundleVersionId":12109391,"modelInstanceId":305281,"modelId":325730},{"sourceType":"modelInstanceVersion","sourceId":392389,"databundleVersionId":12303476,"modelInstanceId":323075,"modelId":343780},{"sourceType":"modelInstanceVersion","sourceId":423906,"databundleVersionId":12575303,"modelInstanceId":345478,"modelId":366776},{"sourceType":"modelInstanceVersion","sourceId":423780,"databundleVersionId":12574228,"modelInstanceId":345366,"modelId":366658},{"sourceType":"modelInstanceVersion","sourceId":423888,"databundleVersionId":12575213,"modelInstanceId":345461,"modelId":366759},{"sourceType":"modelInstanceVersion","sourceId":423892,"databundleVersionId":12575246,"modelInstanceId":345464,"modelId":366762},{"sourceType":"modelInstanceVersion","sourceId":322720,"databundleVersionId":11710411,"modelInstanceId":271941,"modelId":292929},{"sourceType":"modelInstanceVersion","sourceId":367043,"databundleVersionId":12097971,"modelInstanceId":304273,"modelId":324754},{"sourceType":"modelInstanceVersion","sourceId":727138,"databundleVersionId":15404446,"modelInstanceId":553559,"modelId":566106},{"sourceType":"modelInstanceVersion","sourceId":727153,"databundleVersionId":15404610,"modelInstanceId":553572,"modelId":566119},{"sourceType":"modelInstanceVersion","sourceId":727159,"databundleVersionId":15404731,"modelInstanceId":553578,"modelId":566126},{"sourceType":"modelInstanceVersion","sourceId":733428,"databundleVersionId":15483704,"modelInstanceId":558926,"modelId":571512},{"sourceType":"modelInstanceVersion","sourceId":727167,"databundleVersionId":15404837,"modelInstanceId":553586,"modelId":566135},{"sourceType":"modelInstanceVersion","sourceId":688813,"databundleVersionId":14972177,"modelInstanceId":522174,"modelId":536243},{"sourceType":"modelInstanceVersion","sourceId":703048,"databundleVersionId":15143757,"modelInstanceId":533556,"modelId":547258},{"sourceType":"modelInstanceVersion","sourceId":667255,"databundleVersionId":14703359,"modelInstanceId":505154,"modelId":520063},{"sourceType":"modelInstanceVersion","sourceId":401275,"databundleVersionId":12363206,"modelInstanceId":328339,"modelId":349188},{"sourceType":"modelInstanceVersion","sourceId":667275,"databundleVersionId":14703660,"modelInstanceId":505172,"modelId":520079},{"sourceType":"modelInstanceVersion","sourceId":327786,"databundleVersionId":11751692,"modelInstanceId":275082,"modelId":295968},{"sourceType":"modelInstanceVersion","sourceId":720956,"databundleVersionId":15335454,"modelInstanceId":548392,"modelId":561149},{"sourceType":"modelInstanceVersion","sourceId":720974,"databundleVersionId":15335595,"modelInstanceId":548407,"modelId":561162},{"sourceType":"modelInstanceVersion","sourceId":721005,"databundleVersionId":15335823,"modelInstanceId":548434,"modelId":561186},{"sourceType":"modelInstanceVersion","sourceId":721408,"databundleVersionId":15339690,"modelInstanceId":548780,"modelId":561494},{"sourceType":"modelInstanceVersion","sourceId":395248,"databundleVersionId":12322104,"modelInstanceId":324754,"modelId":345574},{"sourceType":"modelInstanceVersion","sourceId":364551,"databundleVersionId":12078278,"modelInstanceId":302470,"modelId":322964},{"sourceType":"modelInstanceVersion","sourceId":366994,"databundleVersionId":12097638,"modelInstanceId":304244,"modelId":324725},{"sourceType":"modelInstanceVersion","sourceId":422817,"databundleVersionId":12563584,"modelInstanceId":344552,"modelId":365846},{"sourceType":"modelInstanceVersion","sourceId":422821,"databundleVersionId":12563646,"modelInstanceId":344556,"modelId":365850},{"sourceType":"modelInstanceVersion","sourceId":422825,"databundleVersionId":12563685,"modelInstanceId":344559,"modelId":365853},{"sourceType":"modelInstanceVersion","sourceId":423743,"databundleVersionId":12573910,"modelInstanceId":345332,"modelId":366624},{"sourceType":"modelInstanceVersion","sourceId":364608,"databundleVersionId":12078763,"modelInstanceId":302517,"modelId":323012},{"sourceType":"modelInstanceVersion","sourceId":428090,"databundleVersionId":12620876,"modelInstanceId":348975,"modelId":370239},{"sourceType":"modelInstanceVersion","sourceId":428978,"databundleVersionId":12629231,"modelInstanceId":349667,"modelId":370924},{"sourceType":"modelInstanceVersion","sourceId":416386,"databundleVersionId":12505385,"modelInstanceId":339710,"modelId":360824},{"sourceType":"modelInstanceVersion","sourceId":438227,"databundleVersionId":12736641,"modelInstanceId":357506,"modelId":378829},{"sourceType":"modelInstanceVersion","sourceId":446883,"databundleVersionId":12807921,"modelInstanceId":362912,"modelId":383768},{"sourceType":"modelInstanceVersion","sourceId":582153,"databundleVersionId":13759944,"modelInstanceId":434618,"modelId":451467},{"sourceType":"modelInstanceVersion","sourceId":632149,"databundleVersionId":14373708,"modelInstanceId":476494,"modelId":492416},{"sourceType":"modelInstanceVersion","sourceId":408871,"databundleVersionId":12430277,"modelInstanceId":334071,"modelId":355058},{"sourceType":"modelInstanceVersion","sourceId":757703,"databundleVersionId":15777927,"modelInstanceId":578768,"modelId":591103},{"sourceType":"modelInstanceVersion","sourceId":736178,"databundleVersionId":15519459,"modelInstanceId":561270,"modelId":573890},{"sourceType":"modelInstanceVersion","sourceId":737101,"databundleVersionId":15532506,"modelInstanceId":562053,"modelId":574676},{"sourceType":"modelInstanceVersion","sourceId":737119,"databundleVersionId":15532869,"modelInstanceId":562069,"modelId":574690},{"sourceType":"modelInstanceVersion","sourceId":735302,"databundleVersionId":15506162,"modelInstanceId":560531,"modelId":573116},{"sourceType":"modelInstanceVersion","sourceId":442288,"databundleVersionId":12763968,"modelInstanceId":359282,"modelId":380590},{"sourceType":"modelInstanceVersion","sourceId":757661,"databundleVersionId":15777486,"modelInstanceId":578741,"modelId":591076},{"sourceType":"modelInstanceVersion","sourceId":757899,"databundleVersionId":15780867,"modelInstanceId":578932,"modelId":591259},{"sourceType":"modelInstanceVersion","sourceId":584254,"databundleVersionId":13786355,"modelInstanceId":436420,"modelId":453191},{"sourceType":"modelInstanceVersion","sourceId":446042,"databundleVersionId":12799139,"modelInstanceId":362200,"modelId":383167},{"sourceType":"modelInstanceVersion","sourceId":448171,"databundleVersionId":12822200,"modelInstanceId":363814,"modelId":384689},{"sourceType":"modelInstanceVersion","sourceId":449467,"databundleVersionId":12836461,"modelInstanceId":364886,"modelId":385770},{"sourceType":"modelInstanceVersion","sourceId":450264,"databundleVersionId":12844752,"modelInstanceId":365450,"modelId":386329},{"sourceType":"modelInstanceVersion","sourceId":446044,"databundleVersionId":12799163,"modelInstanceId":362202,"modelId":383169},{"sourceType":"modelInstanceVersion","sourceId":449386,"databundleVersionId":12835782,"modelInstanceId":364856,"modelId":385736},{"sourceType":"modelInstanceVersion","sourceId":443268,"databundleVersionId":12772589,"modelInstanceId":360032,"modelId":381190},{"sourceType":"modelInstanceVersion","sourceId":540995,"databundleVersionId":13508204,"modelInstanceId":417966,"modelId":435631},{"sourceType":"modelInstanceVersion","sourceId":541009,"databundleVersionId":13508240,"modelInstanceId":417968,"modelId":435634},{"sourceType":"modelInstanceVersion","sourceId":735316,"databundleVersionId":15506319,"modelInstanceId":560545,"modelId":573130},{"sourceType":"modelInstanceVersion","sourceId":582391,"databundleVersionId":13762867,"modelInstanceId":434832,"modelId":451680},{"sourceType":"modelInstanceVersion","sourceId":582826,"databundleVersionId":13768488,"modelInstanceId":435205,"modelId":452029},{"sourceType":"modelInstanceVersion","sourceId":581619,"databundleVersionId":13752384,"modelInstanceId":434168,"modelId":451031},{"sourceType":"modelInstanceVersion","sourceId":545433,"databundleVersionId":13522701,"modelInstanceId":418738,"modelId":436388},{"sourceType":"modelInstanceVersion","sourceId":582415,"databundleVersionId":13763090,"modelInstanceId":434854,"modelId":451700},{"sourceType":"modelInstanceVersion","sourceId":581617,"databundleVersionId":13752357,"modelInstanceId":434167,"modelId":451030},{"sourceType":"modelInstanceVersion","sourceId":431551,"databundleVersionId":12656772,"modelInstanceId":351788,"modelId":373054},{"sourceType":"modelInstanceVersion","sourceId":439909,"databundleVersionId":12751647,"modelInstanceId":358519,"modelId":379833},{"sourceType":"modelInstanceVersion","sourceId":443903,"databundleVersionId":12777488,"modelInstanceId":360396,"modelId":381536},{"sourceType":"modelInstanceVersion","sourceId":584767,"databundleVersionId":13792671,"modelInstanceId":436872,"modelId":453612},{"sourceType":"modelInstanceVersion","sourceId":447812,"databundleVersionId":12818345,"modelInstanceId":363556,"modelId":384422},{"sourceType":"modelInstanceVersion","sourceId":444859,"databundleVersionId":12787670,"modelInstanceId":361202,"modelId":382264},{"sourceType":"modelInstanceVersion","sourceId":444925,"databundleVersionId":12788066,"modelInstanceId":361243,"modelId":382303},{"sourceType":"modelInstanceVersion","sourceId":449282,"databundleVersionId":12834914,"modelInstanceId":364793,"modelId":385675},{"sourceType":"modelInstanceVersion","sourceId":642496,"databundleVersionId":14455147,"modelInstanceId":484513,"modelId":499991},{"sourceType":"modelInstanceVersion","sourceId":609929,"databundleVersionId":14109484,"modelInstanceId":457992,"modelId":473915},{"sourceType":"modelInstanceVersion","sourceId":642424,"databundleVersionId":14454602,"modelInstanceId":484462,"modelId":499948},{"sourceType":"modelInstanceVersion","sourceId":650339,"databundleVersionId":14533155,"modelInstanceId":490704,"modelId":506121},{"sourceType":"modelInstanceVersion","sourceId":327800,"databundleVersionId":11751884,"modelInstanceId":275092,"modelId":295982},{"sourceType":"modelInstanceVersion","sourceId":733414,"databundleVersionId":15483616,"modelInstanceId":558915,"modelId":571499},{"sourceType":"modelInstanceVersion","sourceId":733418,"databundleVersionId":15483629,"modelInstanceId":558919,"modelId":571504},{"sourceType":"modelInstanceVersion","sourceId":733421,"databundleVersionId":15483657,"modelInstanceId":558921,"modelId":571507},{"sourceType":"modelInstanceVersion","sourceId":733422,"databundleVersionId":15483669,"modelInstanceId":558922,"modelId":571508}],"dockerImageVersionId":30097,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"## Imports","metadata":{}},{"cell_type":"code","source":"!mkdir -p /root/.cache/torch/hub/checkpoints\n!cp -r ../input/landmark-additional-packages/rwightman_gen-efficientnet-pytorch_master/rwightman_gen-efficientnet-pytorch_master /root/.cache/torch/hub\n!cp ../input/landmark-additional-packages/tf_efficientnet_b3_aa-84b4657e.pth /root/.cache/torch/hub/checkpoints/\n!cp ../input/landmark-additional-packages/tf_efficientnet_b5_ra-9a3e5369.pth /root/.cache/torch/hub/checkpoints/\n!cp ../input/landmark-additional-packages/se_resnext50_32x4d-a260b3a4.pth /root/.cache/torch/hub/checkpoints/\n!cp ../input/landmark-additional-packages/resnet50d_ra2-464e36ba.pth /root/.cache/torch/hub/checkpoints/","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-03-03T22:08:25.532305Z","iopub.execute_input":"2026-03-03T22:08:25.532694Z","iopub.status.idle":"2026-03-03T22:08:35.109925Z","shell.execute_reply.started":"2026-03-03T22:08:25.532592Z","shell.execute_reply":"2026-03-03T22:08:35.108945Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!pip install -q ../input/landmark-additional-packages/timm-0.3.4-py3-none-any.whl\n!pip install -q ../input/landmark-additional-packages/geffnet-1.0.0-py3-none-any.whl\n!pip install -q ../input/landmark-additional-packages/EfficientNet-PyTorch/EfficientNet-PyTorch-master\n!pip install -q ../input/landmark-additional-packages/pycocotools-2.0.2/dist/pycocotools-2.0.2.tar\n!pip install -q ../input/landmark-additional-packages/pretrainedmodels-0.7.4/pretrainedmodels-0.7.4","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-03-03T22:08:35.11147Z","iopub.execute_input":"2026-03-03T22:08:35.111727Z","iopub.status.idle":"2026-03-03T22:11:50.320258Z","shell.execute_reply.started":"2026-03-03T22:08:35.111699Z","shell.execute_reply":"2026-03-03T22:11:50.319137Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!pip install \"/kaggle/input/hpamisc/pytorch_zoo-master\"\n!pip install \"/kaggle/input/hpamisc/pycocotools-2.0-cp37-cp37m-linux_x86_64.whl\"\n!pip install \"/kaggle/input/hpamisc/faiss_gpu-1.7.0-cp37-cp37m-manylinux2014_x86_64.whl\"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-03-03T22:11:50.32227Z","iopub.execute_input":"2026-03-03T22:11:50.322503Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"! python ../input/maozi-no-arcface/maozi_no_arcface.py","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import random\nimport sys\nsys.path.append('../input/hpa-singlecell-e050f56/hpa_singlecell-double_level_valid_all/')\n\nfrom torch import nn\nimport torch\nimport torch.nn.functional as F\nimport torchvision\nimport timm\nfrom torch.nn.parameter import Parameter\nimport albumentations as A\n\nfrom utils import parse_args, prepare_for_result\nfrom torch.utils.data import DataLoader, Dataset\nfrom losses import get_loss, get_class_balanced_weighted\nfrom dataloaders import get_dataloader\nfrom utils import load_matched_state\nfrom configs import Config\nfrom models import get_model\nfrom dataloaders.transform_loader import get_tfms\n\nimport base64\nimport zlib\nfrom pycocotools import _mask as coco_mask\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport cv2\nimport tqdm\nimport seaborn as sns","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torchvision\nprint(torchvision.__version__)\n\nfrom torchvision import transforms","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Transforms","metadata":{}},{"cell_type":"code","source":"tensor_tfms = torchvision.transforms.Compose([\n torchvision.transforms.ToTensor(),\n torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406, 0.485], \n std=[0.229, 0.224, 0.225, 0.229]),\n ])\n\nimage_tfms = torchvision.transforms.Compose([\n torchvision.transforms.ToTensor(),\n torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406, 0.485], \n std=[0.229, 0.224, 0.225, 0.229]),\n ])\n\n# tensor_tfms = torchvision.transforms.Compose([\n# torchvision.transforms.ToTensor(),\n# torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406, 0.406], \n# std=[0.229, 0.224, 0.225, 0.225]),\n# ])\n\n# image_tfms = torchvision.transforms.Compose([\n# torchvision.transforms.ToTensor(),\n# torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406, 0.406], \n# std=[0.229, 0.224, 0.225, 0.225]),\n# ])\n\n# tensor_tfms = torchvision.transforms.Compose([\n# torchvision.transforms.ToTensor(),\n# torchvision.transforms.Normalize(mean=[0.5, 0.5, 0.5, 0.5], \n# std=[0.5, 0.5, 0.5, 0.5]),\n# ])\n\n# image_tfms = torchvision.transforms.Compose([\n# torchvision.transforms.ToTensor(),\n# torchvision.transforms.Normalize(mean=[0.5, 0.5, 0.5, 0.5], \n# std=[0.5, 0.5, 0.5, 0.5]),\n# ])\n\ntta_tfms = A.Compose([\n A.Resize(always_apply=False, p=1, height=256, width=256, interpolation=1),\n A.HorizontalFlip(always_apply=False, p=0.5),\n A.ShiftScaleRotate(always_apply=False, p=0.7, shift_limit_x=(-0.06, 0.06), shift_limit_y=(-0.06, 0.06), scale_limit=(-0.3, 0.3), rotate_limit=(-22.5, 22.5), interpolation=1, border_mode=2, value=None, mask_value=None),\n A.RandomBrightnessContrast(always_apply=False, p=0.5, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), brightness_by_max=True),\n])\n\nres_tfms = A.Compose([\n A.Resize(always_apply=False, p=1, height=256, width=256, interpolation=1)\n])\n\nimage_res_tfms = A.Compose([\n A.Resize(always_apply=False, p=1, height=512, width=512, interpolation=1)\n])","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Seed","metadata":{}},{"cell_type":"code","source":"def seed_everything(seed=42):\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n torch.cuda.manual_seed_all(seed) # if using GPU\n\n # For convolutional determinism\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\nseed_everything(42)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Functions","metadata":{}},{"cell_type":"code","source":"def binary_mask_to_ascii(mask, mask_val=1):\n \"\"\"Converts a binary mask into OID challenge encoding ascii text.\"\"\"\n mask = np.where(mask==mask_val, 1, 0).astype(np.bool)\n \n # check input mask --\n if mask.dtype != np.bool:\n raise ValueError(f\"encode_binary_mask expects a binary mask, received dtype == {mask.dtype}\")\n\n mask = np.squeeze(mask)\n if len(mask.shape) != 2:\n raise ValueError(f\"encode_binary_mask expects a 2d mask, received shape == {mask.shape}\")\n\n # convert input mask to expected COCO API input --\n mask_to_encode = mask.reshape(mask.shape[0], mask.shape[1], 1)\n mask_to_encode = mask_to_encode.astype(np.uint8)\n mask_to_encode = np.asfortranarray(mask_to_encode)\n\n # RLE encode mask --\n encoded_mask = coco_mask.encode(mask_to_encode)[0][\"counts\"]\n\n # compress and base64 encoding --\n binary_str = zlib.compress(encoded_mask, zlib.Z_BEST_COMPRESSION)\n base64_str = base64.b64encode(binary_str)\n return base64_str.decode()\n\ndef process(x):\n iid, msk, img, sz = x\n img = cv2.resize(img, (2048, 2048))\n enc_msk = cv2.resize(msk, (sz, sz))\n cell_mask = msk\n subs = {}\n results = []\n for i in range(1, cell_mask.max() + 1):\n enc = binary_mask_to_ascii(enc_msk, i)\n sub = cv2.resize((cell_mask == i).astype(np.float), (2048, 2048), cv2.INTER_LINEAR)\n xr, yr = np.where(sub == 1)\n xmin, xmax, ymin, ymax = xr.min(), xr.max(), yr.min(), yr.max()\n subs[i] = (img * np.repeat((sub == 1).astype(np.int)[:, :, np.newaxis], 4, 2))[xmin:xmax, ymin: ymax]\n# imsave(f'./seg_png_fix_test/{iid}_{i}.png', (255 * subs[i]).astype(np.uint8))\n results.append(((255 * subs[i]).astype(np.uint8), enc, sz, sz))\n return results\n\ndef squarify(M,val):\n (a,b,c)=M.shape\n if a>b:\n padding=((0,0),((a-b)//2,a-b-(a-b)//2),(0, 0))\n else:\n padding=(((b-a)//2,b-a-(b-a)//2),(0,0),(0, 0))\n return np.pad(M,padding,mode='constant',constant_values=val)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"CLASSES = np.asarray([\n'0. Nucleoplasm',\n'1. Nuclear-membrane',\n'2. Nucleoli',\n'3. Nucleoli-fibrillar-center',\n'4. Nuclear-speckles',\n'5. Nuclear-bodies',\n'6. Endoplasmic-reticulum',\n'7. Golgi apparatus',\n'8. Intermediate-filaments',\n'9. Actin-filaments',\n'10. Microtubules',\n'11. Mitotic-spindle',\n'12. Centrosome',\n'13. Plasma-membrane',\n'14. Mitochondria',\n'15. Aggresome',\n'16. Cytosol',\n'17. Vesicles',\n'18. Negative'\n])\n\n\ndef get_image(images_dir, sample_id):\n colors = ('red','green','blue','yellow')\n images = [cv2.imread(os.path.join(images_dir, f'{sample_id}_{c}.png'), cv2.IMREAD_GRAYSCALE) for c in colors]\n image = np.stack(images, axis=-1)\n if image.dtype == np.uint16:\n image = ((image.astype(\"float32\")/65536.)*255.).astype(\"uint8\")\n return image\n\ndef get_masks(image_ids, imgs=None, cell_df=None):\n if not isinstance(image_ids, (tuple, list, set)): image_ids = [image_ids]\n if not isinstance(imgs, (tuple, list, set)): imgs = [imgs]\n \n all_samples_precomputed = all(_id in cell_df.index for _id in image_ids)\n if all_samples_precomputed:\n masks = []\n for image_id in image_ids:\n (W, H, pred_str) = cell_df.loc[image_id]\n parts = pred_str.split()\n rles = parts[2::3]\n mask = coco_mask.decode([{\"size\": [H, W], \"counts\": zlib.decompress(base64.b64decode(r))} for r in rles])\n mask = mask.argmax(-1)\n masks.append(mask)\n return masks\n # return [None]*len(imgs)\n\n images = [[img[:, :, 0] for img in imgs],\n [img[:, :, 3] for img in imgs], \n [img[:, :, 2] for img in imgs]]\n\n nuc_segmentations = segmentator.pred_nuclei(images[2])\n cell_segmentations = segmentator.pred_cells(images)\n cell_masks = []\n for i in range(len(cell_segmentations)):\n _, cell_mask = label_cell(nuc_segmentations[i], cell_segmentations[i])\n cell_masks.append(cell_mask)\n return cell_masks","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## ResNest269 Model","metadata":{}},{"cell_type":"code","source":"#@title Model / Architecture\n\nimport math\nimport random\n\nimport cv2\nimport numpy as np\n\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\nfrom torch.nn import BatchNorm2d, Conv2d, Linear, Module, ReLU\nfrom torch.nn.modules.utils import _pair\nimport torch.utils.model_zoo as model_zoo\nfrom torch.optim.lr_scheduler import LambdaLR\n\n\ndef set_seed(seed):\n random.seed(seed)\n np.random.seed(seed)\n\n torch.manual_seed(seed)\n if torch.cuda.is_available():\n torch.cuda.manual_seed_all(seed)\n\n\ndef rotation(x, k):\n return torch.rot90(x, k, (1, 2))\n\n\ndef interleave(x, size):\n s = list(x.shape)\n return x.reshape([-1, size] + s[1:]).transpose(0, 1).reshape([-1] + s[1:])\n\n\ndef de_interleave(x, size):\n s = list(x.shape)\n return x.reshape([size, -1] + s[1:]).transpose(0, 1).reshape([-1] + s[1:])\n\n\ndef resize_tensor(tensors, size, mode='bilinear', align_corners=None):\n return F.interpolate(tensors, size, mode=mode, align_corners=align_corners)\n\n\ndef gap2d(x, keepdims=False):\n x = torch.mean(x.view(x.size(0), x.size(1), -1), -1)\n if keepdims:\n x = x.view(x.size(0), x.size(1), 1, 1)\n return x\n\n\n# Losses\n\n\ndef L1_Loss(A_tensors, B_tensors):\n return torch.abs(A_tensors - B_tensors)\n\n\ndef L2_Loss(A_tensors, B_tensors):\n return torch.pow(A_tensors - B_tensors, 2)\n\n\n# ratio = 0.2, top=20%\ndef Online_Hard_Example_Mining(values, ratio=0.2):\n b, c, h, w = values.size()\n return torch.topk(values.reshape(b, -1), k=int(c * h * w * ratio), dim=-1)[0]\n\n\ndef shannon_entropy_loss(logits, activation=torch.sigmoid, epsilon=1e-5):\n v = activation(logits)\n return -torch.sum(v * torch.log(v + epsilon), dim=1).mean()\n\n\ndef make_cam(x, eps=1e-5, shift_min=False, global_norm=False, inplace=True):\n x = F.relu(x)\n\n if global_norm:\n x_min = x.min() if shift_min else 0\n x_max = x.max() - x_min\n else:\n b, c, h, w = x.size()\n flat_x = x.view(b, c, -1)\n x_min = flat_x.min(axis=-1)[0].view((b, c, 1, 1)) if shift_min else 0\n x_max = flat_x.max(axis=-1)[0].view((b, c, 1, 1)) - x_min\n\n if shift_min:\n if inplace:\n x -= x_min\n x /= x_max + eps\n else:\n x = (x - x_min) / (x_max + eps)\n else:\n if inplace:\n x /= x_max + eps\n else:\n x = x / (x_max + eps)\n\n return x\n\n\ndef one_hot_embedding(label, classes):\n \"\"\"Embedding labels to one-hot form.\n\n Args:\n labels: (int) class labels.\n num_classes: (int) number of classes.\n\n Returns:\n (tensor) encoded labels, sized [N, #classes].\n \"\"\"\n\n vector = np.zeros((classes), dtype=np.float32)\n if len(label) > 0:\n vector[label] = 1.\n return vector\n\n\ndef calculate_parameters(model):\n return sum(param.numel() for param in model.parameters()) / 1000000.0\n\n\ndef get_learning_rate_from_optimizer(optimizer):\n return optimizer.param_groups[0]['lr']\n\n\ndef set_trainable_layers(model, klass=None, trainable=False):\n for m in model.modules():\n if klass is None or isinstance(m, klass):\n for prop in (\"weight\", \"bias\"):\n w = getattr(m, prop, None)\n if w is not None:\n w.requires_grad = trainable\n\n\ndef to_numpy(tensor):\n return tensor.cpu().detach().numpy()\n\n\ndef load_model(model, model_path, parallel=False, map_location=None, strict=True):\n print(f'loading weights from `{model_path}`.')\n\n state = torch.load(model_path, map_location=map_location)\n if parallel:\n model.module.load_state_dict(state, strict=strict)\n else:\n model.load_state_dict(state, strict=strict)\n\n\ndef save_model(model, model_path, parallel=False):\n print(f'saving weights to `{model_path}`.')\n\n if parallel:\n torch.save(model.module.state_dict(), model_path)\n else:\n torch.save(model.state_dict(), model_path)\n\n\ndef transfer_model(pretrained_model, model):\n pretrained_dict = pretrained_model.state_dict()\n model_dict = model.state_dict()\n\n pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict}\n\n model_dict.update(pretrained_dict)\n model.load_state_dict(model_dict)\n\n\ndef get_learning_rate(optimizer):\n lr = []\n for param_group in optimizer.param_groups:\n lr += [param_group['lr']]\n return lr\n\n\ndef get_cosine_schedule_with_warmup(optimizer, warmup_iteration, max_iteration, cycles=7. / 16.):\n\n def _lr_lambda(current_iteration):\n if current_iteration < warmup_iteration:\n return float(current_iteration) / float(max(1, warmup_iteration))\n\n no_progress = float(current_iteration - warmup_iteration) / float(max(1, max_iteration - warmup_iteration))\n return max(0., math.cos(math.pi * cycles * no_progress))\n\n return LambdaLR(optimizer, _lr_lambda, -1)\n\n\ndef label_smoothing(labels, alpha):\n if alpha:\n return (1 - alpha) * labels + alpha * 0.5\n\n return labels\n\n\nclass SplAtConv2d(Module):\n \"\"\"Split-Attention Conv2d\n \"\"\"\n\n def __init__(\n self,\n in_channels,\n channels,\n kernel_size,\n stride=(1, 1),\n padding=(0, 0),\n dilation=(1, 1),\n groups=1,\n bias=True,\n radix=2,\n reduction_factor=4,\n rectify=False,\n rectify_avg=False,\n norm_layer=None,\n dropblock_prob=0.0,\n **kwargs\n ):\n super(SplAtConv2d, self).__init__()\n padding = _pair(padding)\n self.rectify = rectify and (padding[0] > 0 or padding[1] > 0)\n self.rectify_avg = rectify_avg\n inter_channels = max(in_channels * radix // reduction_factor, 32)\n self.radix = radix\n self.cardinality = groups\n self.channels = channels\n self.dropblock_prob = dropblock_prob\n if self.rectify:\n from rfconv import RFConv2d\n self.conv = RFConv2d(\n in_channels,\n channels * radix,\n kernel_size,\n stride,\n padding,\n dilation,\n groups=groups * radix,\n bias=bias,\n average_mode=rectify_avg,\n **kwargs\n )\n else:\n self.conv = Conv2d(\n in_channels,\n channels * radix,\n kernel_size,\n stride,\n padding,\n dilation,\n groups=groups * radix,\n bias=bias,\n **kwargs\n )\n self.use_bn = norm_layer is not None\n if self.use_bn:\n self.bn0 = norm_layer(channels * radix)\n self.relu = ReLU(inplace=True)\n self.fc1 = Conv2d(channels, inter_channels, 1, groups=self.cardinality)\n if self.use_bn:\n self.bn1 = norm_layer(inter_channels)\n self.fc2 = Conv2d(inter_channels, channels * radix, 1, groups=self.cardinality)\n if dropblock_prob > 0.0:\n self.dropblock = DropBlock2D(dropblock_prob, 3)\n self.rsoftmax = rSoftMax(radix, groups)\n\n def forward(self, x):\n x = self.conv(x)\n if self.use_bn:\n x = self.bn0(x)\n if self.dropblock_prob > 0.0:\n x = self.dropblock(x)\n x = self.relu(x)\n\n batch, rchannel = x.shape[:2]\n if self.radix > 1:\n if torch.__version__ < '1.5':\n splited = torch.split(x, int(rchannel // self.radix), dim=1)\n else:\n splited = torch.split(x, rchannel // self.radix, dim=1)\n gap = sum(splited)\n else:\n gap = x\n gap = F.adaptive_avg_pool2d(gap, 1)\n gap = self.fc1(gap)\n\n if self.use_bn:\n gap = self.bn1(gap)\n gap = self.relu(gap)\n\n atten = self.fc2(gap)\n atten = self.rsoftmax(atten).view(batch, -1, 1, 1)\n\n if self.radix > 1:\n if torch.__version__ < '1.5':\n attens = torch.split(atten, int(rchannel // self.radix), dim=1)\n else:\n attens = torch.split(atten, rchannel // self.radix, dim=1)\n out = sum([att * split for (att, split) in zip(attens, splited)])\n else:\n out = atten * x\n return out.contiguous()\n\n\nclass rSoftMax(nn.Module):\n\n def __init__(self, radix, cardinality):\n super().__init__()\n self.radix = radix\n self.cardinality = cardinality\n\n def forward(self, x):\n batch = x.size(0)\n if self.radix > 1:\n x = x.view(batch, self.cardinality, self.radix, -1).transpose(1, 2)\n x = F.softmax(x, dim=1)\n x = x.reshape(batch, -1)\n else:\n x = torch.sigmoid(x)\n return x\n\n\nclass DropBlock2D(object):\n\n def __init__(self, *args, **kwargs):\n raise NotImplementedError\n\n\nclass GlobalAvgPool2d(nn.Module):\n\n def __init__(self):\n \"\"\"Global average pooling over the input's spatial dimensions\"\"\"\n super(GlobalAvgPool2d, self).__init__()\n\n def forward(self, inputs):\n return nn.functional.adaptive_avg_pool2d(inputs, 1).view(inputs.size(0), -1)\n\n\nclass Bottleneck(nn.Module):\n \"\"\"ResNet Bottleneck\n \"\"\"\n # pylint: disable=unused-argument\n expansion = 4\n\n def __init__(\n self,\n inplanes,\n planes,\n stride=1,\n downsample=None,\n radix=1,\n cardinality=1,\n bottleneck_width=64,\n avd=False,\n avd_first=False,\n dilation=1,\n is_first=False,\n rectified_conv=False,\n rectify_avg=False,\n norm_layer=None,\n dropblock_prob=0.0,\n last_gamma=False\n ):\n super(Bottleneck, self).__init__()\n group_width = int(planes * (bottleneck_width / 64.)) * cardinality\n self.conv1 = nn.Conv2d(inplanes, group_width, kernel_size=1, bias=False)\n self.bn1 = norm_layer(group_width)\n self.dropblock_prob = dropblock_prob\n self.radix = radix\n self.avd = avd and (stride > 1 or is_first)\n self.avd_first = avd_first\n\n if self.avd:\n self.avd_layer = nn.AvgPool2d(3, stride, padding=1)\n stride = 1\n\n if dropblock_prob > 0.0:\n self.dropblock1 = DropBlock2D(dropblock_prob, 3)\n if radix == 1:\n self.dropblock2 = DropBlock2D(dropblock_prob, 3)\n self.dropblock3 = DropBlock2D(dropblock_prob, 3)\n\n if radix >= 1:\n self.conv2 = SplAtConv2d(\n group_width,\n group_width,\n kernel_size=3,\n stride=stride,\n padding=dilation,\n dilation=dilation,\n groups=cardinality,\n bias=False,\n radix=radix,\n rectify=rectified_conv,\n rectify_avg=rectify_avg,\n norm_layer=norm_layer,\n dropblock_prob=dropblock_prob\n )\n elif rectified_conv:\n from rfconv import RFConv2d\n self.conv2 = RFConv2d(\n group_width,\n group_width,\n kernel_size=3,\n stride=stride,\n padding=dilation,\n dilation=dilation,\n groups=cardinality,\n bias=False,\n average_mode=rectify_avg\n )\n self.bn2 = norm_layer(group_width)\n else:\n self.conv2 = nn.Conv2d(\n group_width,\n group_width,\n kernel_size=3,\n stride=stride,\n padding=dilation,\n dilation=dilation,\n groups=cardinality,\n bias=False\n )\n self.bn2 = norm_layer(group_width)\n\n self.conv3 = nn.Conv2d(group_width, planes * 4, kernel_size=1, bias=False)\n self.bn3 = norm_layer(planes * 4)\n\n if last_gamma:\n from torch.nn.init import zeros_\n zeros_(self.bn3.weight)\n self.relu = nn.ReLU(inplace=True)\n self.downsample = downsample\n self.dilation = dilation\n self.stride = stride\n\n def forward(self, x):\n residual = x\n\n out = self.conv1(x)\n out = self.bn1(out)\n if self.dropblock_prob > 0.0:\n out = self.dropblock1(out)\n out = self.relu(out)\n\n if self.avd and self.avd_first:\n out = self.avd_layer(out)\n\n out = self.conv2(out)\n if self.radix == 0:\n out = self.bn2(out)\n if self.dropblock_prob > 0.0:\n out = self.dropblock2(out)\n out = self.relu(out)\n\n if self.avd and not self.avd_first:\n out = self.avd_layer(out)\n\n out = self.conv3(out)\n out = self.bn3(out)\n if self.dropblock_prob > 0.0:\n out = self.dropblock3(out)\n\n if self.downsample is not None:\n residual = self.downsample(x)\n\n out += residual\n out = self.relu(out)\n\n return out\n\n\nclass ResNet(nn.Module):\n \"\"\"ResNet Variants\n\n Parameters\n ----------\n block : Block\n Class for the residual block. Options are BasicBlockV1, BottleneckV1.\n layers : list of int\n Numbers of layers in each block\n classes : int, default 1000\n Number of classification classes.\n dilated : bool, default False\n Applying dilation strategy to pretrained ResNet yielding a stride-8 model,\n typically used in Semantic Segmentation.\n norm_layer : object\n Normalization layer used in backbone network (default: :class:`mxnet.gluon.nn.BatchNorm`;\n for Synchronized Cross-GPU BachNormalization).\n\n Reference:\n\n - He, Kaiming, et al. \"Deep residual learning for image recognition.\" Proceedings of the IEEE conference on computer vision and pattern recognition. 2016.\n\n - Yu, Fisher, and Vladlen Koltun. \"Multi-scale context aggregation by dilated convolutions.\"\n \"\"\"\n\n # pylint: disable=unused-variable\n def __init__(\n self,\n block,\n layers,\n radix=1,\n groups=1,\n bottleneck_width=64,\n num_classes=1000,\n dilated=False,\n dilation=1,\n deep_stem=False,\n stem_width=64,\n avg_down=False,\n rectified_conv=False,\n rectify_avg=False,\n avd=False,\n avd_first=False,\n final_drop=0.0,\n dropblock_prob=0,\n last_gamma=False,\n norm_layer=nn.BatchNorm2d\n ):\n self.cardinality = groups\n self.bottleneck_width = bottleneck_width\n # ResNet-D params\n self.stage_features = []\n self.outplanes = self.inplanes = stem_width * 2 if deep_stem else 64\n self.avg_down = avg_down\n self.last_gamma = last_gamma\n # ResNeSt params\n self.radix = radix\n self.avd = avd\n self.avd_first = avd_first\n\n super(ResNet, self).__init__()\n self.rectified_conv = rectified_conv\n self.rectify_avg = rectify_avg\n if rectified_conv:\n from rfconv import RFConv2d\n conv_layer = RFConv2d\n else:\n conv_layer = nn.Conv2d\n conv_kwargs = {'average_mode': rectify_avg} if rectified_conv else {}\n if deep_stem:\n self.conv1 = nn.Sequential(\n conv_layer(3, stem_width, kernel_size=3, stride=2, padding=1, bias=False, **conv_kwargs),\n norm_layer(stem_width),\n nn.ReLU(inplace=True),\n conv_layer(stem_width, stem_width, kernel_size=3, stride=1, padding=1, bias=False, **conv_kwargs),\n norm_layer(stem_width),\n nn.ReLU(inplace=True),\n conv_layer(stem_width, stem_width * 2, kernel_size=3, stride=1, padding=1, bias=False, **conv_kwargs),\n )\n else:\n self.conv1 = conv_layer(3, 64, kernel_size=7, stride=2, padding=3, bias=False, **conv_kwargs)\n self.bn1 = norm_layer(self.inplanes)\n self.relu = nn.ReLU(inplace=True)\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n self.layer1 = self._make_layer(block, 64, layers[0], norm_layer=norm_layer, is_first=False)\n self.layer2 = self._make_layer(block, 128, layers[1], stride=2, norm_layer=norm_layer)\n if dilated or dilation == 4:\n self.layer3 = self._make_layer(\n block, 256, layers[2], stride=1, dilation=2, norm_layer=norm_layer, dropblock_prob=dropblock_prob\n )\n self.layer4 = self._make_layer(\n block, 512, layers[3], stride=1, dilation=4, norm_layer=norm_layer, dropblock_prob=dropblock_prob\n )\n elif dilation == 2:\n self.layer3 = self._make_layer(\n block, 256, layers[2], stride=2, dilation=1, norm_layer=norm_layer, dropblock_prob=dropblock_prob\n )\n self.layer4 = self._make_layer(\n block, 512, layers[3], stride=1, dilation=2, norm_layer=norm_layer, dropblock_prob=dropblock_prob\n )\n else:\n self.layer3 = self._make_layer(\n block, 256, layers[2], stride=2, norm_layer=norm_layer, dropblock_prob=dropblock_prob\n )\n self.layer4 = self._make_layer(\n block, 512, layers[3], stride=2, norm_layer=norm_layer, dropblock_prob=dropblock_prob\n )\n\n self.avgpool = GlobalAvgPool2d()\n self.drop = nn.Dropout(final_drop) if final_drop > 0.0 else None\n self.fc = nn.Linear(512 * block.expansion, num_classes)\n\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n m.weight.data.normal_(0, math.sqrt(2. / n))\n elif isinstance(m, norm_layer):\n m.weight.data.fill_(1)\n m.bias.data.zero_()\n\n def _make_layer(\n self, block, planes, blocks, stride=1, dilation=1, norm_layer=None, dropblock_prob=0.0, is_first=True\n ):\n downsample = None\n if stride != 1 or self.inplanes != planes * block.expansion:\n down_layers = []\n if self.avg_down:\n if dilation == 1:\n down_layers.append(nn.AvgPool2d(kernel_size=stride, stride=stride, ceil_mode=True, count_include_pad=False))\n else:\n down_layers.append(nn.AvgPool2d(kernel_size=1, stride=1, ceil_mode=True, count_include_pad=False))\n down_layers.append(nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=1, bias=False))\n else:\n down_layers.append(nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False))\n down_layers.append(norm_layer(planes * block.expansion))\n downsample = nn.Sequential(*down_layers)\n\n layers = []\n if dilation == 1 or dilation == 2:\n layers.append(\n block(\n self.inplanes,\n planes,\n stride,\n downsample=downsample,\n radix=self.radix,\n cardinality=self.cardinality,\n bottleneck_width=self.bottleneck_width,\n avd=self.avd,\n avd_first=self.avd_first,\n dilation=1,\n is_first=is_first,\n rectified_conv=self.rectified_conv,\n rectify_avg=self.rectify_avg,\n norm_layer=norm_layer,\n dropblock_prob=dropblock_prob,\n last_gamma=self.last_gamma\n )\n )\n elif dilation == 4:\n layers.append(\n block(\n self.inplanes,\n planes,\n stride,\n downsample=downsample,\n radix=self.radix,\n cardinality=self.cardinality,\n bottleneck_width=self.bottleneck_width,\n avd=self.avd,\n avd_first=self.avd_first,\n dilation=2,\n is_first=is_first,\n rectified_conv=self.rectified_conv,\n rectify_avg=self.rectify_avg,\n norm_layer=norm_layer,\n dropblock_prob=dropblock_prob,\n last_gamma=self.last_gamma\n )\n )\n else:\n raise RuntimeError(\"=> unknown dilation size: {}\".format(dilation))\n\n self.outplanes = self.inplanes = planes * block.expansion\n self.stage_features.append(self.outplanes)\n\n for i in range(1, blocks):\n layers.append(\n block(\n self.inplanes,\n planes,\n radix=self.radix,\n cardinality=self.cardinality,\n bottleneck_width=self.bottleneck_width,\n avd=self.avd,\n avd_first=self.avd_first,\n dilation=dilation,\n rectified_conv=self.rectified_conv,\n rectify_avg=self.rectify_avg,\n norm_layer=norm_layer,\n dropblock_prob=dropblock_prob,\n last_gamma=self.last_gamma\n )\n )\n\n return nn.Sequential(*layers)\n\n def forward(self, x):\n x = self.conv1(x)\n x = self.bn1(x)\n x = self.relu(x)\n x = self.maxpool(x)\n\n x1 = self.layer1(x)\n x2 = self.layer2(x1)\n x3 = self.layer3(x2)\n x4 = self.layer4(x3)\n\n # print(x.size())\n\n # x = self.avgpool(x)\n #x = x.view(x.size(0), -1)\n # x = torch.flatten(x, 1)\n # if self.drop:\n # x = self.drop(x)\n # x = self.fc(x)\n\n return (x1, x2, x3, x4)\n\n_url_format = 'https://github.com/zhanghang1989/ResNeSt/releases/download/weights_step1/{}-{}.pth'\n\n_model_sha256 = {\n name: checksum for checksum, name in [\n ('528c19ca', 'resnest50'),\n ('22405ba7', 'resnest101'),\n ('75117900', 'resnest200'),\n ('0cc87c48', 'resnest269'),\n ]\n}\n\n\ndef short_hash(name):\n if name not in _model_sha256:\n raise ValueError('Pretrained model for {name} is not available.'.format(name=name))\n return _model_sha256[name][:8]\n\n\nresnest_model_urls = {name: _url_format.format(name, short_hash(name)) for name in _model_sha256.keys()}\n\n\ndef resnest50(pretrained=False, root='~/.encoding/models', **kwargs):\n model = ResNet(\n Bottleneck, [3, 4, 6, 3],\n radix=2,\n groups=1,\n bottleneck_width=64,\n deep_stem=True,\n stem_width=32,\n avg_down=True,\n avd=True,\n avd_first=False,\n **kwargs\n )\n if pretrained:\n model.load_state_dict(\n torch.hub.load_state_dict_from_url(resnest_model_urls['resnest50'], progress=True, check_hash=True)\n )\n return model\n\n\ndef resnest101(pretrained=False, root='~/.encoding/models', **kwargs):\n model = ResNet(\n Bottleneck, [3, 4, 23, 3],\n radix=2,\n groups=1,\n bottleneck_width=64,\n deep_stem=True,\n stem_width=64,\n avg_down=True,\n avd=True,\n avd_first=False,\n **kwargs\n )\n if pretrained:\n model.load_state_dict(\n torch.hub.load_state_dict_from_url(resnest_model_urls['resnest101'], progress=True, check_hash=True)\n )\n return model\n\n\ndef resnest200(pretrained=False, root='~/.encoding/models', **kwargs):\n model = ResNet(\n Bottleneck, [3, 24, 36, 3],\n radix=2,\n groups=1,\n bottleneck_width=64,\n deep_stem=True,\n stem_width=64,\n avg_down=True,\n avd=True,\n avd_first=False,\n **kwargs\n )\n if pretrained:\n model.load_state_dict(\n torch.hub.load_state_dict_from_url(resnest_model_urls['resnest200'], progress=True, check_hash=True)\n )\n return model\n\n\ndef resnest269(pretrained=False, root='~/.encoding/models', **kwargs):\n model = ResNet(\n Bottleneck, [3, 30, 48, 8],\n radix=2,\n groups=1,\n bottleneck_width=64,\n deep_stem=True,\n stem_width=64,\n avg_down=True,\n avd=True,\n avd_first=False,\n **kwargs\n )\n if pretrained:\n model.load_state_dict(\n torch.hub.load_state_dict_from_url(resnest_model_urls['resnest269'], progress=True, check_hash=True)\n )\n return model\n\n\nclass FixedBatchNorm(nn.BatchNorm2d):\n\n def forward(self, x):\n return F.batch_norm(x, self.running_mean, self.running_var, self.weight, self.bias, training=False, eps=self.eps)\n\n\ndef group_norm(features):\n return nn.GroupNorm(4, features)\n\n\n#######################################################################\n\ndef patch_conv_in_channels(model, layer_name, new_in_channels, copying_channel=0):\n layer = getattr(model, layer_name) # layer = model.conv1\n # new_layer = layer.clone().detach()\n\n if isinstance(layer, nn.Sequential):\n cv_layers = list(layer.children())\n cv = cv_layers[0]\n else:\n cv = layer\n\n if not isinstance(cv, nn.Conv2d):\n raise ValueError(f\"Cannot extract Conv2d from {cv}.\")\n\n new_cv = nn.Conv2d(\n in_channels=new_in_channels,\n out_channels=cv.out_channels,\n kernel_size=cv.kernel_size,\n stride=cv.stride,\n padding=cv.padding,\n bias=cv.bias).requires_grad_()\n\n with torch.no_grad():\n new_cv.weight[:, :cv.in_channels, :, :] = cv.weight.data\n\n for i in range(new_in_channels - cv.in_channels):\n channel = cv.in_channels + i\n new_cv.weight[:, channel:channel+1, :, :] = cv.weight[:, copying_channel:copying_channel+1, : :].data\n new_cv.weight = nn.Parameter(new_cv.weight)\n\n if isinstance(layer, nn.Sequential):\n new_cv = nn.Sequential(new_cv, *cv_layers[1:])\n\n setattr(model, layer_name, new_cv) # model.conv1 = new_layer\n\n\ndef build_backbone(name, dilated, strides, norm_fn, weights='imagenet', channels=3, **kwargs):\n dilation = 4 if dilated else 2\n\n pretrained = weights == \"imagenet\"\n model_fn = globals()[name]\n model = model_fn(pretrained=pretrained, dilated=dilated, dilation=dilation, norm_layer=norm_fn)\n if channels != 3:\n patch_conv_in_channels(model, \"conv1\", channels)\n if pretrained:\n print(f'loading weights from {resnest_model_urls[name]}')\n\n del model.avgpool\n del model.fc\n\n if weights and weights != 'imagenet':\n print(f'loading weights from {weights}')\n checkpoint = torch.load(weights, map_location=\"cpu\")\n model.load_state_dict(checkpoint['state_dict'], strict=False)\n\n stages = (\n nn.Sequential(model.conv1, model.bn1, model.relu, model.maxpool),\n model.layer1,\n model.layer2,\n model.layer3,\n model.layer4,\n )\n\n return model, stages\n\n\nclass Backbone(nn.Module):\n\n def __init__(\n self,\n model_name,\n weights='imagenet',\n channels=3,\n mode='fix',\n dilated=False,\n strides=None,\n trainable_stem=True,\n trainable_stage4=True,\n trainable_backbone=True,\n backbone_kwargs={},\n ):\n super().__init__()\n\n self.mode = mode\n self.trainable_stem = trainable_stem\n self.trainable_stage4 = trainable_stage4\n self.trainable_backbone = trainable_backbone\n self.not_training = []\n self.from_scratch_layers = []\n\n if mode == 'normal':\n self.norm_fn = nn.BatchNorm2d\n elif mode == 'fix':\n self.norm_fn = FixedBatchNorm\n else:\n raise ValueError(f'Unknown mode {mode}. Must be `normal` or `fix`.')\n\n backbone, stages = build_backbone(\n model_name, dilated, strides, self.norm_fn, weights, channels, **backbone_kwargs,\n )\n\n self.backbone = backbone\n self.stages = stages\n\n if not self.trainable_backbone:\n for s in stages:\n set_trainable_layers(s, trainable=False)\n self.not_training.extend(stages)\n else:\n if not self.trainable_stage4:\n self.not_training.extend(stages[:-1])\n for s in stages[:-1]:\n set_trainable_layers(s, trainable=False)\n\n elif not self.trainable_stem:\n set_trainable_layers(stages[0], trainable=False)\n self.not_training.append(stages[0])\n\n if self.mode == \"fix\":\n for s in stages:\n set_trainable_layers(s, torch.nn.BatchNorm2d, trainable=False)\n self.not_training.extend([m for m in s.modules() if isinstance(m, torch.nn.BatchNorm2d)])\n\n def initialize(self, modules):\n for m in modules:\n if isinstance(m, nn.Conv2d):\n torch.nn.init.kaiming_normal_(m.weight)\n elif isinstance(m, nn.Linear):\n nn.init.trunc_normal_(m.weight, std=.02)\n if isinstance(m, nn.Linear) and m.bias is not None:\n nn.init.constant_(m.bias, 0)\n elif isinstance(m, (nn.BatchNorm2d, nn.SyncBatchNorm, nn.GroupNorm, nn.LayerNorm)):\n nn.init.constant_(m.weight, 1.0)\n nn.init.constant_(m.bias, 0)\n\n def get_parameter_groups(self, exclude_partial_names=(), with_names=False):\n names = ([], [], [], [])\n groups = ([], [], [], [])\n\n scratch_parameters = set()\n all_parameters = set()\n\n for layer in self.from_scratch_layers:\n for name, param in layer.named_parameters():\n if param in all_parameters:\n continue\n scratch_parameters.add(param)\n all_parameters.add(param)\n\n if not param.requires_grad:\n continue\n for p in exclude_partial_names:\n if p in name:\n continue\n\n idx = 2 if \"weight\" in name else 3\n names[idx].append(name)\n groups[idx].append(param)\n\n for name, param in self.named_parameters():\n if param in all_parameters:\n continue\n all_parameters.add(param)\n\n if not param.requires_grad or param in scratch_parameters:\n continue\n for p in exclude_partial_names:\n if p in name:\n continue\n\n idx = 0 if \"weight\" in name else 1\n names[idx].append(name)\n groups[idx].append(param)\n\n if with_names:\n return groups, names\n\n return groups\n\n def train(self, mode=True):\n super().train(mode)\n for m in self.not_training:\n m.eval()\n return self\n\n\ndef gem(x, p=3, eps=1e-6):\n return F.avg_pool2d(x.clamp(min=eps).pow(p), (x.size(-2), x.size(-1))).pow(1./p)\n\n\nclass GeM(nn.Module):\n def __init__(self, p=3, eps=1e-6):\n super(GeM,self).__init__()\n self.p = Parameter(torch.ones(1)*p)\n self.eps = eps\n\n def forward(self, x):\n return gem(x, p=self.p, eps=self.eps)\n\n def __repr__(self):\n return self.__class__.__name__ + '(' + 'p=' + '{:.4f}'.format(self.p.data.tolist()[0]) + ', ' + 'eps=' + str(self.eps) + ')'\n\n\nclass CellClassifier(Backbone):\n\n def __init__(\n self,\n model_name,\n num_classes=20,\n backbone_weights=\"imagenet\",\n channels=3,\n mode='fix',\n dilated=False,\n strides=None,\n trainable_stem=True,\n trainable_stage4=True,\n trainable_backbone=True,\n **backbone_kwargs,\n ):\n super().__init__(\n model_name,\n channels=channels,\n weights=backbone_weights,\n mode=mode,\n dilated=dilated,\n strides=strides,\n trainable_stem=trainable_stem,\n trainable_stage4=trainable_stage4,\n trainable_backbone=trainable_backbone,\n backbone_kwargs=backbone_kwargs,\n )\n\n self.num_classes = num_classes\n\n cin = self.backbone.outplanes\n self.classifier = nn.Conv2d(cin, num_classes, 1, bias=False)\n\n self.from_scratch_layers.extend([self.classifier])\n self.initialize([self.classifier])\n\n self.pool = GeM()\n self.flatten = nn.Flatten()\n self.dropout = nn.Dropout(p=0.5)\n\n self.last_linear_cell = nn.Linear(\n in_features=cin, \n out_features=num_classes)\n self.last_linear_image = nn.Linear(\n in_features=cin, \n out_features=num_classes)\n\n def forward(self, x, cnt=16, with_cam=False):\n if with_cam:\n raise NotImplementedError(\n \"CAM not currently supported in multi-view mode\")\n\n outs = self.backbone(x)\n features = outs[-1] if isinstance(outs, tuple) else outs\n\n pooled = self.flatten(self.pool(features))\n viewed_pooled = pooled.view(-1, cnt, pooled.shape[-1])\n viewed_pooled = viewed_pooled.max(1)[0]\n\n cell_logits = self.last_linear_cell(pooled)\n image_logits = self.last_linear_image(viewed_pooled)\n\n return cell_logits, image_logits\n\n\nclass CellClassifierV2(Backbone):\n\n def __init__(\n self,\n model_name,\n num_classes=20,\n backbone_weights=\"imagenet\",\n channels=3,\n mode='fix',\n dilated=False,\n strides=None,\n trainable_stem=True,\n trainable_stage4=True,\n trainable_backbone=True,\n **backbone_kwargs,\n ):\n super().__init__(\n model_name,\n channels=channels,\n weights=backbone_weights,\n mode=mode,\n dilated=dilated,\n strides=strides,\n trainable_stem=trainable_stem,\n trainable_stage4=trainable_stage4,\n trainable_backbone=trainable_backbone,\n backbone_kwargs=backbone_kwargs,\n )\n\n self.num_classes = num_classes\n cin = self.backbone.outplanes\n\n self.pool = GeM()\n self.flatten = nn.Flatten()\n self.dropout = nn.Dropout(p=0.5)\n\n self.last_linear_cell = nn.Linear(\n in_features=cin, \n out_features=num_classes)\n self.last_linear_image = nn.Linear(\n in_features=cin, \n out_features=num_classes)\n \n self.from_scratch_layers.extend([self.last_linear_cell, self.last_linear_image])\n self.initialize([self.last_linear_cell, self.last_linear_image])\n\n def forward(self, x, cnt=16, with_cam=False, cell_logits_to_image_logits=False):\n cnt = torch.tensor(cnt)\n if with_cam:\n raise NotImplementedError(\n \"CAM not currently supported in multi-view mode\")\n\n outs = self.backbone(x)\n features = outs[-1] if isinstance(outs, tuple) else outs\n\n pooled = self.flatten(self.pool(features))\n\n if cell_logits_to_image_logits:\n cell_logits = self.last_linear_cell(pooled)\n cell_logits_split = torch.split(cell_logits, cnt.tolist())\n image_logits = torch.stack([p.max(0).values for p in cell_logits_split])\n\n return cell_logits, image_logits\n\n pooled_split = torch.split(pooled, cnt.tolist())\n pooled_per_img = torch.stack([p.max(0)[0] for p in pooled_split])\n\n cell_logits = self.last_linear_cell(pooled)\n image_logits = self.last_linear_image(pooled_per_img)\n\n return cell_logits, image_logits\n\n\nclass ImageClassifier(Backbone):\n\n def __init__(\n self,\n model_name,\n num_classes=20,\n backbone_weights=\"imagenet\",\n channels=3,\n mode='fix',\n dilated=False,\n strides=None,\n trainable_stem=True,\n trainable_stage4=True,\n trainable_backbone=True,\n **backbone_kwargs,\n ):\n super().__init__(\n model_name,\n channels=channels,\n weights=backbone_weights,\n mode=mode,\n dilated=dilated,\n strides=strides,\n trainable_stem=trainable_stem,\n trainable_stage4=trainable_stage4,\n trainable_backbone=trainable_backbone,\n backbone_kwargs=backbone_kwargs,\n )\n\n self.num_classes = num_classes\n\n cin = self.backbone.outplanes\n self.classifier = nn.Conv2d(cin, num_classes, 1, bias=False)\n\n self.from_scratch_layers.extend([self.classifier])\n self.initialize([self.classifier])\n\n def forward(self, x, with_cam=False):\n outs = self.backbone(x)\n x = outs[-1] if isinstance(outs, tuple) else outs\n\n if with_cam:\n features = self.classifier(x)\n logits = gap2d(features)\n return logits, features\n else:\n x = gap2d(x, keepdims=True)\n logits = self.classifier(x).view(-1, self.num_classes)\n return logits","metadata":{"trusted":true,"jupyter":{"source_hidden":true}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Load ResNest269 Model","metadata":{}},{"cell_type":"code","source":"models = []\nimage_models = []","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# WEIGHTS_PATHS = [\n# '/kaggle/input/models/julianamidlej/rs50-f0-c16-citl-pw0-1-e15/pytorch/default/1/hpa2nd-rs50-lr0.0002-b6-aug2nd-adamw-eid-citl-3/model-f0-e14.pth']\n# DEVICE = 'cuda'\n\n# for weights_path in WEIGHTS_PATHS:\n# model = CellClassifierV2(\n# 'resnest50',\n# 19,\n# channels=4,\n# mode='normal',\n# dilated=False,\n# backbone_weights=None,\n# )\n# load_model(model, weights_path, map_location=torch.device(DEVICE))\n# model.eval()\n\n# models.append(model)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# WEIGHTS_PATHS = [\n# '/kaggle/input/rs269-vanilla-cp/pytorch/default/1/hpa-512-rs269-lr0.1-b32-ls0.1-re-mix-sgd-ema1-cp-1.0-0.5-sum-2.pth']\n# DEVICE = 'cuda'\n\n# for weights_path in WEIGHTS_PATHS:\n# model = ImageClassifier(\n# 'resnest269',\n# 19,\n# channels=4,\n# mode='normal',\n# dilated=False,\n# backbone_weights=None,\n# )\n# load_model(model, weights_path, map_location=torch.device(DEVICE))\n# model.eval()\n\n# image_models.append(model)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Loading models\n* b3\n* b5\n* r50d\n* r200d\n* se50","metadata":{}},{"cell_type":"code","source":"model_paths = [\n '/kaggle/input/b3/pytorch/default/1/b3/checkpoints/f0_epoch-18.pth',\n '/kaggle/input/b3-f1/pytorch/default/1/b3_F1/checkpoints/f1_epoch-16.pth',\n '/kaggle/input/b3-f2/pytorch/default/1/b3_F2/checkpoints/f2_epoch-17.pth',\n '/kaggle/input/b3-f3/pytorch/default/1/b3_F3/checkpoints/f3_epoch-19.pth',\n '/kaggle/input/b3-f4/pytorch/default/1/b3_F4/checkpoints/f4_epoch-18.pth'\n]\n\nfor model_path in model_paths:\n cfg = Config.load_json('/kaggle/input/b3/pytorch/default/1/b3/config.json')\n model = get_model(cfg).cuda()\n load_matched_state(model, torch.load(model_path))\n _ = model.eval()\n models.append(model)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_paths = [\n '/kaggle/input/b5/pytorch/default/1/b5/checkpoints/f0_epoch-14.pth',\n '/kaggle/input/b5-f1/pytorch/default/1/b5_F1/checkpoints/f1_epoch-14.pth',\n '/kaggle/input/b5-f2/pytorch/default/1/b5_F2/checkpoints/f2_epoch-15.pth',\n '/kaggle/input/b5-f3-v2/pytorch/default/1/b5_F3/checkpoints/f3_epoch-17.pth',\n '/kaggle/input/b5-f4/pytorch/default/1/b5_F4/checkpoints/f4_epoch-14.pth' \n]\n\nfor model_path in model_paths:\n cfg = Config.load_json('/kaggle/input/b5/pytorch/default/1/b5/config.json')\n model = get_model(cfg).cuda()\n load_matched_state(model, torch.load(model_path))\n _ = model.eval()\n models.append(model)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_paths = [\n '/kaggle/input/r50-f0/pytorch/default/1/r50_F0/checkpoints/f0_epoch-14.pth',\n '/kaggle/input/r50-f1/pytorch/default/1/r50_F1/checkpoints/f1_epoch-14.pth',\n '/kaggle/input/r50-f2/pytorch/default/1/r50_F2/checkpoints/f2_epoch-13.pth',\n '/kaggle/input/r50-f3/pytorch/default/1/r50_F3/checkpoints/f3_epoch-15.pth',\n '/kaggle/input/r50-f4/pytorch/default/1/r50_F4/checkpoints/f4_epoch-14.pth'\n]\n\nfor model_path in model_paths:\n cfg = Config.load_json('/kaggle/input/r50-f0/pytorch/default/1/r50_F0/config.json')\n model = get_model(cfg).cuda()\n load_matched_state(model, torch.load(model_path))\n _ = model.eval()\n models.append(model)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!cp ../input/landmark-additional-packages/resnet200d_ra2-bdba9bf9.pth /root/.cache/torch/hub/checkpoints/","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_paths = [\n '/kaggle/input/r200/pytorch/default/1/r200d/checkpoints/f0_epoch-13.pth',\n '/kaggle/input/r200-f1/pytorch/default/1/r200d_F1/checkpoints/f1_epoch-15.pth',\n '/kaggle/input/r200-f2/pytorch/default/1/r200d_F2/checkpoints/f2_epoch-15.pth',\n '/kaggle/input/r200-f3/pytorch/default/1/r200d_F3/checkpoints/f3_epoch-14.pth',\n '/kaggle/input/r200-f4/pytorch/default/1/r200d_F4/checkpoints/f4_epoch-14.pth'\n]\n\nfor model_path in model_paths:\n cfg = Config.load_json('/kaggle/input/r200/pytorch/default/1/r200d/config.json')\n model = get_model(cfg).cuda()\n load_matched_state(model, torch.load(model_path))\n _ = model.eval()\n models.append(model)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"model_paths = [\n '/kaggle/input/se50/pytorch/default/1/se50/checkpoints/f0_epoch-18.pth',\n '/kaggle/input/se50-f1/pytorch/default/1/se50_F1/checkpoints/f1_epoch-19.pth',\n '/kaggle/input/se50-f2/pytorch/default/1/se50_F2/checkpoints/f2_epoch-18.pth',\n '/kaggle/input/se50-f3/pytorch/default/1/se50_F3/checkpoints/f3_epoch-18.pth',\n '/kaggle/input/se50-f4/pytorch/default/1/se50_F4/checkpoints/f4_epoch-18.pth'\n]\n\nfor model_path in model_paths:\n cfg = Config.load_json('/kaggle/input/se50/pytorch/default/1/se50/config.json')\n model = get_model(cfg).cuda()\n load_matched_state(model, torch.load(model_path))\n _ = model.eval()\n models.append(model)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print(len(models))\nprint(len(image_models))","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Cell Segmentator","metadata":{}},{"cell_type":"code","source":"# ! pip install -q \"/kaggle/input/pycocotools/wheels/pycocotools-2.0.6-cp310-cp310-linux_x86_64.whl\"\n# ! cp -r /kaggle/input/hpapytorchzoozip/pytorch_zoo-master .\n# ! pip install -q \"./pytorch_zoo-master\"\n# ! cp -r \"/kaggle/input/hpacellsegmentatormaster/HPA-Cell-Segmentation-master\" .\n# ! pip install -q \"./HPA-Cell-Segmentation-master\"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # Cell Segmentator Tool\n# print(\"\\n... INSTALLING AND IMPORTING CELL-PROFILER TOOL (HPACELLSEG) ...\\n\")\n\n# try:\n# import hpacellseg.cellsegmentator as cellsegmentator\n# from hpacellseg.utils import label_cell\n# except:\n# ! pip install -q \"/kaggle/input/pycocotools/wheels/pycocotools-2.0.6-cp310-cp310-linux_x86_64.whl\"\n# ! cp -r /kaggle/input/hpapytorchzoozip/pytorch_zoo-master .\n# ! pip install -q \"./pytorch_zoo-master\"\n# ! cp -r \"/kaggle/input/hpacellsegmentatormaster/HPA-Cell-Segmentation-master\" .\n# ! pip install -q \"./HPA-Cell-Segmentation-master\"\n\n# import hpacellseg.cellsegmentator as cellsegmentator\n# from hpacellseg.utils import label_cell\n\n# # Install dependencies\n# # ! pip -qq install 'scikit-image<0.15'\n# # ! pip -qq install pycocotools\n# # ! pip -qq install git+https://github.com/CellProfiling/HPA-Cell-Segmentation\n\n# # Imports\n# import os\n# import copy\n# import pickle\n# from math import ceil\n# from itertools import groupby\n# import base64\n# import typing as t\n# import zlib\n# import random\n\n# import cv2\n# import torch\n# import numpy as np\n# import pandas as pd\n# import matplotlib.pyplot as plt\n\n# from tqdm import tqdm\n# from pycocotools import mask as mutils\n# from pycocotools import _mask as coco_mask\n\n# cv2.setNumThreads(0)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# # Cell Segmentator\n\n# NUC_MODEL = '../input/hpacellsegmentatormodelweights/dpn_unet_nuclei_v1.pth'\n# CELL_MODEL = '../input/hpacellsegmentatormodelweights/dpn_unet_cell_3ch_v1.pth'\n\n# import collections\n# collections.Iterable = collections.abc.Iterable\n# np.bool = np.bool_\n\n\n# import torch\n# import torch.nn\n# import torch.nn.functional as F\n# import hpacellseg.cellsegmentator as cellsegmentator\n# from skimage import transform as sk_transform, util as sk_util\n\n# NORMALIZE = {\"mean\": [124 / 255, 117 / 255, 104 / 255], \"std\": [1 / (0.0167 * 255)] * 3}\n\n# class CellSegmentator(cellsegmentator.CellSegmentator):\n# def pred_nuclei(self, images):\n# def _preprocess(image):\n# if isinstance(image, str):\n# image = imageio.imread(image)\n# self.target_shape = image.shape\n# if len(image.shape) == 2:\n# image = np.dstack((image, image, image))\n# image = sk_transform.rescale(image, self.scale_factor, multichannel=True)\n# nuc_image = np.dstack((image[..., 2], image[..., 2], image[..., 2]))\n# if self.padding:\n# rows, cols = nuc_image.shape[:2]\n# self.scaled_shape = rows, cols\n# nuc_image = cv2.copyMakeBorder(\n# nuc_image,\n# 32,\n# (32 - rows % 32),\n# 32,\n# (32 - cols % 32),\n# cv2.BORDER_REFLECT,\n# )\n# nuc_image = nuc_image.transpose([2, 0, 1])\n# return nuc_image\n\n# def _segment_helper(imgs):\n# with torch.no_grad():\n# mean = torch.as_tensor(NORMALIZE[\"mean\"], device=self.device)\n# std = torch.as_tensor(NORMALIZE[\"std\"], device=self.device)\n# imgs = torch.tensor(np.array(imgs)).float()\n# imgs = imgs.to(self.device)\n# imgs = imgs.sub_(mean[:, None, None]).div_(std[:, None, None])\n\n# imgs = self.nuclei_model(imgs)\n# imgs = F.softmax(imgs, dim=1)\n# return imgs\n\n# preprocessed_imgs = map(_preprocess, images)\n# predictions = map(lambda x: _segment_helper([x]), preprocessed_imgs)\n# predictions = map(lambda x: x.to(\"cpu\").numpy()[0], predictions)\n# predictions = map(sk_util.img_as_ubyte, predictions)\n# predictions = list(map(self._restore_scaling_padding, predictions))\n# return predictions\n\n# def pred_cells(self, images, precombined=False):\n# def _preprocess(image):\n# self.target_shape = image.shape\n# if not len(image.shape) == 3:\n# raise ValueError(\"image should has 3 channels\")\n# cell_image = sk_transform.rescale(image, self.scale_factor, multichannel=True)\n# if self.padding:\n# rows, cols = cell_image.shape[:2]\n# self.scaled_shape = rows, cols\n# cell_image = cv2.copyMakeBorder(\n# cell_image,\n# 32,\n# (32 - rows % 32),\n# 32,\n# (32 - cols % 32),\n# cv2.BORDER_REFLECT,\n# )\n# cell_image = cell_image.transpose([2, 0, 1])\n# return cell_image\n\n# def _segment_helper(imgs):\n# with torch.no_grad():\n# mean = torch.as_tensor(NORMALIZE[\"mean\"], device=self.device)\n# std = torch.as_tensor(NORMALIZE[\"std\"], device=self.device)\n# imgs = torch.tensor(np.array(imgs)).float()\n# imgs = imgs.to(self.device)\n# imgs = imgs.sub_(mean[:, None, None]).div_(std[:, None, None])\n\n# imgs = self.cell_model(imgs)\n# imgs = F.softmax(imgs, dim=1)\n# return imgs\n\n# if not precombined:\n# images = self._image_conversion(images)\n# preprocessed_imgs = map(_preprocess, images)\n# predictions = map(lambda x: _segment_helper([x]), preprocessed_imgs)\n# predictions = map(lambda x: x.to(\"cpu\").numpy()[0], predictions)\n# predictions = map(self._restore_scaling_padding, predictions)\n# predictions = list(map(sk_util.img_as_ubyte, predictions))\n\n# return predictions","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# segmentator = CellSegmentator(\n# NUC_MODEL,\n# CELL_MODEL,\n# scale_factor=0.25,\n# device=DEVICE,\n# padding=True,\n# multi_channel_model=True,\n# )","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# import os\n# import glob\n# from pathlib import Path\n\n# # Define your root and test image directory\n# ROOT = '../input/hpa-single-cell-image-classification'\n# TEST_IMAGES_DIR = f\"{ROOT}/test/\"\n\n# print(f\"Listing images in: {TEST_IMAGES_DIR}\")\n\n# # This method lists all files and directories, so you need to filter for files\n# images_set = set()\n# if os.path.exists(TEST_IMAGES_DIR):\n# for filename in os.listdir(TEST_IMAGES_DIR):\n# if filename.endswith(\".png\") or filename.endswith(\".jpg\"): # Assuming image formats\n# images_set.add(filename.split('_')[0])\n# print(f\"\\n(os.listdir): Found {len(images_set)} images.\")\n# else:\n# print(f\"Directory not found: {TEST_IMAGES_DIR}\")","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# def load_all_images_dict(images_dir, sample_ids):\n# image_dict = {}\n\n# for sample_id in tqdm(sample_ids, desc=\"Loading images\"):\n# try:\n# image = get_image(images_dir, sample_id)\n# image_dict[sample_id] = image\n# except Exception as e:\n# print(f\"Erro ao carregar {sample_id}: {e}\")\n# continue\n\n# return image_dict","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# image_dict = load_all_images_dict(TEST_IMAGES_DIR, images_set)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# def get_masks_from_images(image_ids, imgs):\n# cell_masks = []\n \n# # Iterar por cada imagem individualmente e monitorar o progresso com tqdm\n# for image_id, img in tqdm(zip(image_ids, imgs), desc=\"Generating cell masks\", total=len(image_ids)):\n# # Separando as imagens em diferentes canais (R, G, B)\n# image = [\n# img[:, :, 0], # canal vermelho\n# img[:, :, 3], # canal amarelo (presumido)\n# img[:, :, 2], # canal azul\n# ]\n\n# # Segmentação de núcleos\n# nuc_segmentations = segmentator.pred_nuclei([image[2]])\n# # Segmentação de células\n# cell_segmentations = segmentator.pred_cells(image)\n\n# # Gerando a máscara da célula\n# _, cell_mask = label_cell(nuc_segmentations, cell_segmentations)\n# cell_masks.append(cell_mask)\n\n# return cell_masks\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# image_ids = list(image_dict.keys())\n# images = list(image_dict.values())\n\n# cell_masks = get_masks_from_images(image_ids, images)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## If we read from a csv","metadata":{}},{"cell_type":"code","source":"df = pd.read_csv('/kaggle/input/hpa-best-segmentation-take-use/best_segmentation_result.csv')\n# df = pd.read_csv('/kaggle/input/segmentation-masks-lucas-baseline/submission.csv')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"df","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Lista para armazenar os dicionários com informações de cada célula\nimgs = []\n\n# Itera sobre todas as linhas do DataFrame df\nfor i, x in df.iterrows():\n \n # Extrai os labels da string PredictionString (um a cada 3 itens)\n label = x.PredictionString.split(' ')[0::3]\n \n # Extrai as probabilidades associadas aos labels (um a cada 3 itens)\n prob = x.PredictionString.split(' ')[1::3]\n \n # Extrai as máscaras codificadas em RLE (um a cada 3 itens)\n encodes = x.PredictionString.split(' ')[2::3]\n \n # Itera sobre os RLEs únicos (remove duplicatas com set)\n for idx, enc in enumerate(list(set(encodes))):\n imgs.append({\n 'image_id': x.ID, # ID da imagem original\n 'cell_id': idx + 1, # Índice da célula (começa do 1)\n 'enc': enc, # Máscara codificada em RLE\n 'fname': f'{x.ID}_{idx+1}', # Nome do arquivo no formato _\n })\n\n# Converte a lista de dicionários em um novo DataFrame\ntm = pd.DataFrame(imgs)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"tm","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"df = df.drop(columns='PredictionString')\ndf.head()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"sample_submission = pd.read_csv('../input/hpa-single-cell-image-classification/sample_submission.csv', index_col=0)\nsample_submission.head()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class SliceInferenceDataset(torch.utils.data.Dataset):\n def __init__(self, df, tta=16, cfg=None, tfms=None):\n self.df = df # DataFrame contendo informações de imagem_id e codificação da máscara\n self.iids = self.df.image_id.unique() # Lista única de IDs de imagem\n self.tta = tta # Número de Test Time Augmentations a serem aplicados\n \n def __len__(self):\n return len(self.iids) # Número total de imagens únicas\n\n def __getitem__(self, idx):\n iid = self.iids[idx] # Pega o image_id pelo índice\n \n # Define uma seed fixa para garantir reproducibilidade por amostra\n seed = 42\n random.seed(seed)\n np.random.seed(seed)\n \n # Lê os canais de imagem correspondentes a cada cor (em escala de cinza)\n mt = f'../input/hpa-single-cell-image-classification/test/{iid}_red.png'\n er = f'../input/hpa-single-cell-image-classification/test/{iid}_yellow.png'\n nu = f'../input/hpa-single-cell-image-classification/test/{iid}_blue.png'\n pr = f'../input/hpa-single-cell-image-classification/test/{iid}_green.png'\n r = cv2.imread(mt, 0).astype(np.float) / 255.0\n g = cv2.imread(pr, 0).astype(np.float) / 255.0\n b = cv2.imread(nu, 0).astype(np.float) / 255.0\n a = cv2.imread(er, 0).astype(np.float) / 255.0\n \n sz = r.shape[0] # Assume imagem quadrada (W = H)\n img = np.stack([r, g, b, a], -1) # Empilha os 4 canais para criar imagem 4-channel RGBY\n \n sli = [] # Lista para armazenar os crops das células (imagem + fname)\n \n # Itera sobre todas as células daquela imagem\n for i, x in self.df[self.df.image_id == iid].iterrows():\n # Decodifica a máscara RLE\n bd = base64.b64decode(x.enc)\n zd = zlib.decompress(bd)\n encoded = [{'counts': zd, 'size': (sz, sz)}]\n ded = coco_mask.decode(encoded)[:, :, 0] # Máscara binária\n\n # Se não tiver célula detectada\n if len(np.unique(ded)) == 1:\n continue\n\n # Extrai bounding box da máscara\n xr, yr = np.where(ded == 1)\n sub = img[xr.min(): xr.max(), yr.min(): yr.max()] # Recorta imagem\n crop_sub_mask = ded[xr.min(): xr.max(), yr.min(): yr.max()]\n crop_sub_mask = np.repeat(crop_sub_mask[:, :, np.newaxis], 4, axis=2) # Expande máscara para 4 canais\n \n # Aplica máscara à imagem\n r = sub * crop_sub_mask\n\n # Ajusta para quadrado e redimensiona para 256×256\n sli.append((cv2.resize(squarify(r, 0), (256, 256)).astype(np.float32), x.fname))\n\n # Se nenhuma célula válida foi extraída da imagem, retorna None\n if not sli:\n return None\n \n BS, tta = len(sli) + 1, self.tta # BS: batch size estimado (número de células + 1)\n ipts = [] # Lista de batches de células com TTA\n\n raw_ipt = [e[0] for e in sli] # Apenas as imagens (sem o fname)\n\n # Aplica transformações de TTA\n if tta == 1:\n ipts.append(torch.stack([tensor_tfms(res_tfms(image=x)['image']) for x in raw_ipt]).float())\n else:\n for tt in range(tta):\n ipts.append(torch.stack([tensor_tfms(tta_tfms(image=x)['image']) for x in raw_ipt]).float())\n\n # Também transforma a imagem inteira para outro uso (ex: CAM)\n image = image_tfms(image_res_tfms(image=img)['image'])\n \n # Retorna:\n # - imagem da amostra inteira (RGBY)\n # - células da imagem após TTA\n # - batch size estimado\n # - número de células detectadas\n # - número de TTA\n # - image_id\n # - lista dos nomes de arquivos para cada célula\n return image, ipts, BS, len(sli), tta, iid, [x[1] for x in sli]\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def seed_worker(worker_id):\n worker_seed = torch.initial_seed() % 2**32\n np.random.seed(worker_seed)\n random.seed(worker_seed)\n\nsid = SliceInferenceDataset(tm, tta=1)\ndl = torch.utils.data.DataLoader(sid, batch_size=1, num_workers=2, worker_init_fn=seed_worker)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Move os modelos para GPU e define modo de avaliação (desativa dropout, batchnorm)\nmodels = [model.cuda().eval() for model in models]\n\n# Listas para armazenar predições\npdfs = [] # Para armazenar predições por célula\nwhole_dfs = [] # Para armazenar predições por imagem (whole image prediction)\n\n# Loop sobre o DataLoader de inferência (dl)\nfor image, ipts, BS, lsli, tta, iid, fnames_raw in tqdm.tqdm(dl):\n # Extração e formatação das variáveis\n BS = BS.item() # Tamanho do batch\n # print(BS)\n tta = tta.item() # Número de Test Time Augmentations\n iid = iid[0] # image_id (string)\n fnames = [e[0] for e in fnames_raw] # Nomes dos arquivos das células\n lsli = lsli.item() # Número de células na imagem\n # print(lsli)\n \n predicted_ps = [] # Lista para armazenar as predições de células\n exp_ps = [] # Lista para armazenar as predições da imagem inteira\n\n # Processamento das células em blocos do tamanho do batch\n for i in range(0, lsli, BS):\n with torch.no_grad():\n res = [] # Predições por célula (para cada modelo com TTA)\n exp = [] # Predições da imagem inteira (para cada modelo)\n \n # Inferência da imagem completa com modelos de imagem (ex: Puzzle-CAM)\n for model in image_models:\n image = image.float() # Garante que o tipo é float32\n model = model.float() # Idem para o modelo\n exp.append(model(image)) # Predição da imagem\n\n # Inferência por TTA: aplica vários modelos às células com augmentations\n for tt in range(tta):\n ipt = ipts[tt][0].cuda() # Recupera as células para essa TTA e move para GPU\n for model in models:\n with torch.cuda.amp.autocast(): # Inferência com mixed-precision\n ifr = model(ipt, len(ipt)) # Modelo retorna predição por célula + imagem\n res.append(ifr[0].float()) # Coleta saída da célula\n exp.append(ifr[1].float()) # Coleta saída da imagem\n\n # Média das predições de cada célula com sigmoid (multi-label)\n predict_p = [torch.sigmoid(r.cpu()) for r in res]\n exp_p = [torch.sigmoid(r.cpu()) for r in exp]\n predict_p = np.stack(predict_p).mean(0) # Média ao longo de modelos/TTA\n exp_p = np.stack(exp_p).mean(0) # Média ao longo de modelos/TTA\n\n predicted_ps.append(predict_p) # Armazena predições das células\n exp_ps.append(exp_p) # Armazena predições da imagem\n\n # Concatena predições por célula (final do loop da imagem)\n p = np.concatenate(predicted_ps) # Shape: (n_cells, n_classes)\n image_df = pd.DataFrame(p, index=fnames) # DataFrame com scores para cada célula\n whole_df = pd.DataFrame(\n np.concatenate(exp_ps).mean(0).reshape(1, 19), index=[iid]\n ) # DataFrame com score médio da imagem inteira\n\n # Salva resultados\n whole_dfs.append(whole_df) # Uma linha por imagem\n pdfs.append(image_df) # Uma linha por célula","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Concatena todos os DataFrames de predição por imagem (gerados durante a inferência)\n# Isso resulta em um DataFrame onde cada linha representa uma imagem (image_id) com predições para cada classe\nimage_level = pd.concat(whole_dfs)\n\n# Junta o DataFrame `image_level` com o DataFrame `tm`, para associar os image_id com seus nomes de arquivo (fname)\n# - `reset_index()` move o índice (que contém image_id) para uma coluna chamada 'index'\n# - `merge(..., how='left')` garante que todos os dados de `image_level` sejam mantidos\n# - `on='index'` (de `image_level`) se conecta com `image_id` (de `tm`)\nimage_pred = image_level.reset_index().merge(\n tm[['image_id', 'fname']], # Subconjunto com apenas as colunas relevantes do `tm`\n left_on='index', # Usa o antigo índice como chave de junção\n right_on='image_id', # Faz a junção com a coluna image_id do `tm`\n how='left' # Preserva todas as linhas de `image_level`\n)\n# Organiza o DataFrame final:\n# - Define 'fname' como índice, o que facilita o acesso por nome de célula depois\n# - Remove as colunas 'index' (image_id original do image_level) e 'image_id' (duplicado do tm)\nimage_pred = image_pred.set_index('fname').drop(['index', 'image_id'], axis=1)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Concatena todos os DataFrames de predições por célula (armazenados em `pdfs`)\n# Cada DataFrame em `pdfs` contém predições de classes para as células daquela imagem, indexadas por fname (ex: \"abc_1\")\npub_pred = pd.concat(pdfs)\n\n# Multiplica as predições por célula (`pub_pred`) pelas predições a nível de imagem (`image_pred`)\n# - Ambas têm o mesmo índice (fname, como \"abc_1\"), então a operação é feita elemento a elemento\n# - Isso pode ser interpretado como um reponderamento das predições da célula com base na imagem\n# (por exemplo, se a imagem não tiver forte ativação para uma classe, a predição da célula será atenuada)\nmerge_pred = pub_pred * image_pred.loc[pub_pred.index]","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## If any ensemble","metadata":{}},{"cell_type":"code","source":"merge_pred.head()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Save prediction","metadata":{}},{"cell_type":"code","source":"df.head()","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"df = df.set_index('ID') # Define a coluna 'ID' como índice do DataFrame `df`\nmerge_pred.index.name = 'fname' # Define o nome do índice de `merge_pred` como 'fname'\nmerge_pred = merge_pred.reset_index() # Reseta o índice de `merge_pred`, transformando 'fname' em uma coluna normal\ntm = tm.set_index('fname') # Define a coluna 'fname' como índice do DataFrame `tm`\n\n# Cria uma nova coluna 'ID' em `merge_pred`, extraindo a parte antes do \"_\" da coluna 'fname'\n# Exemplo: se fname = \"abc_3\", então ID = \"abc\"\nmerge_pred['ID'] = merge_pred['fname'].str.split('_', expand=True)[0]","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Lista para armazenar as predições finais formatadas por imagem\nj_pred = []\n\n# Itera sobre todos os IDs únicos (ou seja, imagens únicas) presentes no DataFrame `merge_pred`\nfor iid in merge_pred.ID.unique():\n enc = '' # Inicializa a string de predição para essa imagem\n\n # Filtra `merge_pred` para obter apenas as linhas (células) associadas ao ID atual (imagem atual)\n sub_df = merge_pred[merge_pred.ID == iid]\n\n # Para cada célula da imagem\n for idx, row in sub_df.iterrows():\n # Para cada uma das 19 classes (0 a 18), cria um trecho do tipo: \"class prob mask\"\n for i in range(19):\n enc += f'{i} {row[i]} {tm.loc[row.fname].enc} '\n \n # Adiciona a predição formatada como um dicionário na lista `j_pred`\n # Remove o último espaço de `enc` com `[:-1]`\n j_pred.append({\n 'ID': iid, # ID da imagem\n 'ImageWidth': df.loc[iid].ImageWidth, # Largura da imagem (obtida do DataFrame original `df`)\n 'ImageHeight': df.loc[iid].ImageHeight, # Altura da imagem\n 'PredictionString': enc[:-1] # String com todas as predições no formato esperado para submissão\n })\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Converte a lista de dicionários `j_pred` em um DataFrame do pandas\nfast_sub = pd.DataFrame(j_pred)\n\n# Salva esse DataFrame em um arquivo CSV chamado 'pub.csv'\n# Esse arquivo será formatado como exigido para submissão na competição (ID, ImageWidth, ImageHeight, PredictionString)\nfast_sub.to_csv('pub.csv', index=False)\n\n# Define a coluna 'ID' como índice do DataFrame (útil para buscas e manipulações futuras)\nfast_sub = fast_sub.set_index('ID')\n","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"fast_sub.head(2)","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## save","metadata":{}},{"cell_type":"code","source":"# Substitui as previsões do DataFrame `sample_submission` pelas do `fast_sub`\n# drop(fast_sub.index): remove as linhas de 'sample_submission' que já estão em 'fast_sub' (com mesmo ID)\n# depois concatena com 'fast_sub' para manter as novas previsões\nsub2 = pd.concat([sample_submission.drop(fast_sub.index), fast_sub], axis=0)\n\n# Reordena as linhas para seguir exatamente a ordem original de 'sample_submission'\nsub2 = sub2.loc[sample_submission.index]\n\n# Salva o novo DataFrame como CSV no formato de submissão exigido\nsub2.to_csv('submission.csv')","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}