{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"!pip install '../input/pytorch-190/torch-1.9.0+cu111-cp37-cp37m-linux_x86_64.whl' --no-deps\n!pip install '../input/pytorch-190/torchvision-0.10.0+cu111-cp37-cp37m-linux_x86_64.whl' --no-deps","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!pip install '/kaggle/input/mmdetection-v217/mmdetection/addict-2.4.0-py3-none-any.whl' --no-deps\n!pip install '/kaggle/input/mmdetection-v217/mmdetection/yapf-0.31.0-py2.py3-none-any.whl' --no-deps\n!pip install '/kaggle/input/mmdetection-v217/mmdetection/terminal-0.4.0-py3-none-any.whl' --no-deps\n!pip install '/kaggle/input/mmdetection-v217/mmdetection/terminaltables-3.1.0-py3-none-any.whl' --no-deps\n!pip install '/kaggle/input/mmdetection-v217/mmdetection/mmcv_full-1.3.x-py2.py3-none-any/mmcv_full-1.3.16-cp37-cp37m-manylinux1_x86_64.whl' --no-deps\n!cp -R ../input/mmdetection-v217/mmdetection/pycocotools-2.0.2 ./\n!cp -R ../input/mmdetection-v217/mmdetection/mmpycocotools-12.0.3 ./\n!pip install './pycocotools-2.0.2/pycocotools-2.0.2' --no-deps\n!pip install './mmpycocotools-12.0.3/mmpycocotools-12.0.3' --no-deps\n\n!rm -rf mmdetection\n\n!cp -r /kaggle/input/mmdetection-v217/mmdetection/mmdetection-2.18.0 /kaggle/working/\n!mv /kaggle/working/mmdetection-2.18.0 /kaggle/working/mmdetection\n%cd /kaggle/working/mmdetection\n!pip install -e .\n\n# !rm -rf mmdetection\n\n# !git clone https://github.com/open-mmlab/mmdetection.git /kaggle/working/mmdetection","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nos.environ['CUDA_LAUNCH_BLOCKING'] = \"1\"\n#os.environ[\"PYTORCH_NO_CUDA_MEMORY_CACHING\"] = str(1)\nimport torch\nimport torch.nn as nn\nimport torchvision.transforms as transforms\nimport torch.nn.functional as F\nimport sklearn\nimport torchvision\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import LabelEncoder\nimport numpy as np\nimport pandas as pd\nimport cupy as cp\nimport shutil\nimport matplotlib.pyplot as plt\nimport PIL\nimport json\nfrom PIL import Image, ImageEnhance\nimport albumentations as A\nimport mmdet\nimport mmcv\nfrom albumentations.pytorch import ToTensorV2\nimport seaborn as sns\nimport glob\nfrom pathlib import Path\nimport pycocotools\nfrom pycocotools import mask\nimport numpy.random\nimport random\nimport cv2\nimport re\nfrom mmdet.datasets import build_dataset\nfrom mmdet.models import build_detector\nfrom mmdet.apis import train_detector\nfrom mmdet.apis import inference_detector, init_detector, show_result_pyplot, set_random_seed","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def rle_decode(mask_rle, shape):\n    '''\n    mask_rle: run-length as string formated (start length)\n    shape: (height,width) of array to return \n    Returns numpy array, 1 - mask, 0 - background\n\n    '''\n    s = mask_rle.split()\n    starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]\n    starts -= 1\n    ends = starts + lengths\n    img = np.zeros(shape[0]*shape[1], dtype=np.uint8)\n    for lo, hi in zip(starts, ends):\n        img[lo:hi] = 1\n    return img.reshape(shape)\n\ndef rle_encode(img):\n    '''\n    img: numpy array, 1 - mask, 0 - background\n    Returns run length as string formated\n    '''\n    pixels = img.flatten()\n    pixels = np.concatenate([[0], pixels, [0]])\n    runs = np.where(pixels[1:] != pixels[:-1])[0] + 1\n    runs[1::2] -= runs[::2]\n    return ' '.join(str(x) for x in runs)\n\n\ndef flatten_l_o_l(nested_list):\n    \"\"\" Flatten a list of lists \"\"\"\n    return [item for sublist in nested_list for item in sublist]\n\n\ndef load_json_to_dict(json_path):\n    \"\"\" tbd \"\"\"\n    with open(json_path) as json_file:\n        data = json.load(json_file)\n    return data","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def get_img_and_mask(img_path, annotation, width, height):\n    \"\"\" Capture the relevant image array as well as the image mask \"\"\"\n    img_mask = np.zeros((height, width), dtype=np.uint8)\n    for i, annot in enumerate(annotation): \n        img_mask = np.where(rle_decode(annot, (height, width))!=0, i, img_mask)\n    img = cv2.imread(img_path)[..., ::-1]\n    return img[..., 0], img_mask\n\ndef plot_img_and_mask(img, mask, invert_img=True, boost_contrast=True):\n    \"\"\" Function to take an image and the corresponding mask and plot\n    \n    Args:\n        img (np.arr): 1 channel np arr representing the image of cellular structures\n        mask (np.arr): 1 channel np arr representing the instance masks (incrementing by one)\n        invert_img (bool, optional): Whether or not to invert the base image\n        boost_contrast (bool, optional): Whether or not to boost contrast of the base image\n        \n    Returns:\n        None; Plots the two arrays and overlays them to create a merged image\n    \"\"\"\n    plt.figure(figsize=(20,10))\n    \n    plt.subplot(1,3,1)\n    _img = np.tile(np.expand_dims(img, axis=-1), 3)\n    \n    # Flip black-->white ... white-->black\n    if invert_img:\n        _img = _img.max()-_img\n        \n    if boost_contrast:\n        _img = np.asarray(ImageEnhance.Contrast(Image.fromarray(_img)).enhance(16))\n        \n    plt.imshow(_img)\n    plt.axis(False)\n    plt.title(\"Cell Image\", fontweight=\"bold\")\n    \n    plt.subplot(1,3,2)\n    _mask = np.zeros_like(_img)\n    _mask[..., 0] = mask\n    plt.imshow(mask, cmap='rainbow')\n    plt.axis(False)\n    plt.title(\"Instance Segmentation Mask\", fontweight=\"bold\")\n    \n    merged = cv2.addWeighted(_img, 0.75, np.clip(_mask, 0, 1)*255, 0.25, 0.0,)\n    plt.subplot(1,3,3)\n    plt.imshow(merged)\n    plt.axis(False)\n    plt.title(\"Cell Image w/ Instance Segmentation Mask Overlay\", fontweight=\"bold\")\n    \n    plt.tight_layout()\n    plt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def polygonFromMask(maskedArr, idx):\n    # adapted from https://github.com/hazirbas/coco-json-converter/blob/master/generate_coco_json.py\n    contours, _ = cv2.findContours(maskedArr, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n    segmentation = []\n    valid_poly = 0\n    for contour in contours:\n        # Valid polygons have >= 6 coordinates (3 points)\n         if contour.size >= 6:\n            segmentation.append(contour.astype(float).flatten().tolist())\n            valid_poly += 1\n    if valid_poly == 0:\n        raise ValueError(idx)\n    return [segmentation]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"os.chdir(\"/kaggle/input/\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df = pd.read_csv('../input/annotation-correction-v2/train.csv')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"lines = []\nfor f in train_df.itertuples():\n    lines.append('../input/sartorius-cell-instance-segmentation/train/' + f[1] + '.png')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"lins = pd.Series(lines, name='img_path')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df = pd.concat([train_df, lins], axis=1)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tmp_df = train_df.drop_duplicates(subset=[\"id\", \"img_path\"]).reset_index(drop=True)\ntmp_df[\"annotation\"] = train_df.groupby(\"id\")[\"annotation\"].agg(list).reset_index(drop=True)\ntrain_df = tmp_df.copy()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def plot_mask(idx):\n    im, mk = get_img_and_mask(**train_df[[\"img_path\", \"annotation\", \"width\", \"height\"]].iloc[idx].to_dict())\n    plot_img_and_mask(im, mk)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# plot_mask(0)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df, val_df = train_test_split(train_df, train_size=0.95, random_state=0)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df = train_df.reset_index(drop=True)\nval_df = val_df.reset_index(drop=True)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"os.chdir(\"/kaggle/working/\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"%%writefile labels.txt\nshsy5y\ncort\nastro","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"os.chdir(\"/kaggle/working/mmdetection\")\n#!ls configs/detectors","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from mmcv import Config\n# cfg = Config.fromfile('/kaggle/working/mmdetection/configs/htc/htc_x101_64x4d_fpn_dconv_c3-c5_mstrain_400_1400_16x1_20e_coco.py')\ncfg = Config.fromfile('configs/detectors/detectors_htc_r50_1x_coco.py')\n# cfg = Config.fromfile('/kaggle/working/mmdetection/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco.py')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# print(cfg.pretty_text)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"cfg.dataset_type = 'CocoDataset'\ncfg.classes = '/kaggle/working/labels.txt'\ncfg.data_root = '/kaggle/working'\nfor head in cfg.model.roi_head.bbox_head:\n    head.num_classes = 3\n\n# cfg.model.roi_head.mask_head.semantic_head.num_classes=3\nfor head in cfg.model.roi_head.mask_head:\n    head.num_classes=3\n    \ncfg.data.test.type = 'CocoDataset'\ncfg.data.test.classes = 'labels.txt'\ncfg.data.test.data_root = '/kaggle/working'\ncfg.data.test.ann_file = '../input/my-json/val_dataset.json'\ncfg.data.test.img_prefix = ''\n\ncfg.data.train.type = 'CocoDataset'\ncfg.data.train.data_root = '/kaggle/working'\ncfg.data.train.ann_file = '../input/my-json/train_dataset.json'\ncfg.data.train.seg_prefix=''\n\ncfg.data.train.img_prefix = ''\ncfg.data.train.classes = 'labels.txt'\n\ncfg.data.val.type = 'CocoDataset'\ncfg.data.val.data_root = '/kaggle/working'\ncfg.data.val.ann_file = '../input/my-json/val_dataset.json'\ncfg.data.val.img_prefix = ''\ncfg.data.val.classes = 'labels.txt'\n\nalbu_train_transforms = []\n\n#img_scale=[(1333, 800), (1056, 780)],\n\ncfg.img_norm_cfg = dict(\n   mean=[128, 128, 128], std=[11.58, 11.58, 11.58], to_rgb=True)\ncfg.train_pipeline = [\n    dict(type='LoadImageFromFile'),\n    dict(\n        type='LoadAnnotations', with_bbox=True, with_mask=True, with_seg=True),\n    dict(\n        type='Resize',\n        img_scale=[(1333, 800), (1056, 780)],\n        #img_scale=[(1333, 400), (1333, 1200)],\n        multiscale_mode='value',\n        keep_ratio=True),\n    dict(type='RandomFlip', direction=['horizontal', 'vertical'], flip_ratio=0.5),\n    dict(type='Normalize', **cfg.img_norm_cfg),\n    dict(type='Pad', size_divisor=32),\n    dict(type='SegRescale', scale_factor=1 / 8),\n    dict(type='DefaultFormatBundle'),\n    dict(\n        type='Collect',\n        keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks', 'gt_semantic_seg']),\n]\n\n# cfg.val_pipeline = [\n#     dict(type='LoadImageFromFile'),\n#     dict(\n#         type='MultiScaleFlipAug',\n# #         img_scale=[(880, 1192), (960, 130), (1040, 1408), (1160, 1570), (1240, 1678)],\n#         img_scale = [(1333, 800), (1690, 960)],\n#         flip=False,\n#         transforms=[\n#         dict(type='Collect', keys=['img'])\n#         ])\n# ]\n\n#img_scale=[(1333, 800), (1056, 780)],\ncfg.test_pipeline = [\n    dict(type='LoadImageFromFile'),\n    dict(\n        type='MultiScaleFlipAug',\n\n        img_scale=[(1333, 800), (1056, 780)],\n        flip=False,\n        transforms=[\n            dict(type='Resize', keep_ratio=True),\n            #dict(type='RandomFlip',direction=['horizontal', 'vertical'],\n            dict(type='Normalize', **cfg.img_norm_cfg),\n            dict(type='Pad', size_divisor=32),\n            dict(type='ImageToTensor', keys=['img']),\n            dict(type='Collect', keys=['img']),\n        ])\n]\n\n\ncfg.data.train.pipeline = cfg.train_pipeline\ncfg.data.val.pipeline = cfg.test_pipeline\ncfg.data.test.pipeline = cfg.test_pipeline\n\ncfg.model.test_cfg.rcnn.max_per_img = 380\n\ncfg.load_from = '../input/checkpointhope/detectors_htc_r50_1x_coco-329b1453.pth'\n\ncfg.work_dir = '/kaggle/working/model_output'\n\ncfg.optimizer.lr = 0.004\ncfg.data.samples_per_gpu = 1\ncfg.data.workers_per_gpu = 0\n\ncfg.lr_config = dict(\n    policy='step',\n    warmup='linear',\n    warmup_iters=500,\n    warmup_ratio=0.001,\n    step=[8, 11])\n\n# cfg.lr_config = dict(\n#     policy='CosineAnnealing', \n#     by_epoch=False,\n#     warmup='linear', \n#     warmup_iters=125, \n#     warmup_ratio=0.001,\n#     min_lr=1e-07)\n\ncfg.evaluation.metric = 'segm'\ncfg.roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0,use_torchvision=True)\ncfg.model.roi_head.bbox_roi_extractor.roi_layer=dict(type= 'RoIAlign', output_size= 7, sampling_ratio= 0,use_torchvision=True)\ncfg.model.roi_head.mask_roi_extractor.roi_layer=dict(type= 'RoIAlign', output_size= 14, sampling_ratio= 0,use_torchvision=True)\ncfg.model.roi_head.mask_roi_extractor.roi_layer=dict(type= 'RoIAlign', output_size= 14, sampling_ratio= 0,use_torchvision=True)\n\ncfg.checkpoint_config = dict(interval=1,max_keep_ckpts=8)\ncfg.runner = dict(type='EpochBasedRunner', max_epochs=15)\ncfg.seed=22\ncfg.gpu_ids = range(1)\n#cfg.fp16 = dict(loss_scale=512.0)\nmeta = dict()\nmeta['config'] = cfg.pretty_text\n#print(f'Config:\\n{cfg.pretty_text}')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"os.chdir(\"/kaggle/working\")","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"datasets = [build_dataset(cfg.data.train)]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"datasets","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model = build_detector(cfg.model, train_cfg=cfg.get('train_cfg'), test_cfg=cfg.get('test_cfg'))\nmodel.CLASSES = datasets[0].CLASSES\nmmcv.mkdir_or_exist(os.path.abspath(cfg.work_dir))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_detector(model, datasets, cfg, distributed=False, validate=False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# confidence_thresholds = {0: 0.25, 1: 0.55, 2: 0.35}","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# def get_mask_from_result(result):\n#     d = {True : 1, False : 0}\n#     u,inv = np.unique(result,return_inverse = True)\n#     mk = cp.array([d[x] for x in u])[inv].reshape(result.shape)\n# #     print(mk.shape)\n#     return mk\n\n# def does_overlap(mask, other_masks):\n#     for other_mask in other_masks:\n#         if np.sum(np.logical_and(mask, other_mask)) > 0:\n#             return True\n#     return False\n\n\n# def remove_overlapping_pixels(mask, other_masks):\n#     for other_mask in other_masks:\n#         if np.sum(np.logical_and(mask, other_mask)) > 0:\n#             #print(\"Overlap detected\")\n#             mask[np.logical_and(mask, other_mask)] = 0\n#     return mask\n\n# def rle_encoding(x):\n#     dots = np.where(x.flatten() == 1)[0]\n#     run_lengths = []\n#     prev = -2\n#     for b in dots:\n#         if (b>prev+1): run_lengths.extend((b + 1, 0))\n#         run_lengths[-1] += 1\n#         prev = b\n#     return ' '.join(map(str, run_lengths))\n\n# from skimage import measure\n# from skimage.filters import unsharp_mask\n# def unsharp(img):\n#     unsharp_img = unsharp_mask(img, radius=5, amount=1.0)\n\n#     return unsharp_img","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# import os\n# model_output = os.path.join('../input/mmdetection-new-cfg-training', 'model_output')\n# os.listdir(model_output)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# model = init_detector(cfg, '../input/mmdetection-new-cfg-training/model_output/epoch_15.pth')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# segms = []\n# files = []\n# for file in sorted(os.listdir('../input/sartorius-cell-instance-segmentation/test')):\n#     img = mmcv.imread('../input/sartorius-cell-instance-segmentation/test/' + file)\n#     #img = unsharp(img)\n# #     plt.imshow(img)\n# #     plt.show()\n# #     img = (unsharp(img)*255)\n# #     plt.imshow(img)\n#     result = inference_detector(model, img)\n#     #print(result[0])\n#     show_result_pyplot(model, img, result)\n#     previous_masks = []\n#     for i, classe in enumerate(result[0]):\n# #         print(classe)\n#         if classe.shape != (0, 5):\n#             bbs = classe\n#             sgs = result[1][i]\n#             for bb, sg in zip(bbs,sgs):\n#                 box = bb[:4]\n#                 cnf = bb[4]\n#                 if cnf >= confidence_thresholds[i]:\n#                     mask = get_mask_from_result(sg)\n#                     mask = remove_overlapping_pixels(mask, previous_masks)\n#                     previous_masks.append(mask)\n\n#     for mk in previous_masks:\n#             rle_mask = rle_encoding(mk)\n#             segms.append(rle_mask)\n#             files.append(str(file.split('.')[0]))","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# indexes = []\n# for i, segm in enumerate(segms):\n#     if segm == '':\n#         indexes.append(i)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# for element in sorted(indexes, reverse = True):\n#     del segms[element]\n#     del files[element]","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# files = pd.Series(files, name='id')\n# preds = pd.Series(segms, name='predicted')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# submission_df = pd.concat([files, preds], axis=1)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# shutil.rmtree('/kaggle/working/mmpycocotools-12.0.3')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# shutil.rmtree('/kaggle/working/mmdetection')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# shutil.rmtree('/kaggle/working/pycocotools-2.0.2')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# shutil.rmtree('/kaggle/working/model_output')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# os.remove('/kaggle/working/labels.txt')","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# submission_df.to_csv('submission.csv', index=False)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# submission_df","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}