nc-severstal10-predictions-9.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2021-04-13T12:42:53.828200Z",
     "iopub.status.busy": "2021-04-13T12:42:53.827588Z",
     "iopub.status.idle": "2021-04-13T12:43:00.121039Z",
     "shell.execute_reply": "2021-04-13T12:43:00.119983Z"
    },
    "papermill": {
     "duration": 6.315677,
     "end_time": "2021-04-13T12:43:00.121241",
     "exception": false,
     "start_time": "2021-04-13T12:42:53.805564",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import gc\n",
    "import cv2\n",
    "import keras\n",
    "from keras import backend as K\n",
    "from keras import layers\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.models import Model, load_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.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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.014141,
     "end_time": "2021-04-13T12:43:00.149873",
     "exception": false,
     "start_time": "2021-04-13T12:43:00.135732",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Read submission samples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:43:00.184821Z",
     "iopub.status.busy": "2021-04-13T12:43:00.184297Z",
     "iopub.status.idle": "2021-04-13T12:43:00.219514Z",
     "shell.execute_reply": "2021-04-13T12:43:00.220118Z"
    },
    "papermill": {
     "duration": 0.056087,
     "end_time": "2021-04-13T12:43:00.220310",
     "exception": false,
     "start_time": "2021-04-13T12:43:00.164223",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5506, 3)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "      <th>EncodedPixels</th>\n",
       "      <th>ClassId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0000f269f.jpg</td>\n",
       "      <td>1 409600</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000ccc2ac.jpg</td>\n",
       "      <td>1 409600</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>002451917.jpg</td>\n",
       "      <td>1 409600</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>003c5da97.jpg</td>\n",
       "      <td>1 409600</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0042e163f.jpg</td>\n",
       "      <td>1 409600</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         ImageId EncodedPixels  ClassId\n",
       "0  0000f269f.jpg      1 409600        0\n",
       "1  000ccc2ac.jpg      1 409600        0\n",
       "2  002451917.jpg      1 409600        0\n",
       "3  003c5da97.jpg      1 409600        0\n",
       "4  0042e163f.jpg      1 409600        0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "submission_df = pd.read_csv('../input/severstal-steel-defect-detection/sample_submission.csv')\n",
    "print(submission_df.shape)\n",
    "submission_df.head()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:43:00.257832Z",
     "iopub.status.busy": "2021-04-13T12:43:00.256954Z",
     "iopub.status.idle": "2021-04-13T12:43:00.266017Z",
     "shell.execute_reply": "2021-04-13T12:43:00.265555Z"
    },
    "papermill": {
     "duration": 0.030305,
     "end_time": "2021-04-13T12:43:00.266137",
     "exception": false,
     "start_time": "2021-04-13T12:43:00.235832",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5506, 1)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0000f269f.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000ccc2ac.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>002451917.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>003c5da97.jpg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0042e163f.jpg</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         ImageId\n",
       "0  0000f269f.jpg\n",
       "1  000ccc2ac.jpg\n",
       "2  002451917.jpg\n",
       "3  003c5da97.jpg\n",
       "4  0042e163f.jpg"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique_test_images = submission_df['ImageId'].unique()\n",
    "len(unique_test_images)\n",
    "test_df = pd.DataFrame(unique_test_images, columns=['ImageId'])\n",
    "print(test_df.shape)\n",
    "test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:43:00.301607Z",
     "iopub.status.busy": "2021-04-13T12:43:00.300842Z",
     "iopub.status.idle": "2021-04-13T12:43:00.303743Z",
     "shell.execute_reply": "2021-04-13T12:43:00.303346Z"
    },
    "papermill": {
     "duration": 0.022111,
     "end_time": "2021-04-13T12:43:00.303856",
     "exception": false,
     "start_time": "2021-04-13T12:43:00.281745",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "TEST_PATH = '../input/severstal-steel-defect-detection/test_images/'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:43:00.339067Z",
     "iopub.status.busy": "2021-04-13T12:43:00.338296Z",
     "iopub.status.idle": "2021-04-13T12:43:00.341242Z",
     "shell.execute_reply": "2021-04-13T12:43:00.340812Z"
    },
    "papermill": {
     "duration": 0.022025,
     "end_time": "2021-04-13T12:43:00.341360",
     "exception": false,
     "start_time": "2021-04-13T12:43:00.319335",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "BATCH_SIZE = 32\n",
    "IMAGE_SIZE = 256"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:43:00.391268Z",
     "iopub.status.busy": "2021-04-13T12:43:00.390627Z",
     "iopub.status.idle": "2021-04-13T12:43:12.952975Z",
     "shell.execute_reply": "2021-04-13T12:43:12.953679Z"
    },
    "papermill": {
     "duration": 12.596021,
     "end_time": "2021-04-13T12:43:12.953848",
     "exception": false,
     "start_time": "2021-04-13T12:43:00.357827",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 5506 validated image filenames.\n"
     ]
    }
   ],
   "source": [
    "submit_test_gen = ImageDataGenerator(rescale=1/255.).flow_from_dataframe(\n",
    "        test_df,\n",
    "        directory='../input/severstal-steel-defect-detection/test_images/',\n",
    "        x_col='ImageId',\n",
    "        class_mode=None,\n",
    "        target_size=(IMAGE_SIZE, IMAGE_SIZE),\n",
    "        batch_size=BATCH_SIZE,\n",
    "        shuffle=False\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.015604,
     "end_time": "2021-04-13T12:43:12.985196",
     "exception": false,
     "start_time": "2021-04-13T12:43:12.969592",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Classification Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:43:13.022852Z",
     "iopub.status.busy": "2021-04-13T12:43:13.022311Z",
     "iopub.status.idle": "2021-04-13T12:44:44.737327Z",
     "shell.execute_reply": "2021-04-13T12:44:44.736606Z"
    },
    "papermill": {
     "duration": 91.736342,
     "end_time": "2021-04-13T12:44:44.737458",
     "exception": false,
     "start_time": "2021-04-13T12:43:13.001116",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predicting...\n",
      "173/173 [==============================] - 81s 440ms/step\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ImageId</th>\n",
       "      <th>defect_label</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0000f269f.jpg</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>000ccc2ac.jpg</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>002451917.jpg</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>003c5da97.jpg</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0042e163f.jpg</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         ImageId  defect_label\n",
       "0  0000f269f.jpg             1\n",
       "1  000ccc2ac.jpg             1\n",
       "2  002451917.jpg             1\n",
       "3  003c5da97.jpg             1\n",
       "4  0042e163f.jpg             1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = load_model('../input/ncseverstal03classificationdensenet/severstal-classification-DenseNet.h5')\n",
    "\n",
    "import math\n",
    "# We take the ceiling because we do not drop the remainder of the batch\n",
    "compute_steps_per_epoch = lambda x: int(math.ceil(1. * x / BATCH_SIZE))\n",
    "\n",
    "STEP_SIZE_TEST = compute_steps_per_epoch(test_df.shape[0])\n",
    "print('predicting...')\n",
    "\n",
    "submit_test = model.predict(\n",
    "    submit_test_gen,\n",
    "    steps=STEP_SIZE_TEST,\n",
    "    verbose=1\n",
    ")\n",
    "\n",
    "test_df['defect_label'] = (submit_test > 0.5).astype(\"int32\")\n",
    "test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:44.864672Z",
     "iopub.status.busy": "2021-04-13T12:44:44.862578Z",
     "iopub.status.idle": "2021-04-13T12:44:44.869968Z",
     "shell.execute_reply": "2021-04-13T12:44:44.869496Z"
    },
    "papermill": {
     "duration": 0.071975,
     "end_time": "2021-04-13T12:44:44.870139",
     "exception": false,
     "start_time": "2021-04-13T12:44:44.798164",
     "status": "completed"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    3430\n",
       "0    2076\n",
       "Name: defect_label, dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df.defect_label.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:44.995514Z",
     "iopub.status.busy": "2021-04-13T12:44:44.994717Z",
     "iopub.status.idle": "2021-04-13T12:44:45.018191Z",
     "shell.execute_reply": "2021-04-13T12:44:45.017722Z"
    },
    "papermill": {
     "duration": 0.087834,
     "end_time": "2021-04-13T12:44:45.018328",
     "exception": false,
     "start_time": "2021-04-13T12:44:44.930494",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3430, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df_defect =  test_df[test_df['defect_label'] == 1].copy()\n",
    "test_df_defect.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:45.144789Z",
     "iopub.status.busy": "2021-04-13T12:44:45.144016Z",
     "iopub.status.idle": "2021-04-13T12:44:45.149416Z",
     "shell.execute_reply": "2021-04-13T12:44:45.148958Z"
    },
    "papermill": {
     "duration": 0.071018,
     "end_time": "2021-04-13T12:44:45.149526",
     "exception": false,
     "start_time": "2021-04-13T12:44:45.078508",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2076, 2)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_df_noDefect =  test_df[test_df['defect_label'] == 0].copy()\n",
    "test_df_noDefect.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.061443,
     "end_time": "2021-04-13T12:44:45.271414",
     "exception": false,
     "start_time": "2021-04-13T12:44:45.209971",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Segmentation Prediction\n",
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:45.403387Z",
     "iopub.status.busy": "2021-04-13T12:44:45.402668Z",
     "iopub.status.idle": "2021-04-13T12:44:45.406575Z",
     "shell.execute_reply": "2021-04-13T12:44:45.406117Z"
    },
    "papermill": {
     "duration": 0.074804,
     "end_time": "2021-04-13T12:44:45.406700",
     "exception": false,
     "start_time": "2021-04-13T12:44:45.331896",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def mask2rle(img):\n",
    "    '''\n",
    "    img: numpy array, 1 - mask, 0 - background\n",
    "    Returns run length as string formated\n",
    "    '''\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",
    "    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",
    "    starts-=1\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_rles(masks):\n",
    "    width, height, depth = masks.shape\n",
    "    \n",
    "    rles = [mask2rle(masks[:, :, i])\n",
    "            for i in range(depth)]\n",
    "    \n",
    "    return rles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:45.549586Z",
     "iopub.status.busy": "2021-04-13T12:44:45.547795Z",
     "iopub.status.idle": "2021-04-13T12:44:45.550230Z",
     "shell.execute_reply": "2021-04-13T12:44:45.550633Z"
    },
    "papermill": {
     "duration": 0.083231,
     "end_time": "2021-04-13T12:44:45.550773",
     "exception": false,
     "start_time": "2021-04-13T12:44:45.467542",
     "status": "completed"
    },
    "tags": []
   },
   "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='../input/severstal-steel-defect-detection/train_images',\n",
    "                 batch_size=32, dim=(256, 1600), n_channels=1,\n",
    "                 n_classes=4, random_state=2021, shuffle=True):\n",
    "        self.dim = dim\n",
    "        self.batch_size = batch_size\n",
    "        self.df = df\n",
    "        self.mode = mode\n",
    "        self.base_path = base_path\n",
    "        self.target_df = target_df\n",
    "        self.list_IDs = list_IDs\n",
    "        self.n_channels = n_channels\n",
    "        self.n_classes = n_classes\n",
    "        self.shuffle = shuffle\n",
    "        self.random_state = random_state\n",
    "        \n",
    "        self.on_epoch_end()\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",
    "            return X, y\n",
    "        \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",
    "        X = np.empty((self.batch_size, *self.dim, 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",
    "            if self.n_channels == 1:\n",
    "                img = self.__load_grayscale(img_path)\n",
    "            else:\n",
    "                img = self.__load_rgb(img_path)\n",
    "            \n",
    "            # Store samples\n",
    "            X[i,] = img\n",
    "\n",
    "        return X\n",
    "    \n",
    "    def __generate_y(self, list_IDs_batch):\n",
    "        y = np.empty((self.batch_size, *self.dim, 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].copy().reset_index()\n",
    "\n",
    "            masks = np.zeros((*self.dim, self.n_classes))\n",
    "            \n",
    "            for j in range(len(image_df)):\n",
    "                rle = image_df.loc[j,'EncodedPixels']\n",
    "                cls =  image_df.loc[j,'ClassId']\n",
    "                masks[:, :, cls-1] = rle2mask(rle, 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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:45.677471Z",
     "iopub.status.busy": "2021-04-13T12:44:45.676692Z",
     "iopub.status.idle": "2021-04-13T12:44:45.680437Z",
     "shell.execute_reply": "2021-04-13T12:44:45.680867Z"
    },
    "papermill": {
     "duration": 0.069867,
     "end_time": "2021-04-13T12:44:45.681043",
     "exception": false,
     "start_time": "2021-04-13T12:44:45.611176",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def dice_coef(y_true, y_pred, smooth=1):\n",
    "    y_true_f = K.flatten(y_true)\n",
    "    y_pred_f = K.flatten(y_pred)\n",
    "    intersection = K.sum(y_true_f * y_pred_f)\n",
    "    return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.062675,
     "end_time": "2021-04-13T12:44:45.812822",
     "exception": false,
     "start_time": "2021-04-13T12:44:45.750147",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Load segmentation saved model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:45.953041Z",
     "iopub.status.busy": "2021-04-13T12:44:45.952035Z",
     "iopub.status.idle": "2021-04-13T12:44:45.954796Z",
     "shell.execute_reply": "2021-04-13T12:44:45.954367Z"
    },
    "papermill": {
     "duration": 0.080152,
     "end_time": "2021-04-13T12:44:45.954922",
     "exception": false,
     "start_time": "2021-04-13T12:44:45.874770",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def load_segmentation_model_and_predict(model_path,submission_file,n_channels):\n",
    "    dependencies = {\n",
    "        'dice_coef': dice_coef\n",
    "    }\n",
    "\n",
    "    model = load_model(model_path, custom_objects=dependencies )\n",
    "    \n",
    "    df = []\n",
    "    step = 300\n",
    "    \n",
    "    #Prediction for the predicted defected images  \n",
    "    for i in range(0, test_df_defect.shape[0], step):\n",
    "        batch_idx = list(\n",
    "            range(i, min(test_df_defect.shape[0], i + step))\n",
    "        )\n",
    "\n",
    "        test_generator = DataGenerator(\n",
    "            batch_idx,\n",
    "            df=test_df_defect,\n",
    "            shuffle=False,\n",
    "            mode='predict',\n",
    "            base_path='../input/severstal-steel-defect-detection/test_images',\n",
    "            target_df=test_df_defect,\n",
    "            batch_size=1,\n",
    "            n_classes=4,\n",
    "            n_channels=n_channels\n",
    "        )\n",
    "\n",
    "        batch_pred_masks = model.predict(\n",
    "            test_generator, \n",
    "            verbose=1,\n",
    "            )\n",
    "\n",
    "        for j, b in tqdm(enumerate(batch_idx)):\n",
    "            filename = test_df_defect['ImageId'].iloc[b]\n",
    "\n",
    "            data = {'ImageId':  [filename, filename, filename, filename],\n",
    "            'ClassId': [1,2,3,4],\n",
    "            'EncodedPixels': ['','','','' ]\n",
    "            }\n",
    "            image_df = pd.DataFrame(data, columns = ['ImageId','ClassId','EncodedPixels'])\n",
    "\n",
    "            pred_masks = batch_pred_masks[j, ].round().astype(int)\n",
    "            pred_rles = build_rles(pred_masks)\n",
    "            for i in range(4):\n",
    "                image_df.loc[i,'EncodedPixels'] = pred_rles[i]\n",
    "\n",
    "            df.append(image_df)\n",
    "\n",
    "        gc.collect()\n",
    "    df = pd.concat(df)\n",
    "        \n",
    "    #Now, we combine results from the predicted masks with the rest of images that our first CNN classified as having all 4 masks missing.\n",
    "\n",
    "    tt = []\n",
    "    for img in test_df_noDefect.index:\n",
    "            image_df = pd.DataFrame(columns = ['ImageId','ClassId','EncodedPixels'])\n",
    "            for i in range(4):\n",
    "                image_df.loc[i,'EncodedPixels'] = np.nan\n",
    "                image_df.loc[i,'ClassId'] = i+1\n",
    "                image_df.loc[i,'ImageId'] = test_df_noDefect.loc[img, \"ImageId\"]            \n",
    "\n",
    "            tt.append(image_df)\n",
    "\n",
    "    tt = pd.concat(tt)\n",
    "\n",
    "    #merge the defected predictions and no-defected \n",
    "    final_submission_df = pd.concat([df, tt])\n",
    "    \n",
    "    final_submission_df[\"EncodedPixels\"] = final_submission_df[\"EncodedPixels\"].apply(lambda x: np.nan if x == '' else x)\n",
    "    final_submission_df[\"ClassId\"] = final_submission_df[\"ClassId\"].astype(str)\n",
    "    final_submission_df['ImageId_ClassId'] = final_submission_df['ImageId']  + \"_\" + final_submission_df[\"ClassId\"]\n",
    "\n",
    "    final_submission_df[['ImageId_ClassId', 'EncodedPixels']].to_csv(submission_file, index=False)\n",
    "    print(\"Model: \", model_path)\n",
    "    print(\"Generated submission file: \", submission_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "papermill": {
     "duration": 0.060942,
     "end_time": "2021-04-13T12:44:46.077031",
     "exception": false,
     "start_time": "2021-04-13T12:44:46.016089",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "# Predictions and Submission file Gerneration for each model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:44:46.228751Z",
     "iopub.status.busy": "2021-04-13T12:44:46.228203Z",
     "iopub.status.idle": "2021-04-13T12:46:54.162715Z",
     "shell.execute_reply": "2021-04-13T12:46:54.163396Z"
    },
    "papermill": {
     "duration": 128.000033,
     "end_time": "2021-04-13T12:46:54.163610",
     "exception": false,
     "start_time": "2021-04-13T12:44:46.163577",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 4s 12ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 63.06it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 71.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 68.17it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 67.61it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 70.06it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 66.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 66.73it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 66.75it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 63.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 65.99it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 65.40it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "130/130 [==============================] - 1s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "130it [00:01, 67.14it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model:  ../input/ncseverstalsegmentationunetdataaugloss/severstal-segmentation_unetDataAugLoss.h5\n",
      "Generated submission file:  submission-ncseverstalsegmentationunetdataaugloss.csv\n"
     ]
    }
   ],
   "source": [
    "model_path = '../input/ncseverstalsegmentationunetdataaugloss/severstal-segmentation_unetDataAugLoss.h5'\n",
    "\n",
    "submission_file = 'submission-ncseverstalsegmentationunetdataaugloss.csv'\n",
    "n_channels = 1\n",
    "load_segmentation_model_and_predict(model_path,submission_file,n_channels)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:46:54.865925Z",
     "iopub.status.busy": "2021-04-13T12:46:54.865349Z",
     "iopub.status.idle": "2021-04-13T12:49:03.764165Z",
     "shell.execute_reply": "2021-04-13T12:49:03.764786Z"
    },
    "papermill": {
     "duration": 129.253098,
     "end_time": "2021-04-13T12:49:03.764991",
     "exception": false,
     "start_time": "2021-04-13T12:46:54.511893",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 63.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 67.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 63.12it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 61.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 65.05it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 64.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 67.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 69.23it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 69.31it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 12ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 68.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 4s 12ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 65.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "130/130 [==============================] - 1s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "130it [00:02, 60.90it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model:  ../input/nc-severstalsegmentationunetdataaugdice/severstal-segmentation_unetDataAugDice.h5\n",
      "Generated submission file:  submission-ncseverstalsegmentationunetdataaugdice.csv\n"
     ]
    }
   ],
   "source": [
    "model_path = '../input/nc-severstalsegmentationunetdataaugdice/severstal-segmentation_unetDataAugDice.h5'\n",
    "submission_file = 'submission-ncseverstalsegmentationunetdataaugdice.csv'\n",
    "n_channels = 1\n",
    "load_segmentation_model_and_predict(model_path,submission_file,n_channels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:49:05.090006Z",
     "iopub.status.busy": "2021-04-13T12:49:05.089213Z",
     "iopub.status.idle": "2021-04-13T12:51:13.728912Z",
     "shell.execute_reply": "2021-04-13T12:51:13.729721Z"
    },
    "papermill": {
     "duration": 129.298643,
     "end_time": "2021-04-13T12:51:13.730003",
     "exception": false,
     "start_time": "2021-04-13T12:49:04.431360",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 64.88it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 66.74it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 62.21it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 60.18it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 68.65it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 70.16it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 4s 12ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 65.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 68.20it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 11ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 70.05it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 4s 13ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 65.09it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 3s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 71.03it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "130/130 [==============================] - 1s 10ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "130it [00:01, 71.58it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model:  ../input/ncseverstal05segmentationunet/severstal-segmentation_UNET.h5\n",
      "Generated submission file:  submission-ncseverstal05segmentationunet.csv\n"
     ]
    }
   ],
   "source": [
    "model_path = '../input/ncseverstal05segmentationunet/severstal-segmentation_UNET.h5'\n",
    "submission_file = 'submission-ncseverstal05segmentationunet.csv'\n",
    "n_channels = 1\n",
    "load_segmentation_model_and_predict(model_path,submission_file,n_channels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:51:15.624753Z",
     "iopub.status.busy": "2021-04-13T12:51:15.624234Z",
     "iopub.status.idle": "2021-04-13T12:56:07.725519Z",
     "shell.execute_reply": "2021-04-13T12:56:07.724885Z"
    },
    "papermill": {
     "duration": 293.027765,
     "end_time": "2021-04-13T12:56:07.725660",
     "exception": false,
     "start_time": "2021-04-13T12:51:14.697895",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 19s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:05, 58.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 68.81it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 57ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 71.07it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 70.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 69.51it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 57ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 69.66it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 57ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 67.92it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:05, 54.63it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 70.53it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 57ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 70.67it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 17s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 69.64it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "130/130 [==============================] - 7s 56ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "130it [00:01, 68.82it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model:  ../input/ncseverstal06segmentationunetxception/severstal-segmentation_UnetXception.h5\n",
      "Generated submission file:  submission-ncseverstal06segmentationunetxception.csv\n"
     ]
    }
   ],
   "source": [
    "model_path = '../input/ncseverstal06segmentationunetxception/severstal-segmentation_UnetXception.h5'\n",
    "submission_file = 'submission-ncseverstal06segmentationunetxception.csv'\n",
    "n_channels = 3\n",
    "load_segmentation_model_and_predict(model_path,submission_file,n_channels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:56:11.691611Z",
     "iopub.status.busy": "2021-04-13T12:56:11.691076Z",
     "iopub.status.idle": "2021-04-13T12:58:43.648760Z",
     "shell.execute_reply": "2021-04-13T12:58:43.649353Z"
    },
    "papermill": {
     "duration": 154.064869,
     "end_time": "2021-04-13T12:58:43.649560",
     "exception": false,
     "start_time": "2021-04-13T12:56:09.584691",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 16ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 64.80it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 16ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 66.61it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 17ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 66.10it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 16ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 66.13it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 17ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 62.13it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 18ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 68.49it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 17ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 64.71it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 16ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 63.24it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 17ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 65.84it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 16ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:04, 60.41it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300/300 [==============================] - 5s 16ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "300it [00:05, 57.38it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "130/130 [==============================] - 2s 18ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "130it [00:01, 65.35it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model:  ../input/ncseverstal07segmentationunetbn/severstal-segmentation_unetBN.h5\n",
      "Generated submission file:  submission-ncseverstal07segmentationunetbn.csv\n"
     ]
    }
   ],
   "source": [
    "model_path = '../input/ncseverstal07segmentationunetbn/severstal-segmentation_unetBN.h5'\n",
    "submission_file = 'submission-ncseverstal07segmentationunetbn.csv'\n",
    "n_channels = 1\n",
    "load_segmentation_model_and_predict(model_path,submission_file,n_channels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-04-13T12:58:48.965350Z",
     "iopub.status.busy": "2021-04-13T12:58:48.964471Z",
     "iopub.status.idle": "2021-04-13T12:58:48.967381Z",
     "shell.execute_reply": "2021-04-13T12:58:48.967844Z"
    },
    "papermill": {
     "duration": 2.401623,
     "end_time": "2021-04-13T12:58:48.968034",
     "exception": false,
     "start_time": "2021-04-13T12:58:46.566411",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nimport pandas as pd\\n\\ns = pd.read_csv('../input/csvfiles/submission.csv')\\n\\ns.to_csv('submission.csv',index=False)\\ns.head()\\n\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a sepertate file to submit the result. \n",
    "'''\n",
    "import pandas as pd\n",
    "\n",
    "s = pd.read_csv('../input/csvfiles/submission.csv')\n",
    "\n",
    "s.to_csv('submission.csv',index=False)\n",
    "s.head()\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "papermill": {
     "duration": 2.218274,
     "end_time": "2021-04-13T12:58:53.431964",
     "exception": false,
     "start_time": "2021-04-13T12:58:51.213690",
     "status": "completed"
    },
    "tags": []
   },
   "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.8.0"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 970.752376,
   "end_time": "2021-04-13T12:58:59.373288",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2021-04-13T12:42:48.620912",
   "version": "2.2.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}