cloud-unet-inference-kernel.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install segmentation-models --quiet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n",
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/opt/conda/lib/python3.6/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Segmentation Models: using `keras` framework.\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import json\n",
    "import seaborn as sns\n",
    "from tqdm import tqdm_notebook\n",
    "import albumentations as albu\n",
    "import os\n",
    "import keras\n",
    "from keras import backend as K\n",
    "from keras.models import Model\n",
    "from keras.layers import Input\n",
    "from keras.layers.convolutional import Conv2D, Conv2DTranspose\n",
    "from keras.layers.pooling import MaxPooling2D\n",
    "from keras.layers.merge import concatenate\n",
    "from keras.losses import binary_crossentropy\n",
    "from keras.optimizers import Adam\n",
    "from keras.callbacks import Callback, ModelCheckpoint\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from sklearn.model_selection import train_test_split\n",
    "import segmentation_models as sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
   },
   "outputs": [],
   "source": [
    "import pdb\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = '../input/understanding_cloud_organization/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DataGenerator(keras.utils.Sequence):\n",
    "    'Generates data for Keras'\n",
    "    def __init__(self, list_IDs, df, target_df=None, mode='fit',\n",
    "                 base_path=f'{data_dir}train_images',\n",
    "                 batch_size=32, dim=(1400, 2100), n_channels=3, reshape=None,\n",
    "                 augment=False, n_classes=4, random_state=42, shuffle=True,threshold = 0.5, min_mask = 3500):\n",
    "        self.dim = dim\n",
    "        self.batch_size = batch_size\n",
    "        self.df = df\n",
    "        self.pp = False\n",
    "        # if mode == 'mask_pred':\n",
    "        # self.pp = True\n",
    "        self.mode = mode\n",
    "        self.base_path = base_path\n",
    "        self.target_df = target_df\n",
    "        self.list_IDs = list_IDs\n",
    "        self.reshape = reshape\n",
    "        self.n_channels = n_channels\n",
    "        self.augment = augment\n",
    "        self.n_classes = n_classes\n",
    "        self.shuffle = shuffle\n",
    "        self.random_state = random_state\n",
    "        self.threshold = threshold\n",
    "        self.min_mask = min_mask\n",
    "        \n",
    "        self.on_epoch_end()\n",
    "        np.random.seed(self.random_state)\n",
    "\n",
    "    def __len__(self):\n",
    "        'Denotes the number of batches per epoch'\n",
    "        return int(np.floor(len(self.list_IDs) / self.batch_size))\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        # Generate indexes of the batch\n",
    "        indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]\n",
    "\n",
    "        # Find list of IDs\n",
    "        list_IDs_batch = [self.list_IDs[k] for k in indexes]\n",
    "        \n",
    "        X = self.__generate_X(list_IDs_batch)\n",
    "        \n",
    "        if self.mode == 'fit':\n",
    "            y = self.__generate_y(list_IDs_batch)\n",
    "            \n",
    "            if self.augment:\n",
    "                X, y = self.__augment_batch(X, y)\n",
    "            \n",
    "            return X, y\n",
    "        elif self.mode == 'mask':\n",
    "            return self.__generate_y(list_IDs_batch)\n",
    "        elif self.mode == 'mask_pred':\n",
    "            return X, self.__generate_y(list_IDs_batch)\n",
    "        elif self.mode == 'predict':\n",
    "            return X\n",
    "\n",
    "        else:\n",
    "            raise AttributeError('The mode parameter should be set to \"fit\" or \"predict\".')\n",
    "        \n",
    "    def on_epoch_end(self):\n",
    "        'Updates indexes after each epoch'\n",
    "        self.indexes = np.arange(len(self.list_IDs))\n",
    "        if self.shuffle == True:\n",
    "            np.random.seed(self.random_state)\n",
    "            np.random.shuffle(self.indexes)\n",
    "    \n",
    "    def __generate_X(self, list_IDs_batch):\n",
    "        'Generates data containing batch_size samples'\n",
    "        # Initialization\n",
    "        if self.reshape is None:\n",
    "            X = np.empty((self.batch_size, *self.dim, self.n_channels))\n",
    "        else:\n",
    "            X = np.empty((self.batch_size, *self.reshape, self.n_channels))\n",
    "        \n",
    "        # Generate data\n",
    "        for i, ID in enumerate(list_IDs_batch):\n",
    "            im_name = self.df['ImageId'].iloc[ID]\n",
    "            img_path = f\"{self.base_path}/{im_name}\"\n",
    "            img = self.__load_rgb(img_path)\n",
    "            \n",
    "            if self.reshape is not None:\n",
    "                img = np_resize(img, self.reshape)\n",
    "            \n",
    "            # Store samples\n",
    "            X[i,] = img\n",
    "\n",
    "        return X\n",
    "    \n",
    "    def __generate_y(self, list_IDs_batch):\n",
    "        if self.reshape is None:\n",
    "            y = np.empty((self.batch_size, *self.dim, self.n_classes), dtype=int)\n",
    "        else:\n",
    "            y = np.empty((self.batch_size, *self.reshape, self.n_classes), dtype=int)\n",
    "        \n",
    "        for i, ID in enumerate(list_IDs_batch):\n",
    "            im_name = self.df['ImageId'].iloc[ID]\n",
    "            image_df = self.target_df[self.target_df['ImageId'] == im_name]\n",
    "            \n",
    "            rles = image_df['EncodedPixels'].values\n",
    "            \n",
    "            if self.reshape is not None:\n",
    "                masks = build_masks(rles, input_shape=self.dim, reshape=self.reshape)\n",
    "            else:\n",
    "                masks = build_masks(rles, input_shape=self.dim)\n",
    "            \n",
    "            y[i, ] = masks\n",
    "\n",
    "        return y\n",
    "    \n",
    "    def __load_grayscale(self, img_path):\n",
    "        img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)\n",
    "        img = img.astype(np.float32) / 255.\n",
    "        img = np.expand_dims(img, axis=-1)\n",
    "\n",
    "        return img\n",
    "    \n",
    "    def __load_rgb(self, img_path):\n",
    "        img = cv2.imread(img_path)\n",
    "        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n",
    "        img = img.astype(np.float32) / 255.\n",
    "\n",
    "        return img\n",
    "    \n",
    "    def __random_transform(self, img, masks):\n",
    "        composition = albu.Compose([\n",
    "            albu.HorizontalFlip(),\n",
    "            albu.VerticalFlip(),\n",
    "            albu.ShiftScaleRotate(rotate_limit=30, shift_limit=0.1)\n",
    "        ])\n",
    "        \n",
    "        composed = composition(image=img, mask=masks)\n",
    "        aug_img = composed['image']\n",
    "        aug_masks = composed['mask']\n",
    "        \n",
    "        return aug_img, aug_masks\n",
    "    \n",
    "    def __augment_batch(self, img_batch, masks_batch):\n",
    "        for i in range(img_batch.shape[0]):\n",
    "            img_batch[i, ], masks_batch[i, ] = self.__random_transform(\n",
    "                img_batch[i, ], masks_batch[i, ])\n",
    "        \n",
    "        return img_batch, masks_batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df = pd.read_csv(f'{data_dir}train.csv')\n",
    "train_df['ImageId'] = train_df['Image_Label'].apply(lambda x: x.split('_')[0])\n",
    "train_df['ClassId'] = train_df['Image_Label'].apply(lambda x: x.split('_')[1])\n",
    "train_df['hasMask'] = ~ train_df['EncodedPixels'].isna()\n",
    "mask_count_df = train_df.groupby('ImageId').agg(np.sum).reset_index()\n",
    "mask_count_df.sort_values('hasMask', ascending=False, inplace=True)\n",
    "_, val_idx = train_test_split(mask_count_df.index, test_size=0.2, random_state=42)\n",
    "\n",
    "def createVal(val_idx):\n",
    "    val_generator = DataGenerator(\n",
    "        val_idx, \n",
    "        df=mask_count_df,\n",
    "        target_df=train_df,\n",
    "        batch_size=16, \n",
    "        shuffle=False,\n",
    "        reshape=(320, 480),\n",
    "        mode='mask_pred',\n",
    "        augment=False,\n",
    "        n_channels=3,\n",
    "        n_classes=4,\n",
    "    )\n",
    "\n",
    "    return val_generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def post_process(probability, threshold, min_size):\n",
    "\n",
    "    '''Post processing of each predicted mask, components with lesser number of pixels\n",
    "    than `min_size` are ignored'''\n",
    "    mask = cv2.threshold(probability, threshold, 1, cv2.THRESH_BINARY)[1]\n",
    "    predictions = np.zeros(probability.shape, np.float32)\n",
    "    num_component, component = cv2.connectedComponents(mask.astype(np.uint8))\n",
    "\n",
    "    for c in range(1, num_component):\n",
    "        p = (component == c)\n",
    "        if p.sum() > min_size:\n",
    "            predictions[p] = 1\n",
    "\n",
    "    return predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def np_resize(img, input_shape):\n",
    "    \"\"\"\n",
    "    Reshape a numpy array, which is input_shape=(height, width), \n",
    "    as opposed to input_shape=(width, height) for cv2\n",
    "    \"\"\"\n",
    "    height, width = input_shape\n",
    "    return cv2.resize(img, (width, height))\n",
    "    \n",
    "def mask2rle(img, best_threshold, min_size):\n",
    "    '''\n",
    "    img: numpy array, 1 - mask, 0 - background\n",
    "    Returns run length as string formated\n",
    "    '''\n",
    "    img = post_process(img, best_threshold, min_size)\n",
    "    #print(f'{t[1]} masks removed')\n",
    "    pixels= img.T.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",
    "def rle2mask(rle, input_shape):\n",
    "    \n",
    "    \n",
    "    width, height = input_shape[:2]\n",
    "    \n",
    "    mask= np.zeros( width*height ).astype(np.uint8)\n",
    "    \n",
    "    array = np.asarray([int(x) for x in rle.split()])\n",
    "    starts = array[0::2]\n",
    "    lengths = array[1::2]\n",
    "\n",
    "    current_position = 0\n",
    "    for index, start in enumerate(starts):\n",
    "        mask[int(start):int(start+lengths[index])] = 1\n",
    "        current_position += lengths[index]\n",
    "\n",
    "    return mask.reshape(height, width).T\n",
    "\n",
    "def build_masks(rles, input_shape, reshape=None):\n",
    "    depth = len(rles)\n",
    "    if reshape is None:\n",
    "        masks = np.zeros((*input_shape, depth))\n",
    "    else:\n",
    "        masks = np.zeros((*reshape, depth))\n",
    "    \n",
    "    for i, rle in enumerate(rles):\n",
    "        if type(rle) is str:\n",
    "            if reshape is None:\n",
    "                masks[:, :, i] = rle2mask(rle, input_shape)\n",
    "            else:\n",
    "                mask = rle2mask(rle, input_shape)\n",
    "                reshaped_mask = np_resize(mask, reshape)\n",
    "               # if pp == True:\n",
    "               #     reshaped_mask = post_process(reshaped_mask, threshold, min_size)\n",
    "                masks[:, :, i] = reshaped_mask\n",
    "    \n",
    "    return masks\n",
    "\n",
    "def build_rles(masks, threshold, size, reshape=None):\n",
    "    width, height, depth = masks.shape\n",
    "    \n",
    "    rles = []\n",
    "    \n",
    "    for i in range(depth):\n",
    "        mask = masks[:, :, i]\n",
    "        \n",
    "        if reshape:\n",
    "            mask = mask.astype(np.float32)\n",
    "            mask = np_resize(mask, reshape).astype(np.float32)\n",
    "        rle = mask2rle(mask, threshold, size)\n",
    "        rles.append(rle)\n",
    "        \n",
    "    return rles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dice(img1, img2):\n",
    "    img1 = np.asarray(img1).astype(np.bool)\n",
    "    img2 = np.asarray(img2).astype(np.bool)\n",
    "\n",
    "    intersection = np.logical_and(img1, img2)\n",
    "\n",
    "    return ((2. * intersection.sum())+1) / (img1.sum() + img2.sum() + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://github.com/qubvel/classification_models/releases/download/0.0.1/resnet34_imagenet_1000_no_top.h5\n",
      "85524480/85521592 [==============================] - 3s 0us/step\n"
     ]
    }
   ],
   "source": [
    "# Initialize mode and load trained weights\n",
    "\n",
    "model = sm.Unet(\"resnet34\",  \n",
    "                classes=4,\n",
    "                input_shape=(320, 480, 3),\n",
    "                activation='sigmoid')\n",
    "\n",
    "model.load_weights('../input/resuweight/res32_unet_unfreeze.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4e0575c0f4ec4a89a6c769a825e23823",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=69), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "val_generator = createVal(val_idx)\n",
    "thresholds = np.arange(0.3, 0.8, 0.025)\n",
    "min_masks = [10000, 11000, 12000,13000,14000, 15000, 16000, 17000, 18000, 20000]\n",
    "\n",
    "all_dices = [(thres, mask, 0) for thres in thresholds for mask in min_masks]\n",
    "\n",
    "\n",
    "for batch in tqdm_notebook(range(len(val_generator))):\n",
    "    X,y = val_generator.__getitem__(batch)\n",
    "    y_pred = model.predict(X)\n",
    "    for thres_idx,threshold in enumerate(thresholds):\n",
    "        for mask_idx, min_mask in enumerate(min_masks):\n",
    "            for i in range(y_pred.shape[0]):\n",
    "                for label in range(y_pred.shape[-1]):\n",
    "                    tmp =  post_process(y_pred[i, :,:, label], threshold, min_mask)\n",
    "                    score = dice(tmp, y[i,:,:,label])\n",
    "                    idx = (thres_idx*len(min_masks))+mask_idx\n",
    "                    all_dices[idx] = (threshold, min_mask, all_dices[idx][-1]+score)\n",
    "                    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dices_df = pd.DataFrame(all_dices, columns=['threshold', 'size', 'dice'])\n",
    "dices_df.sort_values('dice', ascending=False, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.lineplot(x='threshold', y='dice', hue='size', data=dices_df);\n",
    "plt.title('Threshold and min size vs dice');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_threshold = dices_df['threshold'].values[0]\n",
    "best_size = dices_df['size'].values[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.47500000000000014, 15000\n"
     ]
    }
   ],
   "source": [
    "print(f\"{best_threshold}, {best_size}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_submission_path = f'{data_dir}sample_submission.csv'\n",
    "test_data_folder = f\"{data_dir}test_images/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sub_df= pd.read_csv(f'{data_dir}sample_submission.csv')\n",
    "sub_df['ImageId'] = sub_df['Image_Label'].apply(lambda x: x.split('_')[0])\n",
    "test_imgs = pd.DataFrame(sub_df['ImageId'].unique(), columns=['ImageId'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_dir = f'{data_dir}test_images'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b8e2e6a10a154c09be98620de8e3f712",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=8), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500/500 [==============================] - 35s 69ms/step\n",
      "500/500 [==============================] - 35s 71ms/step\n",
      "500/500 [==============================] - 35s 69ms/step\n",
      "500/500 [==============================] - 34s 68ms/step\n",
      "500/500 [==============================] - 35s 69ms/step\n",
      "500/500 [==============================] - 35s 69ms/step\n",
      "500/500 [==============================] - 34s 68ms/step\n",
      "198/198 [==============================] - 14s 71ms/step\n",
      "\n"
     ]
    }
   ],
   "source": [
    "test_df = []\n",
    "\n",
    "for i in tqdm_notebook(range(0, test_imgs.shape[0], 500)):\n",
    "    batch_idx = list(\n",
    "        range(i, min(test_imgs.shape[0], i + 500))\n",
    "    )\n",
    "\n",
    "    test_generator = DataGenerator(\n",
    "        batch_idx,\n",
    "        df=test_imgs,\n",
    "        shuffle=False,\n",
    "        mode='predict',\n",
    "        dim=(350, 525),\n",
    "        reshape=(320, 480),\n",
    "        n_channels=3,\n",
    "        base_path=f'{data_dir}test_images',\n",
    "        target_df=sub_df,\n",
    "        batch_size=1,\n",
    "        n_classes=4\n",
    "    )\n",
    "\n",
    "    batch_pred_masks = model.predict_generator(\n",
    "        test_generator, \n",
    "        workers=1,\n",
    "        verbose=1\n",
    "    )\n",
    "\n",
    "    for j, b in enumerate(batch_idx):\n",
    "        filename = test_imgs['ImageId'].iloc[b]\n",
    "        image_df = sub_df[sub_df['ImageId'] == filename].copy()\n",
    "\n",
    "        pred_masks = batch_pred_masks[j, ].astype(float)\n",
    "#        for i in batch_pred_masks:\n",
    "#            dice()\n",
    "        pred_rles = build_rles(pred_masks, 0.5 , 15000,reshape=(350, 525))\n",
    "\n",
    "        image_df['EncodedPixels'] = pred_rles\n",
    "        test_df.append(image_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "test_df = pd.concat(test_df)\n",
    "test_df.drop(columns='ImageId', inplace=True)\n",
    "test_df.to_csv('maskrem-unet.csv', index=False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Refrences:\n",
    "\n",
    "\n",
    "* https://www.kaggle.com/amanooo/defect-detection-starter-u-net\n",
    "* https://www.kaggle.com/go1dfish/clear-mask-visualization-and-simple-eda\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "1ec298a3ef53457abb5b100faaae99cf": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "3be0297e4b9d45ceacf706fa9c0ba6bf": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "3caadbaacebc4b269ca6f0d050fe3106": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_74365fe224264a1aa809251f8b09981a",
       "placeholder": "​",
       "style": "IPY_MODEL_1ec298a3ef53457abb5b100faaae99cf",
       "value": "100% 8/8 [05:10&lt;00:00, 34.40s/it]"
      }
     },
     "4900f1baeec14e8baaf8ba6fbea7759d": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "4dc92e169c50439a8f5a859daefda16e": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "4e0575c0f4ec4a89a6c769a825e23823": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_b82287b6103d4163b66a65eb92cae5ce",
        "IPY_MODEL_5be2731de4f94af8b1e74cfb8b1f050c"
       ],
       "layout": "IPY_MODEL_98ff8d3a69e24e46949b6c3186c5c57a"
      }
     },
     "5be2731de4f94af8b1e74cfb8b1f050c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_4900f1baeec14e8baaf8ba6fbea7759d",
       "placeholder": "​",
       "style": "IPY_MODEL_da6ab6193d684e2c99c33e6e16e540ca",
       "value": "100% 69/69 [31:19&lt;00:00, 27.21s/it]"
      }
     },
     "74365fe224264a1aa809251f8b09981a": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "7c6900de06454ccaa63c26aefdd9ed95": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "8fc1b5ac23e640ed969130415886988b": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "IntProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "IntProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_9688ca8ee9884e6bb5a8729878b6e493",
       "max": 8,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_b27b4826970a484fa790c1d468707c4e",
       "value": 8
      }
     },
     "9688ca8ee9884e6bb5a8729878b6e493": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "98ff8d3a69e24e46949b6c3186c5c57a": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "b27b4826970a484fa790c1d468707c4e": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     },
     "b82287b6103d4163b66a65eb92cae5ce": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "IntProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "IntProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_4dc92e169c50439a8f5a859daefda16e",
       "max": 69,
       "min": 0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_3be0297e4b9d45ceacf706fa9c0ba6bf",
       "value": 69
      }
     },
     "b8e2e6a10a154c09be98620de8e3f712": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_8fc1b5ac23e640ed969130415886988b",
        "IPY_MODEL_3caadbaacebc4b269ca6f0d050fe3106"
       ],
       "layout": "IPY_MODEL_7c6900de06454ccaa63c26aefdd9ed95"
      }
     },
     "da6ab6193d684e2c99c33e6e16e540ca": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}