├── Carvana Image Masking (U-Net) └── model_cnn.ipynb ├── README.md ├── RSNA Pneumonia Detection (TF with Mask R-CNN) └── TransferLearning_MaskRCNN.ipynb └── Webcam_Segmentation (DeepLab-V3+) ├── .ipynb_checkpoints └── Webcam_Segmentation-checkpoint.ipynb └── Webcam_Segmentation.ipynb /Carvana Image Masking (U-Net)/model_cnn.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Carvana Image Masking Challenge" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Code for the solution in Kaggle's Carvana Image Masking Challenge on car segmentation (https://www.kaggle.com/c/carvana-image-masking-challenge).\n", 15 | "\n", 16 | "We used U-Net to segment a car in the image. This Blogpost explaining the solution: https://www.novatec-gmbh.de/blog/semantic-segmentation-part-2-training-u-net/" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## Requirements" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "To train the final model we used the following hardware and software:\n", 31 | "\n", 32 | "- OS: Ubuntu 18.04 Server\n", 33 | "- Hardware: CPU Intel Core i7-7700k 64 Gb Ram\n", 34 | "- Required hardware: Any decent modern computer with x86-64 CPU, minimum 32 GB RAM\n", 35 | "- Powerful GPU\n", 36 | "\n", 37 | "Main software for training neural networks:\n", 38 | "- Python 3.5\n", 39 | "- CUDA \n", 40 | "- Tensorflow-GPU and Tensorflow, Keras\n", 41 | "\n", 42 | "Data:\n", 43 | "\n", 44 | "Generate the required data paths in '\\data' and put in the datasets you downloaded on the Kaggle website.\n", 45 | "\n" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "# Load Libraries\n" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [ 61 | "import os\n", 62 | "import time\n", 63 | "import h5py\n", 64 | "import math\n", 65 | "import pickle\n", 66 | "import numpy as np\n", 67 | "import pandas as pd\n", 68 | "import cv2\n", 69 | "import threading\n", 70 | "import queue\n", 71 | "import matplotlib.pyplot as plt\n", 72 | "import seaborn as sns\n", 73 | "from scipy import misc, ndimage\n", 74 | "from sklearn import model_selection, preprocessing, metrics\n", 75 | "from sklearn.utils import shuffle\n", 76 | "from skimage import transform\n", 77 | "from tqdm import tqdm\n", 78 | "from keras.regularizers import l2\n", 79 | "from keras.models import Model, load_model\n", 80 | "from keras.layers import *\n", 81 | "from keras.optimizers import *\n", 82 | "from keras.callbacks import EarlyStopping, ModelCheckpoint, TensorBoard\n", 83 | "from keras import backend as K\n", 84 | "from keras.losses import binary_crossentropy\n", 85 | "import keras.backend.tensorflow_backend as KTF\n", 86 | "import tensorflow as tf\n", 87 | "from tensorflow.python.client import device_lib\n", 88 | "\n", 89 | "%matplotlib inline" 90 | ] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "# Check GPU usage" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "from tensorflow.python.client import device_lib\n", 106 | "print(device_lib.list_local_devices())" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "# Define data paths" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [ 122 | "DATA_PATH = 'data'\n", 123 | "TRAIN_PATH = os.path.join(DATA_PATH, 'train')\n", 124 | "TEST_PATH = os.path.join(DATA_PATH, 'test')\n", 125 | "TRAIN_MASKS_PATH = os.path.join(DATA_PATH, 'train_masks')\n", 126 | "TRAIN_MASKS_CSV_PATH = os.path.join(DATA_PATH, 'train_masks.csv')\n", 127 | "SAMPLE_SUBMISSION_PATH = os.path.join(DATA_PATH, 'sample_submission.csv')\n", 128 | "METADATA_PATH = os.path.join(DATA_PATH, 'metadata.csv')\n", 129 | "SUBMISSION_PATH = os.path.join(DATA_PATH, 'submissions')\n", 130 | "MODELS_PATH = os.path.join(DATA_PATH, 'models')\n", 131 | "TENSORBOARD_PATH = os.path.join(DATA_PATH, 'tensorboard')" 132 | ] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "# Mask shape" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [ 147 | "train_masks_df = pd.read_csv(TRAIN_MASKS_CSV_PATH)\n", 148 | "print('train_masks_df.shape', train_masks_df.shape)\n", 149 | "train_masks_df.head()" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "# Define methods and constants" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "# Constants\n", 166 | "HEIGHT_ORIG = 1280\n", 167 | "WIDTH_ORIG = 1918\n", 168 | "CHANNELS_ORIG = 3\n", 169 | "\n", 170 | "HEIGHT = 1024\n", 171 | "WIDTH = 1024\n", 172 | "CHANNELS = 3\n", 173 | "new_shape = (HEIGHT, WIDTH, CHANNELS)\n", 174 | "mask_shape = (new_shape[0], new_shape[1], 1)\n", 175 | "\n", 176 | "def get_img_id(img_path):\n", 177 | " return img_path[:15]\n", 178 | "\n", 179 | "img_ids = list(map(get_img_id, list(train_masks_df.img.values)))\n", 180 | "\n", 181 | "def load_image_disk(img_id, folder=TRAIN_PATH):\n", 182 | " img = misc.imread(os.path.join(folder, img_id + \".jpg\"))\n", 183 | " return img\n", 184 | "\n", 185 | "def get_image(img_id):\n", 186 | " return train_imgs[img_id]\n", 187 | "\n", 188 | "# Return mask as 1/0 binary img with single channel\n", 189 | "def load_mask_disk(img_id, folder=TRAIN_MASKS_PATH, filetype='gif'):\n", 190 | " mask = misc.imread(os.path.join(folder, \"{}_mask.{}\".format(img_id, filetype)), flatten=True)\n", 191 | " mask[mask > 128] = 1\n", 192 | " if len(mask.shape) == 2:\n", 193 | " mask = mask.reshape(mask.shape[0], mask.shape[1], 1)\n", 194 | " return mask\n", 195 | "\n", 196 | "def get_mask(img_id):\n", 197 | " return train_masks[img_id]\n", 198 | "\n", 199 | "# Helper functions to plot car, mask, masked_car\n", 200 | "def plot_image(img_id):\n", 201 | " img = misc.imread(os.path.join(TRAIN_PATH, img_id + \".jpg\"))\n", 202 | " imgplot = plt.imshow(img)\n", 203 | " plt.axis('off')\n", 204 | " plt.show()\n", 205 | " \n", 206 | "def plot_mask(img_id, folder=TRAIN_MASKS_PATH, filetype='gif', ax=None):\n", 207 | " mask = misc.imread(os.path.join(folder, \"{}_mask.{}\".format(img_id, filetype)))\n", 208 | " if ax == None:\n", 209 | " imgplot = plt.imshow(mask)\n", 210 | " plt.axis('off')\n", 211 | " plt.show()\n", 212 | " else:\n", 213 | " ax.imshow(mask)\n", 214 | " ax.axis('off')\n", 215 | " \n", 216 | "def plot_masked_image(img_id, ax=None):\n", 217 | " img = misc.imread(os.path.join(TRAIN_PATH, img_id + \".jpg\"))\n", 218 | " mask = misc.imread(os.path.join(TRAIN_MASKS_PATH, img_id + \"_mask.gif\"))\n", 219 | " mask = mask[:,:,0:3]\n", 220 | " mask[mask == 255] = 1 \n", 221 | " masked_img = img * mask\n", 222 | " if ax == None:\n", 223 | " imgplot = plt.imshow(masked_img)\n", 224 | " plt.axis('off')\n", 225 | " plt.show()\n", 226 | " else:\n", 227 | " ax.imshow(masked_img)\n", 228 | " ax.axis('off')\n", 229 | "\n", 230 | "def gray2rgb(img):\n", 231 | " img = np.squeeze(img)\n", 232 | " w, h = img.shape\n", 233 | " ret = np.empty((w, h, 3), dtype=np.uint8)\n", 234 | " ret[:, :, 0] = img\n", 235 | " ret[:, :, 1] = img\n", 236 | " ret[:, :, 2] = img\n", 237 | " return ret\n", 238 | "\n", 239 | "def resize_img(img, new_s = new_shape):\n", 240 | " return transform.resize(img, new_s)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "markdown", 245 | "metadata": {}, 246 | "source": [ 247 | "# Read images and masks into memory" 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": null, 253 | "metadata": {}, 254 | "outputs": [], 255 | "source": [ 256 | "# Read training images into memory\n", 257 | "train_imgs = {}\n", 258 | "for img_path in tqdm(os.listdir(TRAIN_PATH)):\n", 259 | " img_id = get_img_id(img_path)\n", 260 | " train_imgs[img_id] = cv2.resize(load_image_disk(img_id), (new_shape[0], new_shape[1]))" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": null, 266 | "metadata": {}, 267 | "outputs": [], 268 | "source": [ 269 | "# Read training masks into memory\n", 270 | "train_masks = {}\n", 271 | "for img_path in tqdm(os.listdir(TRAIN_MASKS_PATH)):\n", 272 | " img_id = get_img_id(img_path)\n", 273 | " train_masks[img_id] = np.expand_dims(cv2.resize(load_mask_disk(img_id), (new_shape[0], new_shape[1])), axis=2)" 274 | ] 275 | }, 276 | { 277 | "cell_type": "markdown", 278 | "metadata": {}, 279 | "source": [ 280 | "# Define Data Augmentation methods" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": null, 286 | "metadata": {}, 287 | "outputs": [], 288 | "source": [ 289 | "def randomHueSaturationValue(image, hue_shift_limit=(-180, 180),\n", 290 | " sat_shift_limit=(-255, 255),\n", 291 | " val_shift_limit=(-255, 255), u=0.5):\n", 292 | " if np.random.random() < u:\n", 293 | " image = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)\n", 294 | " h, s, v = cv2.split(image)\n", 295 | " hue_shift = np.random.uniform(hue_shift_limit[0], hue_shift_limit[1])\n", 296 | " h = cv2.add(h, hue_shift)\n", 297 | " sat_shift = np.random.uniform(sat_shift_limit[0], sat_shift_limit[1])\n", 298 | " s = cv2.add(s, sat_shift)\n", 299 | " val_shift = np.random.uniform(val_shift_limit[0], val_shift_limit[1])\n", 300 | " v = cv2.add(v, val_shift)\n", 301 | " image = cv2.merge((h, s, v))\n", 302 | " image = cv2.cvtColor(image, cv2.COLOR_HSV2RGB)\n", 303 | " return image\n", 304 | "\n", 305 | "def randomShiftScaleRotate(image, mask,\n", 306 | " shift_limit=(-0.0625, 0.0625),\n", 307 | " scale_limit=(-0.1, 0.1),\n", 308 | " rotate_limit=(-45, 45), aspect_limit=(0, 0),\n", 309 | " borderMode=cv2.BORDER_REFLECT_101, u=0.5):\n", 310 | " if np.random.random() < u:\n", 311 | " height, width, channel = image.shape\n", 312 | "\n", 313 | " angle = np.random.uniform(rotate_limit[0], rotate_limit[1]) # degree\n", 314 | " scale = np.random.uniform(1 + scale_limit[0], 1 + scale_limit[1])\n", 315 | " aspect = np.random.uniform(1 + aspect_limit[0], 1 + aspect_limit[1])\n", 316 | " sx = scale * aspect / (aspect ** 0.5)\n", 317 | " sy = scale / (aspect ** 0.5)\n", 318 | " dx = round(np.random.uniform(shift_limit[0], shift_limit[1]) * width)\n", 319 | " dy = round(np.random.uniform(shift_limit[0], shift_limit[1]) * height)\n", 320 | "\n", 321 | " cc = np.math.cos(angle / 180 * np.math.pi) * sx\n", 322 | " ss = np.math.sin(angle / 180 * np.math.pi) * sy\n", 323 | " rotate_matrix = np.array([[cc, -ss], [ss, cc]])\n", 324 | "\n", 325 | " box0 = np.array([[0, 0], [width, 0], [width, height], [0, height], ])\n", 326 | " box1 = box0 - np.array([width / 2, height / 2])\n", 327 | " box1 = np.dot(box1, rotate_matrix.T) + np.array([width / 2 + dx, height / 2 + dy])\n", 328 | "\n", 329 | " box0 = box0.astype(np.float32)\n", 330 | " box1 = box1.astype(np.float32)\n", 331 | " mat = cv2.getPerspectiveTransform(box0, box1)\n", 332 | " image = cv2.warpPerspective(image, mat, (width, height), flags=cv2.INTER_LINEAR, borderMode=borderMode,\n", 333 | " borderValue=(0, 0, 0,))\n", 334 | " mask = cv2.warpPerspective(mask, mat, (width, height), flags=cv2.INTER_LINEAR, borderMode=borderMode,\n", 335 | " borderValue=(0, 0, 0,))\n", 336 | " if len(mask.shape) == 2:\n", 337 | " mask = np.expand_dims(mask, axis=2)\n", 338 | "\n", 339 | " return image, mask\n", 340 | "\n", 341 | "def randomHorizontalFlip(image, mask, u=0.5):\n", 342 | " if np.random.random() < u:\n", 343 | " image = cv2.flip(image, 1)\n", 344 | " mask = cv2.flip(mask, 1)\n", 345 | "\n", 346 | " return image, mask" 347 | ] 348 | }, 349 | { 350 | "cell_type": "markdown", 351 | "metadata": {}, 352 | "source": [ 353 | "# Define methods for batch generation" 354 | ] 355 | }, 356 | { 357 | "cell_type": "code", 358 | "execution_count": null, 359 | "metadata": {}, 360 | "outputs": [], 361 | "source": [ 362 | "def generate_training_batch(data, batch_size):\n", 363 | " while True:\n", 364 | " X_batch = []\n", 365 | " Y_batch = []\n", 366 | " batch_ids = np.random.choice(data,\n", 367 | " size=batch_size,\n", 368 | " replace=False)\n", 369 | " for idx, img_id in enumerate(batch_ids):\n", 370 | " x = get_image(img_id)\n", 371 | " y = get_mask(img_id)\n", 372 | " x, y = randomShiftScaleRotate(x, y,\n", 373 | " shift_limit=(-0.0625, 0.0625),\n", 374 | " scale_limit=(-0.1, 0.1),\n", 375 | " rotate_limit=(-0, 0))\n", 376 | " x = randomHueSaturationValue(x,\n", 377 | " hue_shift_limit=(-50, 50),\n", 378 | " sat_shift_limit=(-5, 5),\n", 379 | " val_shift_limit=(-15, 15))\n", 380 | " X_batch.append(x)\n", 381 | " Y_batch.append(y)\n", 382 | " X = np.asarray(X_batch, dtype=np.float32)\n", 383 | " Y = np.asarray(Y_batch, dtype=np.float32)\n", 384 | " yield X, Y\n", 385 | "\n", 386 | "def generate_validation_batch(data, batch_size):\n", 387 | " while True:\n", 388 | " X_batch = []\n", 389 | " Y_batch = []\n", 390 | " batch_ids = np.random.choice(data,\n", 391 | " size=batch_size,\n", 392 | " replace=False)\n", 393 | " for idx, img_id in enumerate(batch_ids):\n", 394 | " x = get_image(img_id)\n", 395 | " y = get_mask(img_id)\n", 396 | " X_batch.append(x)\n", 397 | " Y_batch.append(y)\n", 398 | " X = np.asarray(X_batch, dtype=np.float32)\n", 399 | " Y = np.asarray(Y_batch, dtype=np.float32)\n", 400 | " yield X, Y\n", 401 | "\n", 402 | "def generate_validation_data_seq(data):\n", 403 | " idx = 0\n", 404 | " while True:\n", 405 | " img_id = data[idx]\n", 406 | " X = get_image(img_id)\n", 407 | " Y = get_mask(img_id)\n", 408 | " yield img_id, X, Y\n", 409 | " idx += 1\n", 410 | " if idx >= len(data):\n", 411 | " break\n", 412 | "\n", 413 | "def get_model_memory_usage(batch_size, model):\n", 414 | " from keras import backend as K\n", 415 | "\n", 416 | " shapes_mem_count = 0\n", 417 | " for l in model.layers:\n", 418 | " single_layer_mem = 1\n", 419 | " for s in l.output_shape:\n", 420 | " if s is None:\n", 421 | " continue\n", 422 | " single_layer_mem *= s\n", 423 | " shapes_mem_count += single_layer_mem\n", 424 | "\n", 425 | " trainable_count = int(np.sum([K.count_params(p) for p in set(model.trainable_weights)]))\n", 426 | " non_trainable_count = int(np.sum([K.count_params(p) for p in set(model.non_trainable_weights)]))\n", 427 | "\n", 428 | " total_memory = 4*batch_size*(shapes_mem_count + trainable_count + non_trainable_count)\n", 429 | " gbytes = round(total_memory / (1024 ** 3), 3)\n", 430 | " mbytes = round(total_memory / (1024 ** 2), 3)\n", 431 | " \n", 432 | " print('trainable_count', trainable_count, 'non_trainable_count', non_trainable_count, 'gbytes', gbytes, 'mbytes', mbytes)" 433 | ] 434 | }, 435 | { 436 | "cell_type": "markdown", 437 | "metadata": {}, 438 | "source": [ 439 | "# Impact of random shift scale rotate" 440 | ] 441 | }, 442 | { 443 | "cell_type": "code", 444 | "execution_count": null, 445 | "metadata": { 446 | "scrolled": false 447 | }, 448 | "outputs": [], 449 | "source": [ 450 | "# Visualize impact of random shift scale rotate\n", 451 | "random_idx = np.random.randint(len(train_imgs.keys()))\n", 452 | "random_img_id = list(train_imgs.keys())[random_idx]\n", 453 | "plot_image(random_img_id)\n", 454 | "temp_img = get_image(random_img_id)\n", 455 | "mask = get_mask(random_img_id)\n", 456 | "temp_img, temp_mask = randomShiftScaleRotate(temp_img, mask,\n", 457 | " shift_limit=(-0.0625, 0.0625),\n", 458 | " scale_limit=(-0.1, 0.1),\n", 459 | " rotate_limit=(-0, 0))\n", 460 | "\n", 461 | "plt.imshow(temp_img * gray2rgb(temp_mask))\n", 462 | "plt.axis('off')\n", 463 | "plt.show()" 464 | ] 465 | }, 466 | { 467 | "cell_type": "markdown", 468 | "metadata": {}, 469 | "source": [ 470 | "# Impact of random hue saturation" 471 | ] 472 | }, 473 | { 474 | "cell_type": "code", 475 | "execution_count": null, 476 | "metadata": {}, 477 | "outputs": [], 478 | "source": [ 479 | "# Visualize impact of random hue saturation\n", 480 | "random_idx = np.random.randint(len(train_imgs.keys()))\n", 481 | "random_img_id = list(train_imgs.keys())[random_idx]\n", 482 | "plot_image(random_img_id)\n", 483 | "temp_img = cv2.imread(os.path.join(TRAIN_PATH, '{}.jpg'.format(random_img_id)))\n", 484 | "temp_img = randomHueSaturationValue(temp_img,\n", 485 | " hue_shift_limit=(-50, 50),\n", 486 | " sat_shift_limit=(-5, 5),\n", 487 | " val_shift_limit=(-15, 15))\n", 488 | "plt.imshow(temp_img)\n", 489 | "plt.axis('off')\n", 490 | "plt.show()" 491 | ] 492 | }, 493 | { 494 | "cell_type": "markdown", 495 | "metadata": {}, 496 | "source": [ 497 | "# Define U-Net model" 498 | ] 499 | }, 500 | { 501 | "cell_type": "code", 502 | "execution_count": null, 503 | "metadata": {}, 504 | "outputs": [], 505 | "source": [ 506 | "def down(filters, input_):\n", 507 | " down_ = Conv2D(filters, (3, 3), padding='same')(input_)\n", 508 | " down_ = BatchNormalization(epsilon=1e-4)(down_)\n", 509 | " down_ = Activation('relu')(down_)\n", 510 | " down_ = Conv2D(filters, (3, 3), padding='same')(down_)\n", 511 | " down_ = BatchNormalization(epsilon=1e-4)(down_)\n", 512 | " down_res = Activation('relu')(down_)\n", 513 | " down_pool = MaxPooling2D((2, 2), strides=(2, 2))(down_)\n", 514 | " return down_pool, down_res\n", 515 | "\n", 516 | "def up(filters, input_, down_):\n", 517 | " up_ = UpSampling2D((2, 2))(input_)\n", 518 | " up_ = concatenate([down_, up_], axis=3)\n", 519 | " up_ = Conv2D(filters, (3, 3), padding='same')(up_)\n", 520 | " up_ = BatchNormalization(epsilon=1e-4)(up_)\n", 521 | " up_ = Activation('relu')(up_)\n", 522 | " up_ = Conv2D(filters, (3, 3), padding='same')(up_)\n", 523 | " up_ = BatchNormalization(epsilon=1e-4)(up_)\n", 524 | " up_ = Activation('relu')(up_)\n", 525 | " up_ = Conv2D(filters, (3, 3), padding='same')(up_)\n", 526 | " up_ = BatchNormalization(epsilon=1e-4)(up_)\n", 527 | " up_ = Activation('relu')(up_)\n", 528 | " return up_" 529 | ] 530 | }, 531 | { 532 | "cell_type": "code", 533 | "execution_count": null, 534 | "metadata": {}, 535 | "outputs": [], 536 | "source": [ 537 | "def get_unet_1024(input_shape=(HEIGHT, WIDTH, CHANNELS), num_classes=1):\n", 538 | " inputs = Input(shape=input_shape)\n", 539 | "\n", 540 | " with tf.device('/gpu:0'):\n", 541 | " #down0b, down0b_res = down(8, inputs)\n", 542 | " down0a, down0a_res = down(24, inputs)\n", 543 | " down0, down0_res = down(64, down0a)\n", 544 | " down1, down1_res = down(128, down0)\n", 545 | " down2, down2_res = down(256, down1)\n", 546 | " down3, down3_res = down(512, down2)\n", 547 | " down4, down4_res = down(768, down3)\n", 548 | "\n", 549 | " center = Conv2D(768, (3, 3), padding='same')(down4)\n", 550 | " center = BatchNormalization(epsilon=1e-4)(center)\n", 551 | " center = Activation('relu')(center)\n", 552 | " \n", 553 | " with tf.device('/gpu:1'):\n", 554 | " center = Conv2D(768, (3, 3), padding='same')(center)\n", 555 | " center = BatchNormalization(epsilon=1e-4)(center)\n", 556 | " center = Activation('relu')(center)\n", 557 | "\n", 558 | " up4 = up(768, center, down4_res)\n", 559 | " up3 = up(512, up4, down3_res)\n", 560 | " up2 = up(256, up3, down2_res)\n", 561 | " up1 = up(128, up2, down1_res)\n", 562 | " up0 = up(64, up1, down0_res)\n", 563 | " up0a = up(24, up0, down0a_res)\n", 564 | " #up0b = up(8, up0a, down0b_res)\n", 565 | "\n", 566 | " classify = Conv2D(num_classes, (1, 1), activation='sigmoid', name='final_layer')(up0a)\n", 567 | "\n", 568 | " model = Model(inputs=inputs, outputs=classify)\n", 569 | "\n", 570 | " return model" 571 | ] 572 | }, 573 | { 574 | "cell_type": "markdown", 575 | "metadata": {}, 576 | "source": [ 577 | "# Define Dice Coef evaluation" 578 | ] 579 | }, 580 | { 581 | "cell_type": "code", 582 | "execution_count": null, 583 | "metadata": {}, 584 | "outputs": [], 585 | "source": [ 586 | "def dice_coef(y_true, y_pred, smooth=1):\n", 587 | " y_true_f = K.flatten(y_true)\n", 588 | " y_pred_f = K.flatten(y_pred)\n", 589 | " \n", 590 | " intersection = K.sum(y_true_f * y_pred_f)\n", 591 | " return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)\n", 592 | "\n", 593 | "def dice_coef_loss(y_true, y_pred):\n", 594 | " return 1-dice_coef(y_true, y_pred)\n", 595 | "\n", 596 | "def bce_dice_loss(y_true, y_pred):\n", 597 | " return binary_crossentropy(y_true, y_pred) + dice_coef_loss(y_true, y_pred)" 598 | ] 599 | }, 600 | { 601 | "cell_type": "code", 602 | "execution_count": null, 603 | "metadata": {}, 604 | "outputs": [], 605 | "source": [ 606 | "def weighted_bce_loss(y_true, y_pred, weight):\n", 607 | " # avoiding overflow\n", 608 | " epsilon = 1e-7\n", 609 | " y_pred = K.clip(y_pred, epsilon, 1. - epsilon)\n", 610 | " logit_y_pred = K.log(y_pred / (1. - y_pred))\n", 611 | " \n", 612 | " # https://www.tensorflow.org/api_docs/python/tf/nn/weighted_cross_entropy_with_logits\n", 613 | " loss = (1. - y_true) * logit_y_pred + (1. + (weight - 1.) * y_true) * \\\n", 614 | " (K.log(1. + K.exp(-K.abs(logit_y_pred))) + K.maximum(-logit_y_pred, 0.))\n", 615 | " return K.sum(loss) / K.sum(weight)\n", 616 | "\n", 617 | "def weighted_dice_coef(y_true, y_pred, weight):\n", 618 | " smooth = 1.\n", 619 | " w, m1, m2 = weight * weight, y_true, y_pred\n", 620 | " intersection = (m1 * m2)\n", 621 | " score = (2. * K.sum(w * intersection) + smooth) / (K.sum(w * m1) + K.sum(w * m2) + smooth)\n", 622 | " return score\n", 623 | "\n", 624 | "def weighted_dice_loss(y_true, y_pred, weight):\n", 625 | " return 1. - weighted_dice_coef(y_true, y_pred, weight)\n", 626 | "\n", 627 | "def weighted_bce_dice_loss(y_true, y_pred):\n", 628 | " y_true = K.cast(y_true, 'float32')\n", 629 | " y_pred = K.cast(y_pred, 'float32')\n", 630 | " # if we want to get same size of output, kernel size must be odd number\n", 631 | " averaged_mask = K.pool2d(y_true, pool_size=(11, 11), strides=(1, 1), padding='same', pool_mode='avg')\n", 632 | " border = K.cast(K.greater(averaged_mask, 0.01), 'float32') * K.cast(K.less(averaged_mask, 0.99), 'float32')\n", 633 | " weight = K.ones_like(averaged_mask)\n", 634 | " w0 = K.sum(weight)\n", 635 | " weight += border * 2\n", 636 | " w1 = K.sum(weight)\n", 637 | " weight *= (w0 / w1)\n", 638 | " loss = weighted_bce_loss(y_true, y_pred, weight) + weighted_dice_loss(y_true, y_pred, weight)\n", 639 | " return loss" 640 | ] 641 | }, 642 | { 643 | "cell_type": "markdown", 644 | "metadata": {}, 645 | "source": [ 646 | "# Train the model" 647 | ] 648 | }, 649 | { 650 | "cell_type": "code", 651 | "execution_count": null, 652 | "metadata": { 653 | "scrolled": true 654 | }, 655 | "outputs": [], 656 | "source": [ 657 | "BATCH_SIZE = 1\n", 658 | "# Training new model\n", 659 | "ts = str(int(time.time()))\n", 660 | "model_name = 'malhot'\n", 661 | "num_epochs = 30\n", 662 | "steps_per_epoch = int(len(img_ids) * 0.8/BATCH_SIZE)\n", 663 | "run_name = 'model={}-batch_size={}-num_epoch={}-steps_per_epoch={}-ts={}'.format(model_name,\n", 664 | " BATCH_SIZE,\n", 665 | " num_epochs,\n", 666 | " steps_per_epoch,\n", 667 | " ts)\n", 668 | "tensorboard_loc = os.path.join(TENSORBOARD_PATH, run_name)\n", 669 | "checkpoint_loc = os.path.join(MODELS_PATH,'model-1555053470.h5')\n", 670 | "\n", 671 | "earlyStopping = EarlyStopping(monitor='val_loss', \n", 672 | " patience=2, \n", 673 | " verbose=1, \n", 674 | " min_delta = 0.0001,\n", 675 | " mode='min',)\n", 676 | "\n", 677 | "modelCheckpoint = ModelCheckpoint(checkpoint_loc,\n", 678 | " monitor = 'val_loss', \n", 679 | " save_best_only = True, \n", 680 | " mode = 'min', \n", 681 | " verbose = 1,\n", 682 | " save_weights_only = True)\n", 683 | "\n", 684 | "tensorboard = TensorBoard(log_dir=tensorboard_loc, histogram_freq=0, write_graph=True, write_images=True)\n", 685 | "\n", 686 | "callbacks_list = [modelCheckpoint, earlyStopping, tensorboard]\n", 687 | "\n", 688 | "model = get_unet_1024()\n", 689 | "model.compile(loss=bce_dice_loss, optimizer=Adam(lr=1e-4), metrics=[dice_coef])\n", 690 | "print(model.summary())\n", 691 | "get_model_memory_usage(BATCH_SIZE, model)" 692 | ] 693 | }, 694 | { 695 | "cell_type": "code", 696 | "execution_count": null, 697 | "metadata": {}, 698 | "outputs": [], 699 | "source": [ 700 | "# # Re-training old model\n", 701 | "ts = str(int(time.time()))\n", 702 | "model_name = 'malhot'\n", 703 | "num_epochs = 300\n", 704 | "steps_per_epoch = 101\n", 705 | "run_name = 'model={}-batch_size={}-num_epoch={}-steps_per_epoch={}-ts={}'.format(model_name,\n", 706 | " BATCH_SIZE,\n", 707 | " num_epochs,\n", 708 | " steps_per_epoch,\n", 709 | " ts)\n", 710 | "tensorboard_loc = os.path.join(TENSORBOARD_PATH, run_name)\n", 711 | "checkpoint_loc = os.path.join(MODELS_PATH, 'model-1555053470.h5')\n", 712 | "\n", 713 | "modelCheckpoint = ModelCheckpoint(checkpoint_loc,\n", 714 | " monitor = 'val_loss', \n", 715 | " save_best_only = True, \n", 716 | " mode = 'min', \n", 717 | " verbose = 1,\n", 718 | " save_weights_only = True)\n", 719 | "\n", 720 | "tensorboard = TensorBoard(log_dir=tensorboard_loc, histogram_freq=0, write_graph=True, write_images=True)\n", 721 | "\n", 722 | "callbacks_list = [modelCheckpoint, tensorboard]\n", 723 | "\n", 724 | "model = get_unet_1024()\n", 725 | "model.load_weights(os.path.join(MODELS_PATH, 'model-1555053470.h5'))\n", 726 | "model.compile(loss=weighted_bce_dice_loss, optimizer=Adam(lr=1e-5), metrics=[dice_coef])\n", 727 | "model.summary()" 728 | ] 729 | }, 730 | { 731 | "cell_type": "code", 732 | "execution_count": null, 733 | "metadata": {}, 734 | "outputs": [], 735 | "source": [ 736 | "train_ids, validation_ids = model_selection.train_test_split(img_ids, random_state=42, test_size=0.20)\n", 737 | "train_generator = generate_training_batch(train_ids, BATCH_SIZE)\n", 738 | "valid_generator = generate_validation_batch(validation_ids, BATCH_SIZE)\n", 739 | "VALIDATION_STEPS = int(len(validation_ids) / BATCH_SIZE)" 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": null, 745 | "metadata": {}, 746 | "outputs": [], 747 | "source": [ 748 | "model = get_unet_1024()\n", 749 | "model.load_weights(os.path.join(MODELS_PATH, 'model-1555053470.h5'))\n", 750 | "model.compile(loss=bce_dice_loss, optimizer=Adam(1e-5), metrics=[dice_coef])" 751 | ] 752 | }, 753 | { 754 | "cell_type": "code", 755 | "execution_count": null, 756 | "metadata": {}, 757 | "outputs": [], 758 | "source": [ 759 | "model.evaluate_generator(valid_generator, VALIDATION_STEPS)" 760 | ] 761 | }, 762 | { 763 | "cell_type": "markdown", 764 | "metadata": {}, 765 | "source": [ 766 | "### Error analysis on validation set" 767 | ] 768 | }, 769 | { 770 | "cell_type": "code", 771 | "execution_count": null, 772 | "metadata": { 773 | "scrolled": true 774 | }, 775 | "outputs": [], 776 | "source": [ 777 | "validation_dices = []\n", 778 | "for img_id, X, Y in generate_validation_data_seq(validation_ids):\n", 779 | " error = model.evaluate(np.expand_dims(X, axis=0), np.expand_dims(Y, axis=0), verbose=0)\n", 780 | " validation_dices.append((img_id, error[0], error[1]))\n", 781 | "\n", 782 | "val_eval_df = pd.DataFrame.from_records(validation_dices, columns=['img_id', 'val_loss', 'dice_coef'])\n", 783 | "val_eval_df.head()" 784 | ] 785 | }, 786 | { 787 | "cell_type": "code", 788 | "execution_count": null, 789 | "metadata": { 790 | "scrolled": true 791 | }, 792 | "outputs": [], 793 | "source": [ 794 | "val_eval_df.to_csv(os.path.join(DATA_PATH, 'val_eval_df-1506223599.csv'), index=False)\n", 795 | "val_eval_df = pd.read_csv(os.path.join(DATA_PATH, 'val_eval_df-1506223599.csv'))\n", 796 | "\n", 797 | "def get_outliers(data, col, m=2):\n", 798 | " return data[(data[col] - np.mean(data[col])) < -1.0 * (m * np.std(data[col]))]\n", 799 | "outlier_df = get_outliers(val_eval_df, 'dice_coef', 2)\n", 800 | "outlier_df = outlier_df.sort_values('dice_coef')\n", 801 | "print(outlier_df.shape)\n", 802 | "outlier_df" 803 | ] 804 | }, 805 | { 806 | "cell_type": "code", 807 | "execution_count": null, 808 | "metadata": { 809 | "scrolled": true 810 | }, 811 | "outputs": [], 812 | "source": [ 813 | "for img_id in outlier_df.img_id.tolist():\n", 814 | " print(img_id, outlier_df[outlier_df.img_id == img_id].values.tolist()[0][2])\n", 815 | " test_img = get_image(img_id)\n", 816 | "\n", 817 | " # Plot original image\n", 818 | " actual_img = load_image_disk(img_id)\n", 819 | " plt.figure(figsize=(15, 15))\n", 820 | " plt.imshow(actual_img)\n", 821 | " plt.axis('off')\n", 822 | " \n", 823 | " # Predict mask\n", 824 | " pred_mask = model.predict(np.expand_dims(test_img, axis=0))\n", 825 | " \n", 826 | " # Plot predicted mask\n", 827 | " pred_mask = np.squeeze(pred_mask) \n", 828 | " pred_mask = resize_img(pred_mask, (HEIGHT_ORIG, WIDTH_ORIG))\n", 829 | " pred_mask[pred_mask <= 0.5] = 0\n", 830 | " pred_mask[pred_mask > 0.5] = 1\n", 831 | " \n", 832 | " # Plot ground truth mask\n", 833 | " mask = load_mask_disk(img_id)\n", 834 | " mask = np.squeeze(mask)\n", 835 | " mask = resize_img(mask, (HEIGHT_ORIG, WIDTH_ORIG))\n", 836 | " \n", 837 | " # Plot intersection (true_positives) of two masks\n", 838 | " true_positives = pred_mask * mask\n", 839 | " \n", 840 | " # Plot false positives (pred_mask == 1 && mask == 0)\n", 841 | " false_positives = np.zeros_like(mask)\n", 842 | " false_positives[(pred_mask == 1) & (mask == 0)] = 1\n", 843 | " \n", 844 | " # Plot false negatives (pred_mask == 0 && mask == 1)\n", 845 | " false_negatives = np.zeros_like(mask)\n", 846 | " false_negatives[(pred_mask == 0) & (mask == 1)] = 1\n", 847 | "\n", 848 | " # Plot true negatives (pred_mask == 0 && mask == 0)\n", 849 | " true_negatives = np.zeros_like(mask)\n", 850 | " true_negatives[(pred_mask == 0) & (mask == 0)] = 1\n", 851 | " \n", 852 | " # Plot merged mask \n", 853 | " # Legend: \n", 854 | " # Red: false positives \n", 855 | " # Green: true positives\n", 856 | " # Blue: false negatives\n", 857 | " # Black: true negatives\n", 858 | " # White: background (unclassified pixels) - this should never be visible\n", 859 | " rgb_merged_mask = np.zeros((HEIGHT_ORIG, WIDTH_ORIG, CHANNELS_ORIG))\n", 860 | " rgb_merged_mask = 255 # White\n", 861 | " rgb_true_positives = gray2rgb(true_positives)\n", 862 | " rgb_false_positives = gray2rgb(false_positives)\n", 863 | " rgb_false_negatives = gray2rgb(false_negatives)\n", 864 | " rgb_true_negatives = gray2rgb(true_negatives)\n", 865 | "\n", 866 | " rgb_merged_mask = rgb_true_positives + rgb_false_positives + rgb_false_negatives + rgb_true_negatives\n", 867 | " rgb_merged_mask[true_positives == 1] = [0, 255, 0] # Green\n", 868 | " rgb_merged_mask[false_positives == 1] = [255, 0, 0] # Red\n", 869 | " rgb_merged_mask[false_negatives == 1] = [0, 0, 255] # Blue\n", 870 | " rgb_merged_mask[true_negatives == 1] = [0, 0, 0] # Black\n", 871 | " \n", 872 | " plt.figure(figsize=(15, 15))\n", 873 | " plt.imshow(rgb_merged_mask)\n", 874 | " plt.axis('off')\n", 875 | " plt.show()" 876 | ] 877 | }, 878 | { 879 | "cell_type": "code", 880 | "execution_count": null, 881 | "metadata": {}, 882 | "outputs": [], 883 | "source": [ 884 | "# Helper methods\n", 885 | "def rle_encode(mask_image):\n", 886 | " pixels = mask_image.flatten()\n", 887 | " # We avoid issues with '1' at the start or end (at the corners of \n", 888 | " # the original image) by setting those pixels to '0' explicitly.\n", 889 | " # We do not expect these to be non-zero for an accurate mask, \n", 890 | " # so this should not harm the score.\n", 891 | " pixels[0] = 0\n", 892 | " pixels[-1] = 0\n", 893 | " runs = np.where(pixels[1:] != pixels[:-1])[0] + 2\n", 894 | " runs[1::2] = runs[1::2] - runs[:-1:2]\n", 895 | " return runs\n", 896 | "\n", 897 | "def rle_decode(mask_rle, shape):\n", 898 | " '''\n", 899 | " mask_rle: run-length as string formated (start length)\n", 900 | " shape: (height,width) of array to return \n", 901 | " Returns numpy array, 1 - mask, 0 - background\n", 902 | "\n", 903 | " '''\n", 904 | " s = mask_rle.split()\n", 905 | " starts, lengths = [np.asarray(x, dtype=int) for x in (s[0:][::2], s[1:][::2])]\n", 906 | " starts -= 1\n", 907 | " ends = starts + lengths\n", 908 | " img = np.zeros(shape[0]*shape[1], dtype=np.uint8)\n", 909 | " for lo, hi in zip(starts, ends):\n", 910 | " img[lo:hi] = 1\n", 911 | " return img.reshape(shape)\n", 912 | "\n", 913 | "def rle_to_string(runs):\n", 914 | " return ' '.join(str(x) for x in runs)\n", 915 | "\n", 916 | "def load_imgs(img_ids, folder=TRAIN_PATH):\n", 917 | " imgs = []\n", 918 | " for img_id in img_ids:\n", 919 | " img = misc.imread(os.path.join(folder, img_id + \".jpg\"))\n", 920 | " imgs.append(img)\n", 921 | " return np.asarray(imgs)\n", 922 | "\n", 923 | "def resize_imgs(imgs, factor=0.1):\n", 924 | " resized_imgs = []\n", 925 | " for img in imgs:\n", 926 | " resized_img = rescale(img, factor)\n", 927 | " resized_imgs.append(resized_img)\n", 928 | " return np.asarray(resized_imgs)\n", 929 | "\n", 930 | "def rescale_and_clean_masks(masks):\n", 931 | " clean_masks = np.zeros((masks.shape[0], HEIGHT_ORIG, WIDTH_ORIG, 1), dtype=np.uint8)\n", 932 | " for i in range(masks.shape[0]): \n", 933 | " mask = resize(masks[i], (HEIGHT_ORIG, WIDTH_ORIG, 1))\n", 934 | " mask[mask <= 0.5] = 0\n", 935 | " mask[mask > 0.5] = 1\n", 936 | " clean_masks[i] = mask\n", 937 | " return clean_masks\n", 938 | "\n", 939 | "def rle_masks(masks): \n", 940 | " rles = []\n", 941 | " for i in range(masks.shape[0]):\n", 942 | " rles.append(rle_to_string(rle_encode(masks[i])))\n", 943 | " return rles" 944 | ] 945 | }, 946 | { 947 | "cell_type": "markdown", 948 | "metadata": {}, 949 | "source": [ 950 | "# Predict" 951 | ] 952 | }, 953 | { 954 | "cell_type": "code", 955 | "execution_count": null, 956 | "metadata": {}, 957 | "outputs": [], 958 | "source": [ 959 | "model = get_unet_1024()\n", 960 | "# Here you have to specify the concrete name of your saved model\n", 961 | "model.load_weights(os.path.join(MODELS_PATH, 'model-1555053470.h5'))\n", 962 | "model.compile(loss=bce_dice_loss, optimizer=Adam(1e-5), metrics=[dice_coef])" 963 | ] 964 | }, 965 | { 966 | "cell_type": "code", 967 | "execution_count": null, 968 | "metadata": { 969 | "scrolled": false 970 | }, 971 | "outputs": [], 972 | "source": [ 973 | "for img_path in os.listdir(TEST_PATH)[32000:32010]:\n", 974 | " #print(img_id, outlier_df[outlier_df.img_id == img_id].values.tolist()[0][2])\n", 975 | " #test_img = get_image(img_id)\n", 976 | " img_id = get_img_id(img_path)\n", 977 | " \n", 978 | " # Plot original image\n", 979 | " actual_img = load_image_disk(img_id, TEST_PATH)\n", 980 | " plt.figure(figsize=(15, 15))\n", 981 | " plt.imshow(actual_img)\n", 982 | " plt.axis('off')\n", 983 | " \n", 984 | " test_img_cv2 = cv2.resize(actual_img, (new_shape[0], new_shape[1]))\n", 985 | " \n", 986 | " # Predict mask\n", 987 | " pred_mask = model.predict(np.expand_dims(test_img_cv2, axis=0))\n", 988 | " \n", 989 | " # Plot predicted mask\n", 990 | " pred_mask = np.squeeze(pred_mask) \n", 991 | " pred_mask = resize_img(pred_mask, (HEIGHT_ORIG, WIDTH_ORIG))\n", 992 | " pred_mask[pred_mask <= 0.5] = 0\n", 993 | " pred_mask[pred_mask > 0.5] = 1\n", 994 | " \n", 995 | " plt.figure(figsize=(15, 15))\n", 996 | " plt.imshow(pred_mask)\n", 997 | " plt.axis('off')\n", 998 | " plt.show()" 999 | ] 1000 | } 1001 | ], 1002 | "metadata": { 1003 | "kernelspec": { 1004 | "display_name": "Python 3", 1005 | "language": "python", 1006 | "name": "python3" 1007 | }, 1008 | "language_info": { 1009 | "codemirror_mode": { 1010 | "name": "ipython", 1011 | "version": 3 1012 | }, 1013 | "file_extension": ".py", 1014 | "mimetype": "text/x-python", 1015 | "name": "python", 1016 | "nbconvert_exporter": "python", 1017 | "pygments_lexer": "ipython3", 1018 | "version": "3.6.8" 1019 | } 1020 | }, 1021 | "nbformat": 4, 1022 | "nbformat_minor": 2 1023 | } 1024 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # SemanticSegmentation-Examples 2 | 3 | **1. Semantic Webcam Segmentation using DeepLab-V3+:** 4 | 5 | If you want to test the webcam application copy the juypter notebook you find in the folder of Webcam-Segmenation of this GitHub repository. Make sure, that the notebook should be inside your cloned DeepLab directory. 6 | 7 | You get the DeepLab directory on this link: https://github.com/tensorflow/models/tree/master/research/deeplab 8 | 9 | When you run it, you can see a real-time segmentation of your webcam. 10 | 11 | Related Blogpost: https://www.novatec-gmbh.de/blog/semantic-segmentation-part-1-deeplab-v3/ 12 | 13 | **2. Carvana Image Masking Challenge: Training U-Net:** 14 | 15 | First of all you have to download the datasets of the Carvana Challenge: https://www.kaggle.com/c/carvana-image-masking-challenge 16 | 17 | Make sure, that you have installed all the needed libraries and frameworks like tensorflow-GPU and Keras. 18 | For this application, you will need a GPU. 19 | 20 | Clone and run the provided Notebook (model_cnn) and train your model. 21 | 22 | Related Blogpost: https://www.novatec-gmbh.de/blog/semantic-segmentation-part-2-training-u-net/ 23 | 24 | **3. RSNA Pneumonia Detection Challenge: Transfer Learning using Mask R-CNN** 25 | 26 | Download the required datasets of the challenge: https://www.kaggle.com/c/rsna-pneumonia-detection-challenge/data. 27 | 28 | Follow the instructions of the related blogpost (https://www.novatec-gmbh.de/blog/semantic-segmentation-part-3-transfer-learning) and download the Mask R-CNN repository. After that you can clone or copy the notebook from the folder 'RSNA Pneumonia Detection' and run it! 29 | -------------------------------------------------------------------------------- /RSNA Pneumonia Detection (TF with Mask R-CNN)/TransferLearning_MaskRCNN.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Transfer Learning with Mask R-CNN\n", 8 | "# RSNA Pneumonia Detection Challenge" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "metadata": {}, 14 | "source": [ 15 | "To illustrate the practical use of Mask R-CNN in combination with Transfer Learning, I found an interesting application for instance segmentation. It's the Kaggle Challenge: RSNA Pneumonia Detection Challenge.\n", 16 | "\n", 17 | "The company behind this challenge is Radiological Society of North America (RSNA®), an international society of radiologists, medical physicists and other medical professionals. They see the potential for Machine Learning to solve the problem of detecting pneumonia in a simpler and automated way. Common diagnosing pneumonia requires review of a chest radiograph (CXR) by qualified experts. The disease pattern often manifests as an area of opacity on CXR, but there are many other conditions playing a role.\n", 18 | "\n", 19 | "So in this competition, the participants are called to support clinical institutions by building a machine learning algorithm in order to locate lung opacities on chest radiographs. Our model will be applied to segment all the the regions in the medical images and predicts the probability for a pneumonia. In other words the objective is to detect and draw a bounding box on each of the pneumonia opacities. Each image can have zero or many opacities.\n", 20 | "\n" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "## Import dependencies" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": null, 33 | "metadata": {}, 34 | "outputs": [], 35 | "source": [ 36 | "import os \n", 37 | "import sys\n", 38 | "import random\n", 39 | "import math\n", 40 | "import numpy as np\n", 41 | "import cv2\n", 42 | "import matplotlib.pyplot as plt\n", 43 | "import json\n", 44 | "import pydicom\n", 45 | "from imgaug import augmenters as iaa\n", 46 | "from tqdm import tqdm\n", 47 | "import pandas as pd \n", 48 | "import glob\n", 49 | "from sklearn.model_selection import KFold\n", 50 | "#from models import *" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "## Check GPU usage" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "from tensorflow.python.client import device_lib\n", 67 | "print(device_lib.list_local_devices())" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": null, 73 | "metadata": {}, 74 | "outputs": [], 75 | "source": [ 76 | "DATA_DIR = '/input'\n", 77 | "\n", 78 | "# Directory to save logs and trained model, name it like you want\n", 79 | "ROOT_DIR = '/working'" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "## Clone Mask R-CNN GitHub repository" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "!git clone https://www.github.com/matterport/Mask_RCNN.git\n", 96 | "os.chdir('Mask_RCNN')" 97 | ] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "## Import for Mask R-CNN" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [ 112 | "# Import Mask RCNN\n", 113 | "sys.path.append(os.path.join('Mask_RCNN')) # To find local version of the library\n", 114 | "from mrcnn.config import Config\n", 115 | "from mrcnn import utils\n", 116 | "import mrcnn.model as modellib\n", 117 | "from mrcnn import visualize\n", 118 | "from mrcnn.model import log" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "#download datasets on Kaggle: https://www.kaggle.com/c/rsna-pneumonia-detection-challenge/data\n", 128 | "train_dicom_dir = './input/stage_2_train_images'\n", 129 | "test_dicom_dir = './input/stage_2_test_images'" 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "## Get COCO weights " 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [ 145 | "# !cd coco_weight && wget --quiet https://github.com/matterport/Mask_RCNN/releases/download/v2.0/mask_rcnn_coco.h5\n", 146 | "# !ls -lh mask_rcnn_coco.h5\n", 147 | "\n", 148 | "COCO_WEIGHTS_PATH = \"/my-ml-files/working/mask_rcnn_coco.h5\"" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "metadata": {}, 154 | "source": [ 155 | "## Some setup functions and classes for Mask-RCNN" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": null, 161 | "metadata": {}, 162 | "outputs": [], 163 | "source": [ 164 | "#dicom_fps: list of the dicom image path and filenames\n", 165 | "#image_annotions: dictionary of the annotations keyed by the filenames\n", 166 | "#parsing the dataset: return a list of the image filenames and the annotations dictionary\n", 167 | "\n", 168 | "def get_dicom_fps(dicom_dir):\n", 169 | " dicom_fps = glob.glob(dicom_dir+'/'+'*.dcm')\n", 170 | " return list(set(dicom_fps))\n", 171 | "\n", 172 | "def parse_dataset(dicom_dir, anns): \n", 173 | " image_fps = get_dicom_fps(dicom_dir)\n", 174 | " image_annotations = {fp: [] for fp in image_fps}\n", 175 | " for index, row in anns.iterrows(): \n", 176 | " fp = os.path.join(dicom_dir, row['patientId']+'.dcm')\n", 177 | " image_annotations[fp].append(row)\n", 178 | " return image_fps, image_annotations " 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "## Set training parameter" 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "# The following parameters are not optimal!\n", 195 | "\n", 196 | "class DetectorConfig(Config):\n", 197 | " \"\"\"Configuration for training pneumonia detection on the RSNA pneumonia dataset.\n", 198 | " Overrides values in the base Config class.\n", 199 | " \"\"\"\n", 200 | " \n", 201 | " # Configuration name \n", 202 | " NAME = 'pneumonia'\n", 203 | " \n", 204 | " # 1 GPU and 8 images per GPU\n", 205 | " # Batch size is 8 (GPUs * images/GPU).\n", 206 | " GPU_COUNT = 1\n", 207 | " IMAGES_PER_GPU = 8\n", 208 | " \n", 209 | " # play with some numbers!\n", 210 | " BACKBONE = 'resnet50' #'resnet100'\n", 211 | " \n", 212 | " NUM_CLASSES = 2 # background + pneumonia classes\n", 213 | " \n", 214 | " IMAGE_MIN_DIM = 256\n", 215 | " IMAGE_MAX_DIM = 256\n", 216 | " #RPN_ANCHOR_SCALES = (16, 32, 64, 128)\n", 217 | " TRAIN_ROIS_PER_IMAGE = 32 #16\n", 218 | " MAX_GT_INSTANCES = 4 #3\n", 219 | " DETECTION_MAX_INSTANCES = 3\n", 220 | " DETECTION_MIN_CONFIDENCE = 0.78 #0.7\n", 221 | " DETECTION_NMS_THRESHOLD = 0.01 #0.3\n", 222 | "\n", 223 | " STEPS_PER_EPOCH = 200 #500\n", 224 | "\n", 225 | "config = DetectorConfig()\n", 226 | "config.display()" 227 | ] 228 | }, 229 | { 230 | "cell_type": "markdown", 231 | "metadata": {}, 232 | "source": [ 233 | "## Dataset class for training pneumonia detection on the dataset" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": null, 239 | "metadata": {}, 240 | "outputs": [], 241 | "source": [ 242 | "class DetectorDataset(utils.Dataset):\n", 243 | "\n", 244 | " def __init__(self, image_fps, image_annotations, orig_height, orig_width):\n", 245 | " super().__init__(self)\n", 246 | " \n", 247 | " # Add classes\n", 248 | " self.add_class('pneumonia', 1, 'Lung Opacity')\n", 249 | " \n", 250 | " # add images \n", 251 | " for i, fp in enumerate(image_fps):\n", 252 | " annotations = image_annotations[fp]\n", 253 | " self.add_image('pneumonia', image_id=i, path=fp, \n", 254 | " annotations=annotations, orig_height=orig_height, orig_width=orig_width)\n", 255 | " \n", 256 | " def image_reference(self, image_id):\n", 257 | " info = self.image_info[image_id]\n", 258 | " return info['path']\n", 259 | "\n", 260 | " def load_image(self, image_id):\n", 261 | " info = self.image_info[image_id]\n", 262 | " fp = info['path']\n", 263 | " ds = pydicom.read_file(fp)\n", 264 | " image = ds.pixel_array\n", 265 | " # If grayscale. Convert to RGB for consistency.\n", 266 | " if len(image.shape) != 3 or image.shape[2] != 3:\n", 267 | " image = np.stack((image,) * 3, -1)\n", 268 | " return image\n", 269 | "\n", 270 | " def load_mask(self, image_id):\n", 271 | " info = self.image_info[image_id]\n", 272 | " annotations = info['annotations']\n", 273 | " count = len(annotations)\n", 274 | " if count == 0:\n", 275 | " mask = np.zeros((info['orig_height'], info['orig_width'], 1), dtype=np.uint8)\n", 276 | " class_ids = np.zeros((1,), dtype=np.int32)\n", 277 | " else:\n", 278 | " mask = np.zeros((info['orig_height'], info['orig_width'], count), dtype=np.uint8)\n", 279 | " class_ids = np.zeros((count,), dtype=np.int32)\n", 280 | " for i, a in enumerate(annotations):\n", 281 | " if a['Target'] == 1:\n", 282 | " x = int(a['x'])\n", 283 | " y = int(a['y'])\n", 284 | " w = int(a['width'])\n", 285 | " h = int(a['height'])\n", 286 | " mask_instance = mask[:, :, i].copy()\n", 287 | " cv2.rectangle(mask_instance, (x, y), (x+w, y+h), 255, -1)\n", 288 | " mask[:, :, i] = mask_instance\n", 289 | " class_ids[i] = 1\n", 290 | " return mask.astype(np.bool), class_ids.astype(np.int32)" 291 | ] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "metadata": {}, 296 | "source": [ 297 | "## Examine the annotation data, parse the dataset, and view dicom fields" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": null, 303 | "metadata": {}, 304 | "outputs": [], 305 | "source": [ 306 | "# training dataset\n", 307 | "from pathlib import Path\n", 308 | "mypath = Path().absolute()\n", 309 | "print(mypath)\n", 310 | "\n", 311 | "anns = pd.read_csv('./input/stage_labels.csv')\n", 312 | "anns.head()" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": null, 318 | "metadata": {}, 319 | "outputs": [], 320 | "source": [ 321 | "image_fps, image_annotations = parse_dataset(train_dicom_dir, anns=anns)" 322 | ] 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": null, 327 | "metadata": {}, 328 | "outputs": [], 329 | "source": [ 330 | "ds = pydicom.read_file(image_fps[0]) # read dicom image from filepath \n", 331 | "image = ds.pixel_array # get image array" 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": null, 337 | "metadata": {}, 338 | "outputs": [], 339 | "source": [ 340 | "# Image size: 1024 x 1024\n", 341 | "ORIG_SIZE = 1024" 342 | ] 343 | }, 344 | { 345 | "cell_type": "markdown", 346 | "metadata": {}, 347 | "source": [ 348 | "## Split the data into training and validation datasets" 349 | ] 350 | }, 351 | { 352 | "cell_type": "code", 353 | "execution_count": null, 354 | "metadata": {}, 355 | "outputs": [], 356 | "source": [ 357 | "image_fps_list = list(image_fps)\n", 358 | "random.seed(42)\n", 359 | "random.shuffle(image_fps_list)\n", 360 | "val_size = 1500\n", 361 | "image_fps_val = image_fps_list[:val_size]\n", 362 | "image_fps_train = image_fps_list[val_size:]\n", 363 | "\n", 364 | "print(len(image_fps_train), len(image_fps_val))" 365 | ] 366 | }, 367 | { 368 | "cell_type": "markdown", 369 | "metadata": {}, 370 | "source": [ 371 | "## Create and prepare the training dataset using the DetectorDataset class" 372 | ] 373 | }, 374 | { 375 | "cell_type": "code", 376 | "execution_count": null, 377 | "metadata": {}, 378 | "outputs": [], 379 | "source": [ 380 | "# prepare the training dataset\n", 381 | "dataset_train = DetectorDataset(image_fps_train, image_annotations, ORIG_SIZE, ORIG_SIZE)\n", 382 | "dataset_train.prepare()" 383 | ] 384 | }, 385 | { 386 | "cell_type": "markdown", 387 | "metadata": {}, 388 | "source": [ 389 | "## Show annotation for a DICOM image " 390 | ] 391 | }, 392 | { 393 | "cell_type": "code", 394 | "execution_count": null, 395 | "metadata": {}, 396 | "outputs": [], 397 | "source": [ 398 | "# bounding box with (x, y) of the the top left corner as well as the width and height.\n", 399 | "test_fp = random.choice(image_fps_train)\n", 400 | "image_annotations[test_fp]" 401 | ] 402 | }, 403 | { 404 | "cell_type": "markdown", 405 | "metadata": {}, 406 | "source": [ 407 | "## Prepare the validation dataset" 408 | ] 409 | }, 410 | { 411 | "cell_type": "code", 412 | "execution_count": null, 413 | "metadata": {}, 414 | "outputs": [], 415 | "source": [ 416 | "dataset_val = DetectorDataset(image_fps_val, image_annotations, ORIG_SIZE, ORIG_SIZE)\n", 417 | "dataset_val.prepare()" 418 | ] 419 | }, 420 | { 421 | "cell_type": "markdown", 422 | "metadata": {}, 423 | "source": [ 424 | "## Load and display random sample and their bounding boxes" 425 | ] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": null, 430 | "metadata": {}, 431 | "outputs": [], 432 | "source": [ 433 | "class_ids = [0]\n", 434 | "while class_ids[0] == 0: ## look for a mask\n", 435 | " image_id = random.choice(dataset_train.image_ids)\n", 436 | " image_fp = dataset_train.image_reference(image_id)\n", 437 | " image = dataset_train.load_image(image_id)\n", 438 | " mask, class_ids = dataset_train.load_mask(image_id)\n", 439 | "\n", 440 | "print(image.shape)\n", 441 | "\n", 442 | "plt.figure(figsize=(10, 10))\n", 443 | "plt.subplot(1, 2, 1)\n", 444 | "plt.imshow(image)\n", 445 | "plt.axis('off')\n", 446 | "\n", 447 | "plt.subplot(1, 2, 2)\n", 448 | "masked = np.zeros(image.shape[:2])\n", 449 | "for i in range(mask.shape[2]):\n", 450 | " masked += image[:, :, 0] * mask[:, :, i]\n", 451 | "plt.imshow(masked, cmap='gray')\n", 452 | "plt.axis('off')\n", 453 | "\n", 454 | "print(image_fp)\n", 455 | "print(class_ids)" 456 | ] 457 | }, 458 | { 459 | "cell_type": "markdown", 460 | "metadata": {}, 461 | "source": [ 462 | "## Image augmentation " 463 | ] 464 | }, 465 | { 466 | "cell_type": "code", 467 | "execution_count": null, 468 | "metadata": {}, 469 | "outputs": [], 470 | "source": [ 471 | "augmentation = iaa.Sequential([\n", 472 | " iaa.OneOf([ ## geometric transform\n", 473 | " iaa.Affine(\n", 474 | " scale={\"x\": (0.98, 1.02), \"y\": (0.98, 1.04)},\n", 475 | " translate_percent={\"x\": (-0.02, 0.02), \"y\": (-0.04, 0.04)},\n", 476 | " rotate=(-2, 2),\n", 477 | " shear=(-1, 1),\n", 478 | " ),\n", 479 | " iaa.PiecewiseAffine(scale=(0.001, 0.025)),\n", 480 | " ]),\n", 481 | " iaa.OneOf([ ## brightness or contrast\n", 482 | " iaa.Multiply((0.9, 1.1)),\n", 483 | " iaa.ContrastNormalization((0.9, 1.1)),\n", 484 | " ]),\n", 485 | " iaa.OneOf([ ## blur or sharpen\n", 486 | " iaa.GaussianBlur(sigma=(0.0, 0.1)),\n", 487 | " iaa.Sharpen(alpha=(0.0, 0.1)),\n", 488 | " ]),\n", 489 | "])\n", 490 | "\n", 491 | "# test augmentation on image\n", 492 | "imggrid = augmentation.draw_grid(image[:, :, 0], cols=5, rows=2)\n", 493 | "plt.figure(figsize=(30, 12))\n", 494 | "_ = plt.imshow(imggrid[:, :, 0], cmap='gray')" 495 | ] 496 | }, 497 | { 498 | "cell_type": "markdown", 499 | "metadata": {}, 500 | "source": [ 501 | "## Training" 502 | ] 503 | }, 504 | { 505 | "cell_type": "markdown", 506 | "metadata": {}, 507 | "source": [ 508 | "Now it's time to train the model. \n", 509 | "Note: the following model is for demonstration purpose only.\n", 510 | "\n", 511 | "- dataset_train and dataset_val from DetectorDataset\n", 512 | "- DetectorDataset loads images from image files and masks from the annotation data\n", 513 | "- model: Mask-RCNN\n", 514 | "\n" 515 | ] 516 | }, 517 | { 518 | "cell_type": "code", 519 | "execution_count": null, 520 | "metadata": {}, 521 | "outputs": [], 522 | "source": [ 523 | "model = modellib.MaskRCNN(mode='training', config=config, model_dir=ROOT_DIR)\n", 524 | "\n", 525 | "model.load_weights(COCO_WEIGHTS_PATH, by_name=True, exclude=[\n", 526 | " \"mrcnn_class_logits\", \"mrcnn_bbox_fc\",\n", 527 | " \"mrcnn_bbox\", \"mrcnn_mask\"])" 528 | ] 529 | }, 530 | { 531 | "cell_type": "code", 532 | "execution_count": null, 533 | "metadata": {}, 534 | "outputs": [], 535 | "source": [ 536 | "LEARNING_RATE = 0.006\n", 537 | "\n", 538 | "import warnings \n", 539 | "warnings.filterwarnings(\"ignore\")" 540 | ] 541 | }, 542 | { 543 | "cell_type": "code", 544 | "execution_count": null, 545 | "metadata": {}, 546 | "outputs": [], 547 | "source": [ 548 | "# train heads with higher lr for more learning speed\n", 549 | "model.train(dataset_train, dataset_val,\n", 550 | " learning_rate=LEARNING_RATE,\n", 551 | " epochs=1,\n", 552 | " layers='heads',\n", 553 | " augmentation=None) \n", 554 | "\n", 555 | "history = model.keras_model.history.history\n", 556 | "\n", 557 | "#now with all layers and augmentation included!\n", 558 | "model.train(dataset_train, dataset_val,\n", 559 | " learning_rate=LEARNING_RATE,\n", 560 | " epochs=6,\n", 561 | " layers='all',\n", 562 | " augmentation=augmentation)\n", 563 | "\n", 564 | "new_history = model.keras_model.history.history\n", 565 | "for k in new_history: history[k] = history[k] + new_history[k]\n", 566 | "\n", 567 | "model.train(dataset_train, dataset_val,\n", 568 | " learning_rate=LEARNING_RATE/5,\n", 569 | " epochs=16,\n", 570 | " layers='all',\n", 571 | " augmentation=augmentation)\n", 572 | "\n", 573 | "new_history = model.keras_model.history.history\n", 574 | "for k in new_history: history[k] = history[k] + new_history[k]\n" 575 | ] 576 | }, 577 | { 578 | "cell_type": "code", 579 | "execution_count": null, 580 | "metadata": {}, 581 | "outputs": [], 582 | "source": [ 583 | "epochs = range(1,len(next(iter(history.values())))+1)\n", 584 | "pd.DataFrame(history, index=epochs)" 585 | ] 586 | }, 587 | { 588 | "cell_type": "code", 589 | "execution_count": null, 590 | "metadata": {}, 591 | "outputs": [], 592 | "source": [ 593 | "plt.figure(figsize=(17,5))\n", 594 | "\n", 595 | "plt.subplot(131)\n", 596 | "plt.plot(epochs, history[\"loss\"], label=\"Train loss\")\n", 597 | "plt.plot(epochs, history[\"val_loss\"], label=\"Valid loss\")\n", 598 | "plt.legend()\n", 599 | "plt.subplot(132)\n", 600 | "plt.plot(epochs, history[\"mrcnn_class_loss\"], label=\"Train class ce\")\n", 601 | "plt.plot(epochs, history[\"val_mrcnn_class_loss\"], label=\"Valid class ce\")\n", 602 | "plt.legend()\n", 603 | "plt.subplot(133)\n", 604 | "plt.plot(epochs, history[\"mrcnn_bbox_loss\"], label=\"Train box loss\")\n", 605 | "plt.plot(epochs, history[\"val_mrcnn_bbox_loss\"], label=\"Valid box loss\")\n", 606 | "plt.legend()\n", 607 | "\n", 608 | "plt.show()" 609 | ] 610 | }, 611 | { 612 | "cell_type": "code", 613 | "execution_count": null, 614 | "metadata": {}, 615 | "outputs": [], 616 | "source": [ 617 | "best_epoch = np.argmin(history[\"val_loss\"])\n", 618 | "print(\"Best Epoch:\", best_epoch + 1, history[\"val_loss\"][best_epoch])" 619 | ] 620 | }, 621 | { 622 | "cell_type": "code", 623 | "execution_count": null, 624 | "metadata": {}, 625 | "outputs": [], 626 | "source": [ 627 | "# select trained model \n", 628 | "dir_names = next(os.walk(model.model_dir))[1]\n", 629 | "key = config.NAME.lower()\n", 630 | "dir_names = filter(lambda f: f.startswith(key), dir_names)\n", 631 | "dir_names = sorted(dir_names)\n", 632 | "\n", 633 | "if not dir_names:\n", 634 | " import errno\n", 635 | " raise FileNotFoundError(\n", 636 | " errno.ENOENT,\n", 637 | " \"Could not find model directory under {}\".format(self.model_dir))\n", 638 | " \n", 639 | "fps = []\n", 640 | "# Pick last directory\n", 641 | "for d in dir_names: \n", 642 | " dir_name = os.path.join(model.model_dir, d)\n", 643 | " # Find the last checkpoint\n", 644 | " checkpoints = next(os.walk(dir_name))[2]\n", 645 | " checkpoints = filter(lambda f: f.startswith(\"mask_rcnn\"), checkpoints)\n", 646 | " checkpoints = sorted(checkpoints)\n", 647 | " if not checkpoints:\n", 648 | " print('No weight files in {}'.format(dir_name))\n", 649 | " else:\n", 650 | " checkpoint = os.path.join(dir_name, checkpoints[best_epoch])\n", 651 | " fps.append(checkpoint)\n", 652 | "\n", 653 | "model_path = sorted(fps)[-1]\n", 654 | "print('Found model {}'.format(model_path))" 655 | ] 656 | }, 657 | { 658 | "cell_type": "code", 659 | "execution_count": null, 660 | "metadata": {}, 661 | "outputs": [], 662 | "source": [ 663 | "class InferenceConfig(DetectorConfig):\n", 664 | " GPU_COUNT = 1\n", 665 | " IMAGES_PER_GPU = 1\n", 666 | "\n", 667 | "inference_config = InferenceConfig()\n", 668 | "\n", 669 | "# Recreate the model in inference mode\n", 670 | "model = modellib.MaskRCNN(mode='inference', \n", 671 | " config=inference_config,\n", 672 | " model_dir=ROOT_DIR)\n", 673 | "\n", 674 | "# Load trained weights (fill in path to trained weights here)\n", 675 | "assert model_path != \"\", \"Provide path to trained weights\"\n", 676 | "print(\"Loading weights from \", model_path)\n", 677 | "model.load_weights(model_path, by_name=True)" 678 | ] 679 | }, 680 | { 681 | "cell_type": "code", 682 | "execution_count": null, 683 | "metadata": {}, 684 | "outputs": [], 685 | "source": [ 686 | "# set color for class\n", 687 | "def get_colors_for_class_ids(class_ids):\n", 688 | " colors = []\n", 689 | " for class_id in class_ids:\n", 690 | " if class_id == 1:\n", 691 | " colors.append((.941, .204, .204))\n", 692 | " return colors" 693 | ] 694 | }, 695 | { 696 | "cell_type": "markdown", 697 | "metadata": {}, 698 | "source": [ 699 | "## Using the validation data to check the expected bounding box\n" 700 | ] 701 | }, 702 | { 703 | "cell_type": "code", 704 | "execution_count": null, 705 | "metadata": {}, 706 | "outputs": [], 707 | "source": [ 708 | "# Predictions on the validation dataset \n", 709 | "dataset = dataset_val\n", 710 | "fig = plt.figure(figsize=(10, 30))\n", 711 | "\n", 712 | "for i in range(6):\n", 713 | "\n", 714 | " image_id = random.choice(dataset.image_ids)\n", 715 | " \n", 716 | " original_image, image_meta, gt_class_id, gt_bbox, gt_mask =\\\n", 717 | " modellib.load_image_gt(dataset_val, inference_config, \n", 718 | " image_id, use_mini_mask=False)\n", 719 | " \n", 720 | " print(original_image.shape)\n", 721 | " plt.subplot(6, 2, 2*i + 1)\n", 722 | " visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id, \n", 723 | " dataset.class_names,\n", 724 | " colors=get_colors_for_class_ids(gt_class_id), ax=fig.axes[-1])\n", 725 | " \n", 726 | " plt.subplot(6, 2, 2*i + 2)\n", 727 | " results = model.detect([original_image]) #, verbose=1)\n", 728 | " r = results[0]\n", 729 | " visualize.display_instances(original_image, r['rois'], r['masks'], r['class_ids'], \n", 730 | " dataset.class_names, r['scores'], \n", 731 | " colors=get_colors_for_class_ids(r['class_ids']), ax=fig.axes[-1])" 732 | ] 733 | }, 734 | { 735 | "cell_type": "markdown", 736 | "metadata": {}, 737 | "source": [ 738 | "## Optional: Predict Test dataset and get submission file for Kaggle" 739 | ] 740 | }, 741 | { 742 | "cell_type": "code", 743 | "execution_count": null, 744 | "metadata": {}, 745 | "outputs": [], 746 | "source": [ 747 | "# Get filenames of test images\n", 748 | "test_image_fps = get_dicom_fps(test_dicom_dir)" 749 | ] 750 | }, 751 | { 752 | "cell_type": "code", 753 | "execution_count": null, 754 | "metadata": {}, 755 | "outputs": [], 756 | "source": [ 757 | "# Make predictions on test images, write to submission file\n", 758 | "def predict(image_fps, filepath='submission.csv', min_conf=0.95):\n", 759 | " resize_factor = ORIG_SIZE / config.IMAGE_SHAPE[0]\n", 760 | " with open(filepath, 'w') as file:\n", 761 | " file.write(\"patientId,PredictionString\\n\")\n", 762 | "\n", 763 | " for image_id in tqdm(image_fps):\n", 764 | " ds = pydicom.read_file(image_id)\n", 765 | " image = ds.pixel_array\n", 766 | " if len(image.shape) != 3 or image.shape[2] != 3:\n", 767 | " image = np.stack((image,) * 3, -1)\n", 768 | " image, window, scale, padding, crop = utils.resize_image(\n", 769 | " image,\n", 770 | " min_dim=config.IMAGE_MIN_DIM,\n", 771 | " min_scale=config.IMAGE_MIN_SCALE,\n", 772 | " max_dim=config.IMAGE_MAX_DIM,\n", 773 | " mode=config.IMAGE_RESIZE_MODE)\n", 774 | "\n", 775 | " patient_id = os.path.splitext(os.path.basename(image_id))[0]\n", 776 | "\n", 777 | " results = model.detect([image])\n", 778 | " r = results[0]\n", 779 | "\n", 780 | " out_str = \"\"\n", 781 | " out_str += patient_id\n", 782 | " out_str += \",\"\n", 783 | " assert( len(r['rois']) == len(r['class_ids']) == len(r['scores']) )\n", 784 | " if len(r['rois']) == 0:\n", 785 | " pass\n", 786 | " else:\n", 787 | " num_instances = len(r['rois'])\n", 788 | "\n", 789 | " for i in range(num_instances):\n", 790 | " if r['scores'][i] > min_conf:\n", 791 | " out_str += ' '\n", 792 | " out_str += str(round(r['scores'][i], 2))\n", 793 | " out_str += ' '\n", 794 | "\n", 795 | " # x1, y1, width, height\n", 796 | " x1 = r['rois'][i][1]\n", 797 | " y1 = r['rois'][i][0]\n", 798 | " width = r['rois'][i][3] - x1\n", 799 | " height = r['rois'][i][2] - y1\n", 800 | " bboxes_str = \"{} {} {} {}\".format(x1*resize_factor, y1*resize_factor, \\\n", 801 | " width*resize_factor, height*resize_factor)\n", 802 | " out_str += bboxes_str\n", 803 | "\n", 804 | " file.write(out_str+\"\\n\")" 805 | ] 806 | }, 807 | { 808 | "cell_type": "code", 809 | "execution_count": null, 810 | "metadata": {}, 811 | "outputs": [], 812 | "source": [] 813 | } 814 | ], 815 | "metadata": { 816 | "kernelspec": { 817 | "display_name": "Python 3", 818 | "language": "python", 819 | "name": "python3" 820 | }, 821 | "language_info": { 822 | "codemirror_mode": { 823 | "name": "ipython", 824 | "version": 3 825 | }, 826 | "file_extension": ".py", 827 | "mimetype": "text/x-python", 828 | "name": "python", 829 | "nbconvert_exporter": "python", 830 | "pygments_lexer": "ipython3", 831 | "version": "3.6.8" 832 | } 833 | }, 834 | "nbformat": 4, 835 | "nbformat_minor": 2 836 | } 837 | -------------------------------------------------------------------------------- /Webcam_Segmentation (DeepLab-V3+)/Webcam_Segmentation.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Semantic Image Segmentation with DeepLab in TensorFlow using Webcam OpenCV\n" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Semantic Segmentation describes the task to assign a semantic label to every pixel in an image or video. Framing the topic of real-time segmentation, I applied the open-sourced DeepLab model by Google, which is implemented in TensorFlow. The following improvements have been made to the model since its release in 2016:\n", 15 | "- DeepLab-V1: Using atrous convolution (a.k.a. dilated convolution: Introducing another parameter, the dilation rate, to convolution layer, what delivers a wider field of view at the same computation) to control the resolution of feature responses computation in CNNs.\n", 16 | "- DeepLab-V2: Using atrous spatial pyramid pooling (ASPP), which helps to account for different object scales and improves accuracy.\n", 17 | "- DeepLab-V3: Adding image-level feature to ASPP and applying batch normalization for easier training.\n", 18 | "- DeepLab-V3+: Extension of DeepLabv3 by a decoder module to refine the segmentation results.\n", 19 | "\n", 20 | "The architecture of the latest version of DeepLab (DeepLab-V3+) is composed of two steps:\n", 21 | "\n", 22 | "1. Encoder: In this step, a pre-trained CNN extracts the essential information from the input image. For segmentation tasks, the essential information is the objects present in the image and their location.\n", 23 | "2. Decoder: Here, we reconstruct the output of appropriate dimensions using the extracted information as input.\n" 24 | ] 25 | }, 26 | { 27 | "attachments": { 28 | "image.png": { 29 | "image/png": "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" 30 | } 31 | }, 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "![image.png](attachment:image.png)" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 1, 41 | "metadata": {}, 42 | "outputs": [ 43 | { 44 | "ename": "ModuleNotFoundError", 45 | "evalue": "No module named 'get_dataset_colormap'", 46 | "output_type": "error", 47 | "traceback": [ 48 | "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", 49 | "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", 50 | "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 18\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mtensorflow\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mtf\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 19\u001b[0m \u001b[0msys\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'utils'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 20\u001b[1;33m \u001b[1;32mimport\u001b[0m \u001b[0mget_dataset_colormap\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", 51 | "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'get_dataset_colormap'" 52 | ] 53 | } 54 | ], 55 | "source": [ 56 | "#Some imports\n", 57 | "import collections\n", 58 | "import os\n", 59 | "import io\n", 60 | "import sys\n", 61 | "import tarfile\n", 62 | "import tempfile\n", 63 | "import urllib\n", 64 | "from IPython import display\n", 65 | "from ipywidgets import interact\n", 66 | "from ipywidgets import interactive\n", 67 | "from matplotlib import gridspec\n", 68 | "from matplotlib import pyplot as plt\n", 69 | "import numpy as np\n", 70 | "from PIL import Image\n", 71 | "import cv2\n", 72 | "\n", 73 | "import tensorflow as tf\n", 74 | "sys.path.append('utils')\n", 75 | "import get_dataset_colormap" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "#Download URLs of the pre-trained Xception model\n", 85 | "_MODEL_URLS = {\n", 86 | " 'xception_coco_voctrainaug': 'http://download.tensorflow.org/models/deeplabv3_pascal_train_aug_2018_01_04.tar.gz',\n", 87 | " 'xception_coco_voctrainval': 'http://download.tensorflow.org/models/deeplabv3_pascal_trainval_2018_01_04.tar.gz',\n", 88 | "}\n", 89 | "\n", 90 | "Config = collections.namedtuple('Config', 'model_url, model_dir')\n", 91 | "\n", 92 | "def get_config(model_name, model_dir):\n", 93 | " return Config(_MODEL_URLS[model_name], model_dir)\n", 94 | "\n", 95 | "config_widget = interactive(get_config, model_name=_MODEL_URLS.keys(), model_dir='')\n", 96 | "display.display(config_widget)\n", 97 | "\n", 98 | "_TARBALL_NAME = 'deeplab_model.tar.gz'\n", 99 | "\n", 100 | "config = config_widget.result\n", 101 | "\n", 102 | "#create directory\n", 103 | "model_dir = config.model_dir or tempfile.mkdtemp()\n", 104 | "tf.gfile.MakeDirs(model_dir)\n", 105 | "\n", 106 | "download_path = os.path.join(model_dir, _TARBALL_NAME)\n", 107 | "print('downloading model to %s, this might take a while...' % download_path)\n", 108 | "urllib.request.urlretrieve(config.model_url, download_path)\n", 109 | "print('download completed!')" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [ 118 | "_FROZEN_GRAPH = 'frozen_inference_graph'\n", 119 | "\n", 120 | "# Class to load DeepLab model and run inference.\n", 121 | "class DeepLab(object)\n", 122 | " INPUT_TENSOR = 'ImageTensor:0'\n", 123 | " OUTPUT_TENSOR = 'SemanticPredictions:0'\n", 124 | " INPUT_SIZE = 513\n", 125 | " # Creates and loads pretrained Deeplab model\n", 126 | " def __init__(self, tarball_path):\n", 127 | " self.graph = tf.Graph()\n", 128 | " graph_def = None\n", 129 | " tar_file = tarfile.open(tarball_path)\n", 130 | " for tar_info in tar_file.getmembers():\n", 131 | " if _FROZEN_GRAPH in os.path.basename(tar_info.name):\n", 132 | " file_handle = tar_file.extractfile(tar_info)\n", 133 | " graph_def = tf.GraphDef.FromString(file_handle.read())\n", 134 | " break\n", 135 | " tar_file.close()\n", 136 | " if graph_def is None:\n", 137 | " raise RuntimeError('Cant find graph.')\n", 138 | "\n", 139 | " with self.graph.as_default(): \n", 140 | " tf.import_graph_def(graph_def, name='')\n", 141 | " \n", 142 | " self.sess = tf.Session(graph=self.graph)\n", 143 | " # Run inference on a single image\n", 144 | " def run(self, image):\n", 145 | " # Args: PIL.image object\n", 146 | " width, height = image.size\n", 147 | " resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)\n", 148 | " target_size = (int(resize_ratio * width), int(resize_ratio * height))\n", 149 | " resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)\n", 150 | " batch_seg_map = self.sess.run(\n", 151 | " self.OUTPUT_TENSOR,\n", 152 | " feed_dict={self.INPUT_TENSOR: [np.asarray(resized_image)]})\n", 153 | " seg_map = batch_seg_map[0]\n", 154 | " # Output: RGB image resized from original input image, segmentation map of resized image \n", 155 | " return resized_image, seg_map" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": null, 161 | "metadata": {}, 162 | "outputs": [], 163 | "source": [ 164 | "#Every time you run the code, a new model will be downloaded. Change the following line to a local path!\n", 165 | "model = DeepLab(download_path)\n", 166 | "cap = cv2.VideoCapture(0)\n", 167 | "final = np.zeros((1, 384, 1026, 3))\n", 168 | "while True:\n", 169 | " ret, frame = cap.read()\n", 170 | " cv2_im = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n", 171 | " pil_im = Image.fromarray(cv2_im)\n", 172 | " # model\n", 173 | " resized_im, seg_map = model.run(pil_im)\n", 174 | " # color of mask\n", 175 | " seg_image = get_dataset_colormap.label_to_color_image(\n", 176 | " seg_map, get_dataset_colormap.get_pascal_name()).astype(np.uint8)\n", 177 | " \n", 178 | " frame = np.array(pil_im)\n", 179 | " r = seg_image.shape[1] / frame.shape[1]\n", 180 | " dim = (int(frame.shape[0] * r), seg_image.shape[1])[::-1]\n", 181 | " resized = cv2.resize(frame, dim, interpolation = cv2.INTER_AREA)\n", 182 | " resized = cv2.cvtColor(resized, cv2.COLOR_RGB2BGR)\n", 183 | " color_and_mask = np.hstack((resized, seg_image))\n", 184 | " cv2.imshow('frame', color_and_mask)\n", 185 | " if cv2.waitKey(25) & 0xFF == ord('q'):\n", 186 | " cap.release()\n", 187 | " cv2.destroyAllWindows()\n", 188 | " break\n", 189 | "\n" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": null, 202 | "metadata": {}, 203 | "outputs": [], 204 | "source": [] 205 | } 206 | ], 207 | "metadata": { 208 | "kernelspec": { 209 | "display_name": "Python 3", 210 | "language": "python", 211 | "name": "python3" 212 | }, 213 | "language_info": { 214 | "codemirror_mode": { 215 | "name": "ipython", 216 | "version": 3 217 | }, 218 | "file_extension": ".py", 219 | "mimetype": "text/x-python", 220 | "name": "python", 221 | "nbconvert_exporter": "python", 222 | "pygments_lexer": "ipython3", 223 | "version": "3.6.8" 224 | } 225 | }, 226 | "nbformat": 4, 227 | "nbformat_minor": 2 228 | } 229 | --------------------------------------------------------------------------------