├── README.md ├── U-Net-Balloon.ipynb └── U-Net.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # U-Net-Demo 2 | 3 | 4 | U-Net是Kaggle比赛非常青睐的模型，简单、高效、易懂，容易定制，可以从相对较小的训练集中学习。来看几个变形： 5 | 6 | - （1）[Supervise.ly](https://supervise.ly/) 公司。 7 | 在用 Faster-RCNN（基于 NasNet）定位 + UNet-like 架构的分割，来做他们数据众包图像分割方向的主动学习，当时没有使用 Mask-RCNN，因为靠近物体边缘的分割质量很低（[终于！Supervise.ly 发布人像分割数据集啦（免费开源）](https://www.leiphone.com/news/201804/h2LP6OeEwgmGghER.html)）； 8 | 9 | - （2）Kaggle-卫星图像分割与识别。 10 | 需要分割出：房屋和楼房；混杂的人工建筑；道路；铁路；树木；农作物；河流；积水区；大型车辆；小轿车。在U-Net基础上微调了一下。 而且针对不同的图像类型，微调的地方不一样，就会有不同的分割模型，最后融合。（[Kaggle优胜者详解：如何用深度学习实现卫星图像分割与识别](https://zhuanlan.zhihu.com/p/26377387)） 11 | 12 | 13 | - （3）广东政务数据创新大赛—智能算法赛 。 14 | 国土监察业务中须监管地上建筑物的建、拆、改、扩，高分辨率图像和智能算法以自动化完成工作。并且：八通道U-Net：直接输出房屋变化，可应对高层建筑倾斜问题；数据增强：增加模型泛化性，简单有效；加权损失函数：增强对新增建筑的检测能力；模型融合：取长补短，结果更全。（参考：[LiuDongjing/BuildingChangeDetector](https://github.com/LiuDongjing/BuildingChangeDetector)） 15 | ![这里写图片描述](https://img-blog.csdn.net/20180427144549445?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70) 16 | - （4）Kaggle车辆边界识别——TernausNet。 17 | 由VGG初始化权重 + U-Net网络，Kaggle Carvana Image Masking Challenge 第一名，使用的预训练权重改进U-Net，提升图像分割的效果。开源的代码在[ternaus/TernausNet](https://github.com/ternaus/TernausNet) 18 | 19 | 当然现在还有很多流行、好用的分割网络：谷歌的DeepLabv3+（[DeepLab: Deep Labelling for 20 | Semantic Image Segmentation](https://github.com/tensorflow/models/tree/master/research/deeplab)）、[Mask R-CNN](https://github.com/matterport/Mask_RCNN/)、COCO-16 图像分割冠军的实例分割FCIS（[msracver/FCIS](https://github.com/msracver/FCIS)） 等。 21 | 22 | 23 | 24 | **跟目标检测需要准备的数据集不一样，因为图像分割是图像中实体的整个轮廓，所以标注的内容就是物体的掩膜。有两种标记方式：一种是提供单个物体的掩膜、一种是提供物体轮廓的标点。** 25 | 26 | 27 | ---------- 28 | 29 | 30 | ## 一、U-Net网络练习题一： Kaggle - 2018 Data Science Bowl 31 | 因为Kaggle有该比赛，而且code写的很简单易懂，于是乎拿来玩一下。[Keras U-Net starter - LB 0.277](https://www.kaggle.com/keegil/keras-u-net-starter-lb-0-277?scriptVersionId=2164855/notebook) 32 | 与U-Net相关的开源项目与code很多，各种框架的版本都有：[Tensorflow Unet](https://github.com/jakeret/tf_unet)、[End-to-end baseline with U-net (keras)](https://www.kaggle.com/drn01z3/end-to-end-baseline-with-u-net-keras)等等。 33 | 34 | ### 1.1 训练集的构造 35 | 36 | 因为使用的是比赛数据，赛方已经很好地帮我们做好了前期数据整理的工作，所以目前来说可能很方便的制作训练集、测试集然后跑模型。这里下载得到的数据为提供图像中单个物体的掩膜。其中，笔者认为最麻烦的就是标注集的构造（掩膜）。 37 | 38 | 原图： 39 | 40 | ![这里写图片描述](https://img-blog.csdn.net/20180427163628216?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70) 41 | 42 | 掩膜图： 43 | 44 | ![这里写图片描述](https://img-blog.csdn.net/20180427163828863?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70) 45 | 46 | 从掩膜列表可以到，比赛中是把每个细胞的掩膜都分开来了。来看一下这个掩膜标注内容如何： 47 | 48 | ``` 49 | mask = np.zeros((IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool) 50 | Y_train = np.zeros((len(train_ids), IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool) 51 | for mask_file in next(os.walk(path + '/masks/'))[2]: 52 | mask_ = imread(path + '/masks/' + mask_file) 53 | mask_ = np.expand_dims(resize(mask_, (IMG_HEIGHT, IMG_WIDTH), mode='constant', 54 | preserve_range=True), axis=-1) 55 | mask = np.maximum(mask, mask_) 56 | Y_train[n] = mask 57 | ``` 58 | 59 | - 读入（imread）掩膜图，图像的格式为：(m,n)； 60 | - resize，掩膜的尺寸缩放在128*128 61 | - np.expand_dims步骤改变图像维度为(m,n,1)； 62 | - np.maximum，当出现很多掩膜的时候，有些掩膜会重叠，那么就需要留下共有的部分； 63 | - Y_train的数据格式已经定义为bool型，那么最后存储得到的数据即为(x,m,n,1)，且数据格式为True/False： 64 | 65 | ``` 66 | array([[[[False], 67 | [False], 68 | [False], 69 | ..., 70 | [False], 71 | [False], 72 | [False]], 73 | 74 | [[False], 75 | [False], 76 | [False], 77 | ..., 78 | [False], 79 | ... 80 | ``` 81 | 其他X_train训练数据集，就会被存储成：(x,m,n,3)，同时需要resize成128*128 82 | 83 | 84 | ### 1.2 预测 85 | 86 | 预测就可以用`model.predict(X_test, verbose=1)`，即可以得到结果。那么得到的结果是(128,128,1)的，那么就是一个图层，也就是说U-Net出来的结果是单标签的，如果是多标签那么可以多套模型，可参考：Kaggle-卫星图像分割与识别。 87 | 预测出来的结果为单图层，可以重新回到原尺寸： 88 | 89 | ``` 90 | resize(np.squeeze(preds_test[i]), 91 | (sizes_test[i][0], sizes_test[i][1]), mode='constant', preserve_range=True) 92 | ``` 93 | 94 | 95 | ### 1.3 结果提交 96 | 97 | 图像分割在提交结果的时候，主要就是掩膜了。那么掩膜的提交需要编码压缩： 98 | Run-Length Encoding（RLE）行程长度的原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。例如:aaabccccccddeee，则可用3a1b6c2d3e来代替。对于拥有大面积，相同颜色区域的图像，用RLE压缩方法非常有效。由RLE原理派生出许多具体行程压缩方法。 99 | 那么图像压缩出来的结果即为： 100 | 101 | ``` 102 | '137795 3 138292 25 138802 29 139312 32 139823 34 140334 36 140845 38 141356 40 141867 42 142371 51 142881 54 143391 57 143902 59 144414 59 144925 61 145436 62 145948 63 146459 65 146970 66 147482 66 147994 66 148506 66 149017 67 149529 67 150041 67 150553 67 151065 67 151577 66 152089 66 152602 65 153114 64 153626 64 154138 63 154650 63 155162 63 155674 63 156187 62 156699 62 157212 60 157724 60 158236 60 158749 59 159261 59 159773 58 160285 58 160798 56 161310 56 161823 55 162335 54 162848 53 163361 52 163874 50 164387 49 164899 48 165412 47 165925 45 166439 42 166953 40 167466 38 167980 35 168495 31 169009 28 169522 26 170036 23 170549 21 171062 18 171577 12 172093 4' 103 | ``` 104 | 那么下图就是出来的结果了，第一张为原图，第二张为标注的掩膜图，第三张为预测图。 105 | 106 | ![这里写图片描述](https://img-blog.csdn.net/20180427181653536?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70) 107 | 108 | 109 | 110 | ---------- 111 | 112 | 113 | ## 二、U-Net网络练习题二：气球识别 114 | 在《如何使用Mask RCNN模型进行图像实体分割？》一文中提到了用Mask-RCNN来做气球分割，官网之中也有对应的代码，本着练习的态度，那么笔者就拿来这个数据集继续练手，最麻烦的仍然是如何得到标注数据。MaskRCNN的开源code为[Mask R-CNN - Inspect Balloon Training Data](https://github.com/matterport/Mask_RCNN/blob/v2.1/samples/balloon/inspect_balloon_data.ipynb) 115 | 116 | 由于很多内容是从Mask R-CNN之中挖过来的，笔者也没细究，能用就行，所以会显得很笨拙... 117 | 118 | ### 2.1 训练集的准备 119 | 数据下载页面：[balloon_dataset.zip](https://github.com/matterport/Mask_RCNN/releases/download/v2.1/balloon_dataset.zip) 120 | 该案例更为通用，因为比赛的训练集是比赛方写好的，一般实际训练的时候，掩膜都是没有给出的，而只是给出标记点，如： 121 | 122 | 123 | ![这里写图片描述](https://img-blog.csdn.net/20180427182345370?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70) 124 | 125 | 126 | ![这里写图片描述](https://img-blog.csdn.net/20180427182334487?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70) 127 | 128 | 129 | 此时的标注数据都放在json之中，譬如： 130 | 131 | ``` 132 | {'10464445726_6f1e3bbe6a_k.jpg712154': {'base64_img_data': '', 133 | 'file_attributes': {}, 134 | 'filename': '10464445726_6f1e3bbe6a_k.jpg', 135 | 'fileref': '', 136 | 'regions': {'0': {'region_attributes': {}, 137 | 'shape_attributes': {'all_points_x': [1757, 138 | 1772, 139 | 1787, 140 | 1780, 141 | 1764], 142 | 'all_points_y': [867, 143 | 913, 144 | 986, 145 | 1104, 146 | 1170], 147 | 'name': 'polygon'}}, 148 | ``` 149 | `all_points_x`以及`all_points_y`都是掩膜标记的（x，y）点坐标，每一个物体都是由很多个box构造而成： 150 | 151 | ``` 152 | def get_mask(a,dataset_dir): 153 | image_path = os.path.join(dataset_dir, a['filename']) 154 | image = io.imread(image_path) 155 | height, width = image.shape[:2] 156 | polygons = [r['shape_attributes'] for r in a['regions'].values()] 157 | mask = np.zeros([height, width, len(polygons)],dtype=np.uint8) 158 | 159 | # 掩膜mask 160 | for i, p in enumerate(polygons): 161 | # Get indexes of pixels inside the polygon and set them to 1 162 | rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x']) 163 | mask[rr, cc, i] = 1 164 | # 此时mask为(685, 1024, 1) 165 | 166 | # mask二值化 167 | mask, class_ids = mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32) 168 | 169 | # 提取每个掩膜的坐标 170 | boxes = extract_bboxes(resize(mask, (128, 128), mode='constant',preserve_range=True)) 171 | 172 | unique_class_ids = np.unique(class_ids) 173 | mask_area = [np.sum(mask[:, :, np.where(class_ids == i)[0]]) 174 | for i in unique_class_ids] 175 | top_ids = [v[0] for v in sorted(zip(unique_class_ids, mask_area), 176 | key=lambda r: r[1], reverse=True) if v[1] > 0] 177 | 178 | class_id = top_ids[0] 179 | # Pull masks of instances belonging to the same class. 180 | m = mask[:, :, np.where(class_ids == class_id)[0]] 181 | m = np.sum(m * np.arange(1, m.shape[-1] + 1), -1) 182 | 183 | return m,image,height,width,class_ids,boxes 184 | ``` 185 | 186 | - polygon之中记录的是一个掩膜的(x，y)点坐标，然后通过`skimage.draw.polygon`连成圈； 187 | - `mask[rr, cc, i] = 1`这句中，mask变成了一个0/1的(m,n,x)的矩阵,x代表可能有x个物体； 188 | - mask.astype(np.bool)将上述的0/1矩阵，变为T/F矩阵； 189 | - extract_bboxes()函数，要着重说，因为他是根据掩膜的位置，找出整体掩膜的坐标点，给入5个物体，他就会返回5个物体的坐标`（xmax,ymax,xmin,ymin）` 190 | - np.sum()是降维的过程，把(m,n,1)到(m,n) 191 | 192 | 那么，最终 Y_train的数据格式如案例一，一样的： 193 | ``` 194 | array([[[[False], 195 | [False], 196 | [False], 197 | ..., 198 | [False], 199 | [False], 200 | [False]], 201 | 202 | [[False], 203 | [False], 204 | [False], 205 | ..., 206 | [False], 207 | ... 208 | ``` 209 | ### 2.2 模型预测 210 | 211 | ``` 212 | model = load_model(model_name, custom_objects={'mean_iou': mean_iou}) 213 | preds_train = model.predict(X_train[:int(X_train.shape[0]*0.9)], verbose=1) 214 | preds_val = model.predict(X_train[int(X_train.shape[0]*0.9):],verbose=1) 215 | preds_test = model.predict(X_test,verbose=1) 216 | ``` 217 | 218 | 这边的操作是把trainset按照9:1，分为训练集、验证集，还有一部分是测试集 219 | 220 | 输入维度: 221 | 222 | ``` 223 | X_train (670, 128, 128, 3) 224 | Y_train (670, 128, 128, 1) 225 | X_test (65, 128, 128, 3) 226 | ``` 227 | 228 | 输出维度: 229 | 每个像素点的概率[0,1] 230 | 231 | ``` 232 | preds_train (603, 128, 128, 1) 233 | preds_val (67, 128, 128, 1) 234 | preds_test (65, 128, 128, 1) 235 | ``` 236 | 237 | ### 2.3 画图函数 238 | 该部分是从MaskRCNN中搬过来的， 239 | 240 | ``` 241 | def display_instances(image, boxes, masks, class_names, 242 | scores=None, title="", 243 | figsize=(16, 16), ax=None, 244 | show_mask=True, show_bbox=True, 245 | colors=None, captions=None): 246 | ``` 247 | 需要图像矩阵image，boxes代表每个实例的boxes，masks是图像的掩膜，class_names，是每张图标签的名称。下图是128*128像素的，很模糊，将就着看吧... 248 | 249 | ![这里写图片描述](https://img-blog.csdn.net/20180427224140215?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzI2OTE3Mzgz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70) 250 | 251 | 252 | 随机颜色生成函数random_colors 253 | 254 | ``` 255 | def random_colors(N, bright=True): 256 | """ 257 | Generate random colors. 258 | To get visually distinct colors, generate them in HSV space then 259 | convert to RGB. 260 | """ 261 | brightness = 1.0 if bright else 0.7 262 | hsv = [(i / N, 1, brightness) for i in range(N)] 263 | colors = list(map(lambda c: colorsys.hsv_to_rgb(*c), hsv)) 264 | random.shuffle(colors) 265 | return colors 266 | ``` 267 | 268 | 还有就是一般来说，掩膜如果是(m,n)，或者让是(m,n,1)都是可以画出来的。 269 | 270 | ``` 271 | imshow(mask) 272 | plt.show() 273 | ``` 274 | 275 | -------------------------------------------------------------------------------- /U-Net.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# U-Net图像分割\n", 8 | "\n", 9 | "code来源：\n", 10 | "https://www.kaggle.com/keegil/keras-u-net-starter-lb-0-277?scriptVersionId=2164855/notebook\n", 11 | "\n", 12 | "数据来源code：\n", 13 | "https://github.com/kamalkraj/DATA-SCIENCE-BOWL-2018/blob/master/Data_Science_Bowl_2018.ipynb" 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": null, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "# Data download and unzipping\n", 23 | "!wget https://raw.githubusercontent.com/AakashSudhakar/2018-data-science-bowl/master/compressed_files/stage1_test.zip -c\n", 24 | "!wget https://raw.githubusercontent.com/AakashSudhakar/2018-data-science-bowl/master/compressed_files/stage1_train.zip -c\n", 25 | "\n", 26 | "!mkdir stage1_train stage1_test\n", 27 | "!unzip stage1_train.zip -d stage1_train/\n", 28 | "!unzip stage1_test.zip -d stage1_test/" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 1, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "name": "stderr", 38 | "output_type": "stream", 39 | "text": [ 40 | "Using TensorFlow backend.\n" 41 | ] 42 | } 43 | ], 44 | "source": [ 45 | "import os\n", 46 | "import sys\n", 47 | "import random\n", 48 | "import warnings\n", 49 | "\n", 50 | "# 需要指定一下数据目录\n", 51 | "sys.path.append('/mnt/unet/')\n", 52 | "\n", 53 | "import numpy as np\n", 54 | "import pandas as pd\n", 55 | "\n", 56 | "import matplotlib.pyplot as plt\n", 57 | "\n", 58 | "\n", 59 | "import tensorflow as tf\n", 60 | "from keras.backend.tensorflow_backend import set_session\n", 61 | "config = tf.ConfigProto()\n", 62 | "config.gpu_options.per_process_gpu_memory_fraction = 0.4\n", 63 | "set_session(tf.Session(config=config))\n", 64 | "\n", 65 | "from tqdm import tqdm\n", 66 | "from itertools import chain\n", 67 | "from skimage.io import imread, imshow, imread_collection, concatenate_images\n", 68 | "from skimage.transform import resize\n", 69 | "from skimage.morphology import label\n", 70 | "\n", 71 | "from keras.models import Model, load_model\n", 72 | "from keras.layers import Input\n", 73 | "from keras.layers.core import Lambda\n", 74 | "from keras.layers.convolutional import Conv2D, Conv2DTranspose\n", 75 | "from keras.layers.pooling import MaxPooling2D\n", 76 | "from keras.layers.merge import concatenate\n", 77 | "from keras.callbacks import EarlyStopping, ModelCheckpoint\n", 78 | "from keras import backend as K\n", 79 | "\n", 80 | "# Set some parameters\n", 81 | "IMG_WIDTH = 128\n", 82 | "IMG_HEIGHT = 128\n", 83 | "IMG_CHANNELS = 3\n", 84 | "TRAIN_PATH = './stage1_train/'\n", 85 | "TEST_PATH = './stage1_test/'\n", 86 | "\n", 87 | "warnings.filterwarnings('ignore', category=UserWarning, module='skimage')\n", 88 | "seed = 42\n", 89 | "random.seed = seed\n", 90 | "np.random.seed = seed\n", 91 | "\n", 92 | "# Get train and test IDs\n", 93 | "train_ids = next(os.walk(TRAIN_PATH))[1] # 670\n", 94 | "test_ids = next(os.walk(TEST_PATH))[1] # 65" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "## Get the data\n", 102 | "Let's first import all the images and associated masks. I downsample both the training and test images to keep things light and manageable, but we need to keep a record of the original sizes of the test images to upsample our predicted masks and create correct run-length encodings later on. There are definitely better ways to handle this, but it works fine for now!\n" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 8, 108 | "metadata": {}, 109 | "outputs": [ 110 | { 111 | "name": "stdout", 112 | "output_type": "stream", 113 | "text": [ 114 | "Getting and resizing train images and masks ... \n" 115 | ] 116 | }, 117 | { 118 | "name": "stderr", 119 | "output_type": "stream", 120 | "text": [ 121 | "100%|██████████| 670/670 [01:16<00:00, 8.74it/s]" 122 | ] 123 | }, 124 | { 125 | "name": "stdout", 126 | "output_type": "stream", 127 | "text": [ 128 | "Getting and resizing test images ... \n" 129 | ] 130 | }, 131 | { 132 | "name": "stderr", 133 | "output_type": "stream", 134 | "text": [ 135 | "\n", 136 | "100%|██████████| 65/65 [00:00<00:00, 100.11it/s]" 137 | ] 138 | }, 139 | { 140 | "name": "stdout", 141 | "output_type": "stream", 142 | "text": [ 143 | "Data Generate Done!\n" 144 | ] 145 | }, 146 | { 147 | "name": "stderr", 148 | "output_type": "stream", 149 | "text": [ 150 | "\n" 151 | ] 152 | } 153 | ], 154 | "source": [ 155 | "def data_generator(train_ids,test_ids):\n", 156 | " # Get and resize train images and masks\n", 157 | " X_train = np.zeros((len(train_ids), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)\n", 158 | " Y_train = np.zeros((len(train_ids), IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool)\n", 159 | " print('Getting and resizing train images and masks ... ')\n", 160 | " sys.stdout.flush()\n", 161 | " for n, id_ in tqdm(enumerate(train_ids), total=len(train_ids)):\n", 162 | " path = TRAIN_PATH + id_\n", 163 | " img = imread(path + '/images/' + id_ + '.png')[:,:,:IMG_CHANNELS]\n", 164 | " img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True) # resize成128*128\n", 165 | " X_train[n] = img\n", 166 | " mask = np.zeros((IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool)\n", 167 | " for mask_file in next(os.walk(path + '/masks/'))[2]:\n", 168 | " mask_ = imread(path + '/masks/' + mask_file)\n", 169 | " mask_ = np.expand_dims(resize(mask_, (IMG_HEIGHT, IMG_WIDTH), mode='constant', \n", 170 | " preserve_range=True), axis=-1)\n", 171 | " mask = np.maximum(mask, mask_)\n", 172 | " Y_train[n] = mask\n", 173 | "\n", 174 | " # Get and resize test images\n", 175 | " X_test = np.zeros((len(test_ids), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS), dtype=np.uint8)\n", 176 | " sizes_test = []\n", 177 | " print('Getting and resizing test images ... ')\n", 178 | " sys.stdout.flush()\n", 179 | " for n, id_ in tqdm(enumerate(test_ids), total=len(test_ids)):\n", 180 | " path = TEST_PATH + id_\n", 181 | " img = imread(path + '/images/' + id_ + '.png')[:,:,:IMG_CHANNELS]\n", 182 | " sizes_test.append([img.shape[0], img.shape[1]])\n", 183 | " img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True)\n", 184 | " X_test[n] = img\n", 185 | "\n", 186 | " print('Data Generate Done!')\n", 187 | " return X_train,Y_train,X_test,sizes_test\n", 188 | "\n", 189 | "X_train,Y_train,X_test,sizes_test = data_generator(train_ids,test_ids)\n", 190 | "# X_train (670, 128, 128, 3)\n", 191 | "# Y_train (670, 128, 128, 1)\n", 192 | "# X_test (65, 128, 128, 3)\n", 193 | "# sizes_test (65,2)" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 5, 199 | "metadata": {}, 200 | "outputs": [ 201 | { 202 | "data": { 203 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUEAAAEYCAYAAADCj0QOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nFAAAAABJRU5ErkJggg==\n", 204 | "text/plain": [ 205 | "" 206 | ] 207 | }, 208 | "metadata": {}, 209 | "output_type": "display_data" 210 | }, 211 | { 212 | "data": { 213 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAEYCAYAAAATaEB+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAADvNJREFUeJzt3X+s3XV9x/Hna63oxMwWXZraslFj\no2FmDtIYiP5BRCMwIywhBmNi50iaJW7ij0Rh/mH238yMiolja0RlC0EZstGQTccqi/vHzls1CFSk\nkyFtCsWouGiy2PneH+d757W03ttz7rnvc0+fj+TmnO+vc973097X/Xw/3++5n1QVktTl17oLkHR2\nM4QktTKEJLUyhCS1MoQktTKEJLUyhCS1mloIJbkiySNJDie5cVrvI2l9yzRuVkyyAfgO8AbgCPA1\n4K1V9fCqv5mkdW3jlF731cDhqvouQJLPAVcDpwyhJN62Lc2f71fVby6307ROx7YBTyxZPjKs+39J\n9iRZSLIwpRok9Xp8JTtNqye0rKraC+wFe0LS2WxaPaGjwPlLlrcP6yTpl0wrhL4G7EyyI8k5wHXA\nvim9l6R1bCqnY1V1IsmfAF8CNgCfrqqHpvFekta3qVyiP+MiHBOS5tHBqtq13E7eMS2plSEkqZUh\nJKmVISSplSEkqZUhJKmVISSplSEkqZUhJKmVISSplSEkqZUhJKmVISSplSEkqZUhJKmVISSplSEk\nqZUhJKmVISSplSEkqZUhJKmVISSplSEkqZUhJKmVISSplSEkqdVU5qI/W6x0Cu0kU65EWr/sCUlq\nZQitgapaca9JOtuMHUJJzk9yf5KHkzyU5IZh/XlJ7kvy6PC4efXKlTRvJukJnQDeV1UXApcA70xy\nIXAjsL+qdgL7h+W5Ys9GWj1jh1BVHauqrw/P/xs4BGwDrgZuG3a7Dbhm0iLnxXoNr8W6T/76VdvW\n6/eqtbcqV8eSXABcBBwAtlTVsWHTk8CW0xyzB9izGu8vaf2aeGA6yQuALwDvrqofL91Wo1+Fp/x1\nWFV7q2pXVe2atAb1WElPxx6RljNRCCV5DqMAur2q7h5WP5Vk67B9K3B8shIlzbNJro4FuBU4VFUf\nXbJpH7B7eL4buGf88iTNu4zbVU7yWuDfgW8BPx9W/xmjcaE7gd8CHgfeUlU/WOa11lV/fdLTi/V2\nB/VqnE6tt+9Zq+LgSoZbxg6h1WQIzTZDSGNaUQh5x7SkVobQGJKcVb/Zz7bvV2vLEJLUyhDSitkj\n0jQYQpJa+UfNJrDYKzjb/rjZmXzf8/I9a3rsCUlqZU9oFfjb3jbQ+OwJSWplT0hjs/ej1WBPSFIr\nQ0hSK0NIUitDSFIrQ0hSK0NIUitDSFIrQ0hSK0NIUitDSFIrQ0hSK0NIUitDSFIrQ0hSK0NIUitD\nSFIrQ0hSK0NIUitDSFIrQ0hSq4lDKMmGJN9Icu+wvCPJgSSHk3w+yTmTlylpXq1GT+gG4NCS5Q8D\nH6uqlwE/BK5fhfeQNKcmCqEk24HfBz41LAd4HXDXsMttwDWTvIek+TZpT+jjwPuBnw/LLwJ+VFUn\nhuUjwLZTHZhkT5KFJAsT1iBpHRs7hJK8CTheVQfHOb6q9lbVrqraNW4Nkta/SWZgfQ3w5iRXAc8D\nfgO4GdiUZOPQG9oOHJ28TEnzauyeUFXdVFXbq+oC4Drgy1X1NuB+4Npht93APRNXKWluTeM+oQ8A\n701ymNEY0a1TeA9JcyJV1V0DSfqLkLTaDq5kzNc7piW1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1\nMoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUy\nhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktZoohJJsSnJXkm8nOZTk0iTnJbkvyaPD4+bV\nKlbS/Jm0J3Qz8MWqegXwKuAQcCOwv6p2AvuHZUk6pVTVeAcmLwS+Cby0lrxIkkeAy6rqWJKtwL9V\n1cuXea3xipA0yw5W1a7ldpqkJ7QDeBr4TJJvJPlUknOBLVV1bNjnSWDLqQ5OsifJQpKFCWqQtM5N\nEkIbgYuBW6rqIuAnnHTqNfSQTtnLqaq9VbVrJUkpaX5NEkJHgCNVdWBYvotRKD01nIYxPB6frERJ\n82zsEKqqJ4EnkiyO91wOPAzsA3YP63YD90xUoaS5tnHC4/8UuD3JOcB3gXcwCrY7k1wPPA68ZcL3\nkDTHxr46tqpFeHVMmkdTvzomSRMzhCS1MoQktTKEJLUyhCS1mvQSvaR1bKVXx5NMrQZ7QpJa2ROS\nzkKzcH/gIntCkloZQpKWNc2ekyEkqZVjQtJZZJbGghbZE5LUyhCStCzvE5I0twwhSa0MIUmtDCFJ\nrbxEL51FFgeYZ+GDq4vsCUlqZU9IOgutRQ9npewJSWplCElqZQhJamUISWplCElqZQhJamUISWpl\nCElqNVEIJXlPkoeSPJjkjiTPS7IjyYEkh5N8Psk5q1WspPkzdggl2Qa8C9hVVa8ENgDXAR8GPlZV\nLwN+CFy/GoVKmk+Tno5tBH49yUbg+cAx4HXAXcP224BrJnwPSXNs7BCqqqPAR4DvMQqfZ4CDwI+q\n6sSw2xFg26RFSppfk5yObQauBnYALwHOBa44g+P3JFlIsjBuDZLWv0k+Rf964LGqehogyd3Aa4BN\nSTYOvaHtwNFTHVxVe4G9w7GzNw+JpDUxyZjQ94BLkjw/o78LcDnwMHA/cO2wz27gnslKlDTPJhkT\nOsBoAPrrwLeG19oLfAB4b5LDwIuAW1ehTklzKrMwI6OnY9JcOlhVu5bbyTumJbUyhCS1MoQktTKE\nJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQk\ntTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktVo2hJJ8Osnx\nJA8uWXdekvuSPDo8bh7WJ8knkhxO8kCSi6dZvKT1byU9oc8CV5y07kZgf1XtBPYPywBXAjuHrz3A\nLatTpqR5tWwIVdVXgB+ctPpq4Lbh+W3ANUvW/22NfBXYlGTrahUraf6MOya0paqODc+fBLYMz7cB\nTyzZ78iw7lmS7EmykGRhzBokzYGNk75AVVWSGuO4vcBegHGOlzQfxu0JPbV4mjU8Hh/WHwXOX7Lf\n9mGdJJ3SuCG0D9g9PN8N3LNk/duHq2SXAM8sOW2TpGdZ9nQsyR3AZcCLkxwBPgT8BXBnkuuBx4G3\nDLv/E3AVcBj4KfCOKdQsaY6kqn84xjEhaS4drKpdy+3kHdOSWhlCkloZQpJaGUKSWhlCkloZQpJa\nGUKSWhlCkloZQpJaGUKSWhlCkloZQpJaGUKSWhlCkloZQpJaGUKSWhlCkloZQpJaGUKSWhlCkloZ\nQpJaGUKSWhlCkloZQpJaGUKSWhlCkloZQpJaGUKSWhlCklotG0JJPp3keJIHl6z7yyTfTvJAkn9I\nsmnJtpuSHE7ySJI3TqtwSfNhJT2hzwJXnLTuPuCVVfW7wHeAmwCSXAhcB/zOcMxfJdmwatVKmjvL\nhlBVfQX4wUnr/qWqTgyLXwW2D8+vBj5XVf9TVY8Bh4FXr2K9kubMaowJ/RHwz8PzbcATS7YdGdY9\nS5I9SRaSLKxCDZLWqY2THJzkg8AJ4PYzPbaq9gJ7h9epSeqQtH6NHUJJ/hB4E3B5VS2GyFHg/CW7\nbR/WSdIpjXU6luQK4P3Am6vqp0s27QOuS/LcJDuAncB/TF6mpHm1bE8oyR3AZcCLkxwBPsToathz\ngfuSAHy1qv64qh5KcifwMKPTtHdW1f9Oq3hJ619+cSbVWIRjQtI8OlhVu5bbyTumJbUyhCS1MoQk\ntTKEJLUyhCS1MoQktTKEJLUyhCS1MoQktZroU/Sr6PvAT4bHWfRiZrM26zpzs1rbrNYF49f22yvZ\naSY+tgGQZGElt3h3mNXarOvMzWpts1oXTL82T8cktTKEJLWapRDa213ArzCrtVnXmZvV2ma1Lphy\nbTMzJiTp7DRLPSFJZyFDSFKrmQihJFcMM7YeTnJjYx3nJ7k/ycNJHkpyw7D+vCT3JXl0eNzcVN+G\nJN9Icu+wvCPJgaHdPp/knKa6NiW5a5iV91CSS2ehzZK8Z/h3fDDJHUme19Vmp5nJ+JRtlJFPDDU+\nkOTiNa5rTWdYbg+hYYbWTwJXAhcCbx1mcu1wAnhfVV0IXAK8c6jlRmB/Ve0E9g/LHW4ADi1Z/jDw\nsap6GfBD4PqWquBm4ItV9QrgVYxqbG2zJNuAdwG7quqVwAZGswN3tdlnefZMxqdroysZTRKxE9gD\n3LLGda3tDMtV1foFXAp8acnyTcBN3XUNtdwDvAF4BNg6rNsKPNJQy3ZG/1FfB9wLhNFdrBtP1Y5r\nWNcLgccYLnIsWd/aZvxiIs7zGH0y4F7gjZ1tBlwAPLhcGwF/A7z1VPutRV0nbfsD4Pbh+S/9bAJf\nAi6d9P3be0KcwaytaynJBcBFwAFgS1UdGzY9CWxpKOnjjKZZ+vmw/CLgR/WL6bi72m0H8DTwmeFU\n8VNJzqW5zarqKPAR4HvAMeAZ4CCz0WaLTtdGs/QzMdYMy2diFkJo5iR5AfAF4N1V9eOl22r0K2BN\n72tI8ibgeFUdXMv3XaGNwMXALVV1EaPPAP7SqVdTm20GrmYUki8BzuXZpx0zo6ONljPJDMtnYhZC\naKZmbU3yHEYBdHtV3T2sfirJ1mH7VuD4Gpf1GuDNSf4L+ByjU7KbgU1JFj+E3NVuR4AjVXVgWL6L\nUSh1t9nrgceq6umq+hlwN6N2nIU2W3S6Nmr/mVgyw/LbhoCcWl2zEEJfA3YOVy3OYTTwta+jkIxm\ncrwVOFRVH12yaR+we3i+m9FY0ZqpqpuqantVXcCofb5cVW8D7geu7aprqO1J4IkkLx9WXc5o8svW\nNmN0GnZJkucP/66LdbW32RKna6N9wNuHq2SXAM8sOW2bujWfYXmtBuWWGRi7itEo/H8CH2ys47WM\nusQPAN8cvq5iNP6yH3gU+FfgvMYaLwPuHZ6/dPhPcBj4e+C5TTX9HrAwtNs/Aptnoc2APwe+DTwI\n/B2jWYNb2gy4g9HY1M8Y9R6vP10bMbro8Mnh5+FbjK7wrWVdhxmN/Sz+DPz1kv0/ONT1CHDlatTg\nxzYktZqF0zFJZzFDSFIrQ0hSK0NIUitDSFIrQ0hSK0NIUqv/A5BmdE67EzhOAAAAAElFTkSuQmCC\n", 214 | "text/plain": [ 215 | "" 216 | ] 217 | }, 218 | "metadata": {}, 219 | "output_type": "display_data" 220 | } 221 | ], 222 | "source": [ 223 | "# Check if training data looks all right\n", 224 | "# 查看数据是否正确\n", 225 | "ix = random.randint(0, len(train_ids))\n", 226 | "imshow(X_train[ix])\n", 227 | "plt.show()\n", 228 | "imshow(np.squeeze(Y_train[ix]))\n", 229 | "plt.show()" 230 | ] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": {}, 235 | "source": [ 236 | "## Create our Keras metric\n", 237 | "Now we try to define the mean average precision at different intersection over union (IoU) thresholds metric in Keras. TensorFlow has a mean IoU metric, but it doesn't have any native support for the mean over multiple thresholds, so I tried to implement this. I'm by no means certain that this implementation is correct, though! Any assistance in verifying this would be most welcome!\n", 238 | "\n", 239 | "Update: This implementation is most definitely not correct due to the very large discrepancy between the results reported here and the LB results. It also seems to just increase over time no matter what when you train ..." 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 5, 245 | "metadata": {}, 246 | "outputs": [], 247 | "source": [ 248 | "# Define IoU metric\n", 249 | "def mean_iou(y_true, y_pred):\n", 250 | " prec = []\n", 251 | " for t in np.arange(0.5, 1.0, 0.05):\n", 252 | " y_pred_ = tf.to_int32(y_pred > t)\n", 253 | " score, up_opt = tf.metrics.mean_iou(y_true, y_pred_, 2)\n", 254 | " K.get_session().run(tf.local_variables_initializer())\n", 255 | " with tf.control_dependencies([up_opt]):\n", 256 | " score = tf.identity(score)\n", 257 | " prec.append(score)\n", 258 | " return K.mean(K.stack(prec), axis=0)" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "## Build and train our neural network\n", 266 | "\n", 267 | "Next we build our U-Net model, loosely based on U-Net: Convolutional Networks for Biomedical Image Segmentation and very similar to this repo from the Kaggle Ultrasound Nerve Segmentation competition.\n", 268 | "\n", 269 | "![模型结构图](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/u-net-architecture.png)\n", 270 | "\n" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": 6, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [ 279 | "def UNetModel(IMG_HEIGHT,IMG_WIDTH,IMG_CHANNELS):\n", 280 | " inputs = Input((IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS))\n", 281 | " s = Lambda(lambda x: x / 255) (inputs)\n", 282 | "\n", 283 | " c1 = Conv2D(8, (3, 3), activation='relu', padding='same') (s)\n", 284 | " c1 = Conv2D(8, (3, 3), activation='relu', padding='same') (c1)\n", 285 | " p1 = MaxPooling2D((2, 2)) (c1)\n", 286 | "\n", 287 | " c2 = Conv2D(16, (3, 3), activation='relu', padding='same') (p1)\n", 288 | " c2 = Conv2D(16, (3, 3), activation='relu', padding='same') (c2)\n", 289 | " p2 = MaxPooling2D((2, 2)) (c2)\n", 290 | "\n", 291 | " c3 = Conv2D(32, (3, 3), activation='relu', padding='same') (p2)\n", 292 | " c3 = Conv2D(32, (3, 3), activation='relu', padding='same') (c3)\n", 293 | " p3 = MaxPooling2D((2, 2)) (c3)\n", 294 | "\n", 295 | " c4 = Conv2D(64, (3, 3), activation='relu', padding='same') (p3)\n", 296 | " c4 = Conv2D(64, (3, 3), activation='relu', padding='same') (c4)\n", 297 | " p4 = MaxPooling2D(pool_size=(2, 2)) (c4)\n", 298 | "\n", 299 | " c5 = Conv2D(128, (3, 3), activation='relu', padding='same') (p4)\n", 300 | " c5 = Conv2D(128, (3, 3), activation='relu', padding='same') (c5)\n", 301 | "\n", 302 | " u6 = Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same') (c5)\n", 303 | " u6 = concatenate([u6, c4])\n", 304 | " c6 = Conv2D(64, (3, 3), activation='relu', padding='same') (u6)\n", 305 | " c6 = Conv2D(64, (3, 3), activation='relu', padding='same') (c6)\n", 306 | "\n", 307 | " u7 = Conv2DTranspose(32, (2, 2), strides=(2, 2), padding='same') (c6)\n", 308 | " u7 = concatenate([u7, c3])\n", 309 | " c7 = Conv2D(32, (3, 3), activation='relu', padding='same') (u7)\n", 310 | " c7 = Conv2D(32, (3, 3), activation='relu', padding='same') (c7)\n", 311 | "\n", 312 | " u8 = Conv2DTranspose(16, (2, 2), strides=(2, 2), padding='same') (c7)\n", 313 | " u8 = concatenate([u8, c2])\n", 314 | " c8 = Conv2D(16, (3, 3), activation='relu', padding='same') (u8)\n", 315 | " c8 = Conv2D(16, (3, 3), activation='relu', padding='same') (c8)\n", 316 | "\n", 317 | " u9 = Conv2DTranspose(8, (2, 2), strides=(2, 2), padding='same') (c8)\n", 318 | " u9 = concatenate([u9, c1], axis=3)\n", 319 | " c9 = Conv2D(8, (3, 3), activation='relu', padding='same') (u9)\n", 320 | " c9 = Conv2D(8, (3, 3), activation='relu', padding='same') (c9)\n", 321 | "\n", 322 | " outputs = Conv2D(1, (1, 1), activation='sigmoid') (c9)\n", 323 | "\n", 324 | " model = Model(inputs=[inputs], outputs=[outputs])\n", 325 | " model.compile(optimizer='adam', loss='binary_crossentropy', metrics=[mean_iou])\n", 326 | " return model\n", 327 | "\n", 328 | "model = UNetModel(IMG_HEIGHT,IMG_WIDTH,IMG_CHANNELS)" 329 | ] 330 | }, 331 | { 332 | "cell_type": "markdown", 333 | "metadata": {}, 334 | "source": [ 335 | "## Fit model\n", 336 | "\n", 337 | "I'll just train for 10 epochs, which takes around 10 minutes in the Kaggle kernel with the current parameters.\n", 338 | "\n", 339 | "Update: Added early stopping and checkpointing and increased to 30 epochs.\n", 340 | "\n", 341 | "ou should easily be able to stabilize and improve the results just by changing a few parameters, tweaking the architecture a little bit and training longer with early stopping." 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 8, 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "name": "stdout", 351 | "output_type": "stream", 352 | "text": [ 353 | "Train on 603 samples, validate on 67 samples\n", 354 | "Epoch 1/30\n", 355 | "600/603 [============================>.] - ETA: 0s - loss: 0.5000 - mean_iou: 0.4169Epoch 00001: val_loss improved from inf to 0.39077, saving model to model-dsbowl2018-1.h5\n", 356 | "603/603 [==============================] - 6s 9ms/step - loss: 0.4996 - mean_iou: 0.4169 - val_loss: 0.3908 - val_mean_iou: 0.4232\n", 357 | "Epoch 2/30\n", 358 | "600/603 [============================>.] - ETA: 0s - loss: 0.3269 - mean_iou: 0.4247Epoch 00002: val_loss improved from 0.39077 to 0.24166, saving model to model-dsbowl2018-1.h5\n", 359 | "603/603 [==============================] - 3s 5ms/step - loss: 0.3260 - mean_iou: 0.4247 - val_loss: 0.2417 - val_mean_iou: 0.4361\n", 360 | "Epoch 3/30\n", 361 | "592/603 [============================>.] - ETA: 0s - loss: 0.1859 - mean_iou: 0.4758Epoch 00003: val_loss improved from 0.24166 to 0.15848, saving model to model-dsbowl2018-1.h5\n", 362 | "603/603 [==============================] - 3s 5ms/step - loss: 0.1856 - mean_iou: 0.4765 - val_loss: 0.1585 - val_mean_iou: 0.5148\n", 363 | "Epoch 4/30\n", 364 | "600/603 [============================>.] - ETA: 0s - loss: 0.1387 - mean_iou: 0.5452Epoch 00004: val_loss improved from 0.15848 to 0.15135, saving model to model-dsbowl2018-1.h5\n", 365 | "603/603 [==============================] - 3s 5ms/step - loss: 0.1384 - mean_iou: 0.5454 - val_loss: 0.1513 - val_mean_iou: 0.5742\n", 366 | "Epoch 5/30\n", 367 | "600/603 [============================>.] - ETA: 0s - loss: 0.1201 - mean_iou: 0.5971Epoch 00005: val_loss improved from 0.15135 to 0.12357, saving model to model-dsbowl2018-1.h5\n", 368 | "603/603 [==============================] - 3s 5ms/step - loss: 0.1200 - mean_iou: 0.5971 - val_loss: 0.1236 - val_mean_iou: 0.6175\n", 369 | "Epoch 6/30\n", 370 | "600/603 [============================>.] - ETA: 0s - loss: 0.1133 - mean_iou: 0.6338Epoch 00006: val_loss did not improve\n", 371 | "603/603 [==============================] - 3s 5ms/step - loss: 0.1130 - mean_iou: 0.6339 - val_loss: 0.1280 - val_mean_iou: 0.6477\n", 372 | "Epoch 7/30\n", 373 | "600/603 [============================>.] - ETA: 0s - loss: 0.1074 - mean_iou: 0.6593Epoch 00007: val_loss did not improve\n", 374 | "603/603 [==============================] - 3s 5ms/step - loss: 0.1072 - mean_iou: 0.6594 - val_loss: 0.1258 - val_mean_iou: 0.6702\n", 375 | "Epoch 8/30\n", 376 | "600/603 [============================>.] - ETA: 0s - loss: 0.1071 - mean_iou: 0.6795Epoch 00008: val_loss improved from 0.12357 to 0.11764, saving model to model-dsbowl2018-1.h5\n", 377 | "603/603 [==============================] - 3s 5ms/step - loss: 0.1067 - mean_iou: 0.6795 - val_loss: 0.1176 - val_mean_iou: 0.6873\n", 378 | "Epoch 9/30\n", 379 | "592/603 [============================>.] - ETA: 0s - loss: 0.0975 - mean_iou: 0.6946Epoch 00009: val_loss improved from 0.11764 to 0.10682, saving model to model-dsbowl2018-1.h5\n", 380 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0975 - mean_iou: 0.6948 - val_loss: 0.1068 - val_mean_iou: 0.7022\n", 381 | "Epoch 10/30\n", 382 | "600/603 [============================>.] - ETA: 0s - loss: 0.0960 - mean_iou: 0.7082Epoch 00010: val_loss improved from 0.10682 to 0.10215, saving model to model-dsbowl2018-1.h5\n", 383 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0967 - mean_iou: 0.7083 - val_loss: 0.1021 - val_mean_iou: 0.7137\n", 384 | "Epoch 11/30\n", 385 | "600/603 [============================>.] - ETA: 0s - loss: 0.0908 - mean_iou: 0.7189Epoch 00011: val_loss improved from 0.10215 to 0.10012, saving model to model-dsbowl2018-1.h5\n", 386 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0904 - mean_iou: 0.7189 - val_loss: 0.1001 - val_mean_iou: 0.7242\n", 387 | "Epoch 12/30\n", 388 | "600/603 [============================>.] - ETA: 0s - loss: 0.0895 - mean_iou: 0.7289Epoch 00012: val_loss did not improve\n", 389 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0894 - mean_iou: 0.7289 - val_loss: 0.1001 - val_mean_iou: 0.7334\n", 390 | "Epoch 13/30\n", 391 | "600/603 [============================>.] - ETA: 0s - loss: 0.0877 - mean_iou: 0.7375Epoch 00013: val_loss improved from 0.10012 to 0.09696, saving model to model-dsbowl2018-1.h5\n", 392 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0879 - mean_iou: 0.7375 - val_loss: 0.0970 - val_mean_iou: 0.7413\n", 393 | "Epoch 14/30\n", 394 | "600/603 [============================>.] - ETA: 0s - loss: 0.0860 - mean_iou: 0.7449Epoch 00014: val_loss did not improve\n", 395 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0862 - mean_iou: 0.7449 - val_loss: 0.0990 - val_mean_iou: 0.7482\n", 396 | "Epoch 15/30\n", 397 | "600/603 [============================>.] - ETA: 0s - loss: 0.0847 - mean_iou: 0.7516Epoch 00015: val_loss improved from 0.09696 to 0.08973, saving model to model-dsbowl2018-1.h5\n", 398 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0844 - mean_iou: 0.7516 - val_loss: 0.0897 - val_mean_iou: 0.7545\n", 399 | "Epoch 16/30\n", 400 | "600/603 [============================>.] - ETA: 0s - loss: 0.0809 - mean_iou: 0.7573Epoch 00016: val_loss did not improve\n", 401 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0808 - mean_iou: 0.7573 - val_loss: 0.0929 - val_mean_iou: 0.7601\n", 402 | "Epoch 17/30\n", 403 | "600/603 [============================>.] - ETA: 0s - loss: 0.0833 - mean_iou: 0.7626Epoch 00017: val_loss did not improve\n", 404 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0832 - mean_iou: 0.7627 - val_loss: 0.0953 - val_mean_iou: 0.7649\n", 405 | "Epoch 18/30\n", 406 | "592/603 [============================>.] - ETA: 0s - loss: 0.0777 - mean_iou: 0.7672Epoch 00018: val_loss improved from 0.08973 to 0.08723, saving model to model-dsbowl2018-1.h5\n", 407 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0783 - mean_iou: 0.7673 - val_loss: 0.0872 - val_mean_iou: 0.7695\n", 408 | "Epoch 19/30\n", 409 | "600/603 [============================>.] - ETA: 0s - loss: 0.0789 - mean_iou: 0.7715Epoch 00019: val_loss did not improve\n", 410 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0790 - mean_iou: 0.7716 - val_loss: 0.0910 - val_mean_iou: 0.7736\n", 411 | "Epoch 20/30\n", 412 | "600/603 [============================>.] - ETA: 0s - loss: 0.0780 - mean_iou: 0.7756Epoch 00020: val_loss did not improve\n", 413 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0778 - mean_iou: 0.7756 - val_loss: 0.0875 - val_mean_iou: 0.7775\n", 414 | "Epoch 21/30\n", 415 | "600/603 [============================>.] - ETA: 0s - loss: 0.0753 - mean_iou: 0.7794Epoch 00021: val_loss did not improve\n", 416 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0753 - mean_iou: 0.7794 - val_loss: 0.0892 - val_mean_iou: 0.7812\n", 417 | "Epoch 22/30\n", 418 | "600/603 [============================>.] - ETA: 0s - loss: 0.0747 - mean_iou: 0.7830Epoch 00022: val_loss improved from 0.08723 to 0.08300, saving model to model-dsbowl2018-1.h5\n", 419 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0746 - mean_iou: 0.7830 - val_loss: 0.0830 - val_mean_iou: 0.7846\n", 420 | "Epoch 23/30\n", 421 | "600/603 [============================>.] - ETA: 0s - loss: 0.0750 - mean_iou: 0.7862Epoch 00023: val_loss did not improve\n", 422 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0752 - mean_iou: 0.7862 - val_loss: 0.0951 - val_mean_iou: 0.7876\n", 423 | "Epoch 24/30\n", 424 | "600/603 [============================>.] - ETA: 0s - loss: 0.0745 - mean_iou: 0.7889Epoch 00024: val_loss did not improve\n", 425 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0749 - mean_iou: 0.7889 - val_loss: 0.0864 - val_mean_iou: 0.7904\n", 426 | "Epoch 25/30\n", 427 | "600/603 [============================>.] - ETA: 0s - loss: 0.0754 - mean_iou: 0.7916Epoch 00025: val_loss did not improve\n", 428 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0756 - mean_iou: 0.7916 - val_loss: 0.0871 - val_mean_iou: 0.7929\n", 429 | "Epoch 26/30\n", 430 | "600/603 [============================>.] - ETA: 0s - loss: 0.0746 - mean_iou: 0.7941Epoch 00026: val_loss did not improve\n", 431 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0747 - mean_iou: 0.7941 - val_loss: 0.0912 - val_mean_iou: 0.7953\n", 432 | "Epoch 27/30\n", 433 | "600/603 [============================>.] - ETA: 0s - loss: 0.0745 - mean_iou: 0.7965Epoch 00027: val_loss improved from 0.08300 to 0.08124, saving model to model-dsbowl2018-1.h5\n", 434 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0743 - mean_iou: 0.7965 - val_loss: 0.0812 - val_mean_iou: 0.7976\n", 435 | "Epoch 28/30\n", 436 | "592/603 [============================>.] - ETA: 0s - loss: 0.0715 - mean_iou: 0.7988Epoch 00028: val_loss did not improve\n", 437 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0716 - mean_iou: 0.7988 - val_loss: 0.0892 - val_mean_iou: 0.7999\n" 438 | ] 439 | }, 440 | { 441 | "name": "stdout", 442 | "output_type": "stream", 443 | "text": [ 444 | "Epoch 29/30\n", 445 | "600/603 [============================>.] - ETA: 0s - loss: 0.0753 - mean_iou: 0.8009Epoch 00029: val_loss did not improve\n", 446 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0754 - mean_iou: 0.8009 - val_loss: 0.0860 - val_mean_iou: 0.8018\n", 447 | "Epoch 30/30\n", 448 | "600/603 [============================>.] - ETA: 0s - loss: 0.0729 - mean_iou: 0.8028Epoch 00030: val_loss did not improve\n", 449 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0728 - mean_iou: 0.8028 - val_loss: 0.0857 - val_mean_iou: 0.8037\n" 450 | ] 451 | } 452 | ], 453 | "source": [ 454 | "def model_fit(X_train,Y_train,model_name,epochs,batch_size,validation_split):\n", 455 | " earlystopper = EarlyStopping(patience=5, verbose=1)\n", 456 | " checkpointer = ModelCheckpoint(model_name, verbose=1, save_best_only=True)\n", 457 | " results = model.fit(X_train, Y_train, validation_split=validation_split, \n", 458 | " batch_size=batch_size, epochs=epochs, \n", 459 | " callbacks=[earlystopper, checkpointer])\n", 460 | "\n", 461 | "model_name = 'model-dsbowl2018-1.h5'\n", 462 | "epochs = 30\n", 463 | "batch_size = 8\n", 464 | "validation_split = 0.1\n", 465 | "model_fit(X_train,Y_train,model_name,epochs,batch_size,validation_split)" 466 | ] 467 | }, 468 | { 469 | "cell_type": "code", 470 | "execution_count": 20, 471 | "metadata": { 472 | "scrolled": true 473 | }, 474 | "outputs": [ 475 | { 476 | "name": "stdout", 477 | "output_type": "stream", 478 | "text": [ 479 | "Train on 603 samples, validate on 67 samples\n", 480 | "Epoch 1/30\n", 481 | "592/603 [============================>.] - ETA: 0s - loss: 0.0714 - mean_iou: 0.8531Epoch 00001: val_loss improved from inf to 0.08364, saving model to model-dsbowl2018-1.h5\n", 482 | "603/603 [==============================] - 5s 8ms/step - loss: 0.0710 - mean_iou: 0.8533 - val_loss: 0.0836 - val_mean_iou: 0.8633\n", 483 | "Epoch 2/30\n", 484 | "600/603 [============================>.] - ETA: 0s - loss: 0.0710 - mean_iou: 0.8615Epoch 00002: val_loss did not improve\n", 485 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0710 - mean_iou: 0.8615 - val_loss: 0.0874 - val_mean_iou: 0.8617\n", 486 | "Epoch 3/30\n", 487 | "600/603 [============================>.] - ETA: 0s - loss: 0.0719 - mean_iou: 0.8607Epoch 00003: val_loss did not improve\n", 488 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0721 - mean_iou: 0.8608 - val_loss: 0.0911 - val_mean_iou: 0.8612\n", 489 | "Epoch 4/30\n", 490 | "600/603 [============================>.] - ETA: 0s - loss: 0.0715 - mean_iou: 0.8620Epoch 00004: val_loss improved from 0.08364 to 0.08225, saving model to model-dsbowl2018-1.h5\n", 491 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0713 - mean_iou: 0.8620 - val_loss: 0.0822 - val_mean_iou: 0.8617\n", 492 | "Epoch 5/30\n", 493 | "600/603 [============================>.] - ETA: 0s - loss: 0.0693 - mean_iou: 0.8619Epoch 00005: val_loss did not improve\n", 494 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0694 - mean_iou: 0.8619 - val_loss: 0.0894 - val_mean_iou: 0.8618\n", 495 | "Epoch 6/30\n", 496 | "600/603 [============================>.] - ETA: 0s - loss: 0.0701 - mean_iou: 0.8622 ETA: 0s - loss: 0.0695 - mean_iou: 0.Epoch 00006: val_loss did not improve\n", 497 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0703 - mean_iou: 0.8622 - val_loss: 0.0828 - val_mean_iou: 0.8621\n", 498 | "Epoch 7/30\n", 499 | "600/603 [============================>.] - ETA: 0s - loss: 0.0702 - mean_iou: 0.8622Epoch 00007: val_loss improved from 0.08225 to 0.08217, saving model to model-dsbowl2018-1.h5\n", 500 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0700 - mean_iou: 0.8622 - val_loss: 0.0822 - val_mean_iou: 0.8624\n", 501 | "Epoch 8/30\n", 502 | "600/603 [============================>.] - ETA: 0s - loss: 0.0688 - mean_iou: 0.8630Epoch 00008: val_loss improved from 0.08217 to 0.08216, saving model to model-dsbowl2018-1.h5\n", 503 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0685 - mean_iou: 0.8630 - val_loss: 0.0822 - val_mean_iou: 0.8630\n", 504 | "Epoch 9/30\n", 505 | "592/603 [============================>.] - ETA: 0s - loss: 0.0682 - mean_iou: 0.8631Epoch 00009: val_loss did not improve\n", 506 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0678 - mean_iou: 0.8631 - val_loss: 0.0843 - val_mean_iou: 0.8633\n", 507 | "Epoch 10/30\n", 508 | "592/603 [============================>.] - ETA: 0s - loss: 0.0658 - mean_iou: 0.8636Epoch 00010: val_loss did not improve\n", 509 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0659 - mean_iou: 0.8636 - val_loss: 0.0864 - val_mean_iou: 0.8641\n", 510 | "Epoch 11/30\n", 511 | "600/603 [============================>.] - ETA: 0s - loss: 0.0654 - mean_iou: 0.8646Epoch 00011: val_loss did not improve\n", 512 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0656 - mean_iou: 0.8646 - val_loss: 0.0873 - val_mean_iou: 0.8647\n", 513 | "Epoch 12/30\n", 514 | "600/603 [============================>.] - ETA: 0s - loss: 0.0719 - mean_iou: 0.8641Epoch 00012: val_loss did not improve\n", 515 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0718 - mean_iou: 0.8641 - val_loss: 0.0833 - val_mean_iou: 0.8643\n", 516 | "Epoch 13/30\n", 517 | "600/603 [============================>.] - ETA: 0s - loss: 0.0673 - mean_iou: 0.8645Epoch 00013: val_loss did not improve\n", 518 | "603/603 [==============================] - 3s 5ms/step - loss: 0.0672 - mean_iou: 0.8645 - val_loss: 0.0882 - val_mean_iou: 0.8645\n", 519 | "Epoch 00013: early stopping\n" 520 | ] 521 | } 522 | ], 523 | "source": [ 524 | "# Fit model\n", 525 | "earlystopper = EarlyStopping(patience=5, verbose=1)\n", 526 | "checkpointer = ModelCheckpoint('model-dsbowl2018-1.h5', verbose=1, save_best_only=True)\n", 527 | "results = model.fit(X_train, Y_train, validation_split=0.1, batch_size=8, epochs=30, \n", 528 | " callbacks=[earlystopper, checkpointer])" 529 | ] 530 | }, 531 | { 532 | "cell_type": "markdown", 533 | "metadata": {}, 534 | "source": [ 535 | "## Make predictions 预测\n", 536 | "Let's make predictions both on the test set, the val set and the train set (as a sanity check). Remember to load the best saved model if you've used early stopping and checkpointing." 537 | ] 538 | }, 539 | { 540 | "cell_type": "code", 541 | "execution_count": null, 542 | "metadata": {}, 543 | "outputs": [], 544 | "source": [ 545 | "# X_train (670, 128, 128, 3)\n", 546 | "# Y_train (670, 128, 128, 1)\n", 547 | "# X_test (65, 128, 128, 3)" 548 | ] 549 | }, 550 | { 551 | "cell_type": "code", 552 | "execution_count": 9, 553 | "metadata": {}, 554 | "outputs": [ 555 | { 556 | "name": "stdout", 557 | "output_type": "stream", 558 | "text": [ 559 | "603/603 [==============================] - 1s 2ms/step\n", 560 | "67/67 [==============================] - 0s 747us/step\n", 561 | "65/65 [==============================] - 0s 737us/step\n" 562 | ] 563 | } 564 | ], 565 | "source": [ 566 | "# Predict on train, val and test\n", 567 | "model = load_model('model-dsbowl2018-1.h5', custom_objects={'mean_iou': mean_iou})\n", 568 | "preds_train = model.predict(X_train[:int(X_train.shape[0]*0.9)], verbose=1) # (603, 128, 128, 1)\n", 569 | "preds_val = model.predict(X_train[int(X_train.shape[0]*0.9):], verbose=1) # (67, 128, 128, 1)\n", 570 | "preds_test = model.predict(X_test, verbose=1) # (65, 128, 128, 1)\n", 571 | "\n", 572 | "# Threshold predictions\n", 573 | "# 二值化\n", 574 | "preds_train_t = (preds_train > 0.5).astype(np.uint8)\n", 575 | "preds_val_t = (preds_val > 0.5).astype(np.uint8)\n", 576 | "preds_test_t = (preds_test > 0.5).astype(np.uint8)\n", 577 | "\n", 578 | "# Create list of upsampled test masks\n", 579 | "# 上采样，回到原来的尺寸\n", 580 | "preds_test_upsampled = [] # (65,)\n", 581 | "for i in range(len(preds_test)):\n", 582 | " preds_test_upsampled.append(resize(np.squeeze(preds_test[i]), \n", 583 | " (sizes_test[i][0], sizes_test[i][1]), # 回到原来的尺寸\n", 584 | " mode='constant', preserve_range=True))" 585 | ] 586 | }, 587 | { 588 | "cell_type": "code", 589 | "execution_count": 10, 590 | "metadata": { 591 | "scrolled": false 592 | }, 593 | "outputs": [ 594 | { 595 | "data": { 596 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAEYCAYAAAATaEB+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nGwJi8vDjAAAAAElFTkSuQmCC\n", 597 | "text/plain": [ 598 | "" 599 | ] 600 | }, 601 | "metadata": {}, 602 | "output_type": "display_data" 603 | }, 604 | { 605 | "data": { 606 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAEYCAYAAAATaEB+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nXQAAAABJRU5ErkJggg==\n", 607 | "text/plain": [ 608 | "" 609 | ] 610 | }, 611 | "metadata": {}, 612 | "output_type": "display_data" 613 | }, 614 | { 615 | "data": { 616 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUQAAAEYCAYAAAAkpo9KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhDvgGg0AAAAASUVORK5CYII=\n", 617 | "text/plain": [ 618 | "" 619 | ] 620 | }, 621 | "metadata": {}, 622 | "output_type": "display_data" 623 | } 624 | ], 625 | "source": [ 626 | "# Perform a sanity check on some random training samples\n", 627 | "ix = random.randint(0, len(preds_train_t))\n", 628 | "imshow(X_train[ix])\n", 629 | "plt.show()\n", 630 | "imshow(np.squeeze(Y_train[ix]))# 128*128*1\n", 631 | "plt.show()\n", 632 | "imshow(np.squeeze(preds_train_t[ix])) # 128*128*1\n", 633 | "plt.show()" 634 | ] 635 | }, 636 | { 637 | "cell_type": "code", 638 | "execution_count": 18, 639 | "metadata": { 640 | "scrolled": false 641 | }, 642 | "outputs": [ 643 | { 644 | "data": { 645 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAEYCAYAAAATaEB+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n0yv/Hw8fn1I60HtxAAAAAElFTkSuQmCC\n", 646 | "text/plain": [ 647 | "" 648 | ] 649 | }, 650 | "metadata": {}, 651 | "output_type": "display_data" 652 | }, 653 | { 654 | "data": { 655 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAASEAAAEYCAYAAAATaEB+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 656 | "text/plain": [ 657 | "" 658 | ] 659 | }, 660 | "metadata": {}, 661 | "output_type": "display_data" 662 | }, 663 | { 664 | "data": { 665 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUQAAAEYCAYAAAAkpo9KAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAGB9JREFUeJzt3X+wXOV93/H3B/GrYGMhlFIhkaCO\n5aQKdYBR+TF0amrhQVAGpVMPI9lxwCbVdAYSYrsJUDompZMZqFM7ZEpJboGAPQSFKE7QuHIUwDCe\ndgrmEjMYCWNuRQAJYQGWicc0oB+f/nGelZbre+/uvfvj7O79vGbOaM/Zs2e/90j3q+9znuc5R7aJ\niAg4ou4AIiIGRRJiRESRhBgRUSQhRkQUSYgREUUSYkREkYQYEUNJ0t2S9kh6dpr3JekPJE1IekbS\nWa2O2bOEKGmNpOdLMNf36nsiYt66B1gzw/sXAyvKsgG4o9UBe5IQJS0Abi8BrQTWS1rZi++KiPnJ\n9reAH86wy1rgK648DiyUtGSmYx7ZzQCbnA1M2N4BIGljCW77VDsfrWN8LMf3KJSIqMOP2fuG7Z8B\nuOhfHu83f3ig7c8+9cw724C/b9o0ZntsliEsBV5pWt9Ztu2e7gO9SohTBXJO8w6SNlCVsRzLcZyj\n1T0KJSLq8LA3vdR4/eYPD/DtrT/b9mcXLHnh722v6klgM+hVQmypZPsxgBO0KBOqI0aYgYMc7PfX\n7gJObVpfVrZNq1edKrMOJCJGmTngg20vXbIZ+NXS23wu8JbtaZvL0LsK8UlghaTlVIlwHfCJHn1X\nRAy4qkLsbkNQ0v3ABcBiSTuBm4CjAGz/IbAFuASYAN4GPt3qmD1JiLb3S7oG2AosAO62va0X3xUR\nw6HbTWbb61u8b+Dq2RyzZ9cQbW+hytARMc8Zc2AI7r1aW6dKRMwv3W4y90ISYkT0nIEDSYgREZVU\niBERVBXivlxDjIgonSqpECMiAMOBwc+HSYgR0XvVwOzBl4QYEX0gDqC6g2gpCTEies7AwTSZIyIq\nqRAjImgMzE5CjIgA4KCTECMiUiFGRDQYcWAInnqchBgRfZEmc0QEaTJHRDQRB5wmc0REmbqXhBgR\nAaTJHBEBgJ0mc0TEIQdTIUZENHqZUyFGRJBe5oiIIr3MERFNDmSmSkRE5jJHRBxSPYZ08NPN4EcY\nEUPPKE3miIiGdKpERAA2QzHsZs4RSjpV0qOStkvaJunasn2RpIckvVD+PLF74UbEcBIHZ7HUpZOU\nvR/4vO2VwLnA1ZJWAtcDj9heATxS1iNiHjNVhdjuUpc5N5lt7wZ2l9c/lvQcsBRYC1xQdrsXeAy4\nrqMoI2LozZthN5JOA84EngBOLskS4DXg5Gk+swHYAHAsx3UjjIgYUEbz4xECkt4H/Dnwm7b/Tjr8\nQ9u2JE/1OdtjwBjACVo05T4RMTpGvkKUdBRVMrzP9tfK5h9IWmJ7t6QlwJ5Wx/nQh99m69anW37f\nRaec0Um4EVETAwdHvJdZwF3Ac7a/1PTWZuCK8voK4MG5hxcRo0EcmMVSl04qxPOBTwHfldQo7/4D\ncAvwgKSrgJeAyzsL8bCtr1Zfk0oxYrgMS4XYSS/z/4JpU/nquR43IkZTnqnSI1tffXogqsRGxdrK\nIMQaUSdbXa8QJa0BbgMWAHfavmXS+z9LNfRvYdnnettbZjrmUCbEiBg+3RxwLWkBcDvwMWAn8KSk\nzba3N+32H4EHbN9RJo1sAU6b6bgD0aj//jPHpYqKGGHVHbO7OnXvbGDC9g7b7wIbqSaFTP7aE8rr\nDwCvtjpoKsSI6INZP1NlsaTxpvWxMna5YSnwStP6TuCcScf4HeCvJf06cDxwYasvHaiE2KgSW12b\nSzUZMVyqXuZZdaq8YXtVh1+7HrjH9n+VdB7wVUmn2z443QcGKiFGxOjq8kyVXcCpTevLyrZmVwFr\nAGz/H0nHAouZYbLIQCbEyRVgu725ETGYejCX+UlghaTlVIlwHfCJSfu8TDUE8B5J/wQ4Fnh9poMO\nZEKMiNHTzTtm294v6RpgK9WQmrttb5N0MzBuezPweeB/SPosVav9Stsz3jdhKBLisF4zHNa4I7qt\numN2dwdmlzGFWyZt+0LT6+1UM+raNhQJMSKG37y4/dd8NrlXPBVhxNSM2OcFdYfRUhJiRPTcHIbd\n1CIJsQtSGUa00v25zL2QhBgRfVHn0/TalYQYET3Xi17mXkhCjIi+SJM5IoJ59NS9iIh25BpiRAQZ\ndhMR8R65hhgRAeBcQ4yIAA4/QmDQJSFGRF+kQoyIIJ0qERHvkYQYEUEGZkdEvEc6VSIiAJwmc0QE\nMI86VSQtAMaBXbYvLY8F3AicBDwFfMr2u51+T0RMb66P6u3nzY2HISF2Yy7NtcBzTeu3Al+2/UFg\nL9XDoiNiHmt0qrS71KWjhChpGfCvgDvLuoCPApvKLvcCv9zJd0TEzOZaHfabrbaXunTaZP594LeB\n95f1k4Af2d5f1ncCS6f6oKQNwAaAYzmuwzAiYtANQy/znCtESZcCe2w/NZfP2x6zvcr2qqM4Zq5h\nREQHtr76dF8qTJde5kFvMndSIZ4PXCbpEuBY4ATgNmChpCNLlbgM2NV5mBEx3MSBg4N/+685R2j7\nBtvLbJ8GrAO+afuTwKPAx8tuVwAPdhxlRPTERaec0bee5mG4htiLlH0d8DlJE1TXFO/qwXdExBBp\njEMc5SbzIbYfAx4rr3cAZ3fjuBHR2kWnnDH4Pc2uriMOusxUiYi+GIZe5iTEiBHQuA7YqlLs58yU\nZoZarw22KwkxYoTUlfBay+2/IiIOyTXEiIgiTeaICKrqMAkxIqLINcSIiCLXECMiijSZIyKobhCb\nhBgRUQxBi7knN3eIiHgvd/9uN5LWSHpe0oSk66fZ53JJ2yVtk/QnrY6ZCjEi+qOLJWJ5uN3twMeo\n7sz/pKTNtrc37bMCuAE43/ZeSf+w1XFTIUZEX3S5QjwbmLC9ozzVcyOwdtI+/xa43fbe6vu9p9VB\nkxAjoi/s9pc2LAVeaVqf6vlNHwI+JOl/S3pc0ppWB02TOSJ6bg53u1ksabxpfcz22Cy/9khgBXAB\n1eNMviXpn9r+0UwfiIjoLQOzS4hv2F41w/u7gFOb1qd6ftNO4Anb+4AXJX2fKkE+Od1B02SOiL7o\ncpP5SWCFpOWSjqZ6rtPmSfv8JVV1iKTFVE3oHTMdNAkxIvrDs1haHap6quc1wFbgOeAB29sk3Szp\nsrLbVuBNSdupHn73W7bfnOm4aTJHRB8IH+zuTBXbW4Atk7Z9oem1gc+VpS1JiBHRe7n9V0REkyGY\nu5eEGBF9kgoxIqKSCjEiokhCjIhgLgOza5GEGBF9kUcIREQ0JCFGRBRD0GTuaOqepIWSNkn6nqTn\nJJ0naZGkhyS9UP48sVvBRsTwkttf6tLpXObbgL+y/QvAL1HNKbweeMT2CuCRsh4R89ls5jEPY0KU\n9AHgXwB3Adh+t9xnbC1wb9ntXuCXOw0yIoadqiZzu0tNOqkQlwOvA38s6TuS7pR0PHCy7d1ln9eA\nk6f6sKQNksYlje/jnQ7CiIihMMoVIlWHzFnAHbbPBH7CpOZxudvElD+e7THbq2yvOopjOggjIobC\niCfEncBO20+U9U1UCfIHkpYAlD9bPtglIuaBUU6Itl8DXpH082XTamA71V1rryjbrgAe7CjCiBh+\njZkqA34NsdNxiL8O3Fdu4b0D+DRVkn1A0lXAS8DlHX5HRIyAOofTtKujhGj7aWCqB8Gs7uS4ETGC\nhiAh5pkqERFFpu5FRF+MfJM5IqJtQzCXOQkxInqv5uE07UpCjIi+0MG6I2gtCTEi+iMVYkREkYQY\nEVH/fQ7blYQYEf2RXuaIiCIVYkREJU3miIiGJMSICCCdKhERTZIQIyKKJMSIiMowNJlzP8SIiCIV\nYkT0xxBUiEmIMRC2vvr0lNsvOuWMPkcSPZFe5oiIJkmIETObrjJsfj9V4ohIQoyIAJEmc0RXTK4i\nUzEOqS4nRElrgNuABcCdtm+ZZr9/A2wC/pnt8ZmOmWE3EdF7PnxPxHaWViQtAG4HLgZWAuslrZxi\nv/cD1wJPtBNmKsSoRatrhzGCulshng1M2N4BIGkjsBbYPmm//wzcCvxWOwdNhRgR/eFZLK0tBV5p\nWt9Zth0i6SzgVNv/s90QUyFGRF/MslNlsaTm631jtsfa/i7pCOBLwJWz+dIkxIjoPQOzewzpG7ZX\nzfD+LuDUpvVlZVvD+4HTgcckAfwjYLOky2bqWElCjIi+6PKwmyeBFZKWUyXCdcAnGm/afgtYfOi7\npceAf59e5ogYDF28hmh7P3ANsBV4DnjA9jZJN0u6bK4hdlQhSvos8GtUP8J3gU8DS4CNwEnAU8Cn\nbL/byfeMikbPasbRHT4H6W2eP7o9MNv2FmDLpG1fmGbfC9o55pwrRElLgd8AVtk+nWpw5DqqLu4v\n2/4gsBe4aq7fEREjpLu9zD3R6TXEI4F/IGkfcBywG/goh9vy9wK/A9zR4fcMpemqn8zPnZucsyFW\nc6Jr15wrRNu7gN8DXqZKhG9RNZF/VNr3MMXYoAZJGySNSxrfxztzDSMihoBmudSlkybziVQjw5cD\npwDHA2va/bztMdurbK86imPmGsbQ2vrq07l+RlX1pfKbJ0a8yXwh8KLt1wEkfQ04H1go6chSJU4e\nGxQR89So3+3mZeBcSccB/w9YDYwDjwIfp+ppvgJ4sNMgR1GqoveafD6aq+ecqxExBAmxk2uIT1Dd\nUudvqIbcHAGMAdcBn5M0QTX05q4uxBkRw27Em8zYvgm4adLmHVR3ooiYs1SFIybPVIn8Ukc0SUKM\niKikQoyIaEhCjIiopEKMiIDae4/blYQYEf2RhBgRkecyR0S8VxJiRERFHvyMmIQYEb2XTpWIiMNy\nDTEiotDsHkNaiyTEiOiPVIgREeRuNxER75GEGBGRgdkREe+VcYgREZVUiBERkIHZERHNMg5xREx+\noHyelRIxB6kQIyIquYY45CZXhtNtT8UY0YJJL/Mwmy4ZzrRvEmPE9FIhRkQ0JCFGRGSmSkTEYXau\nIUZENKRCjIhoGIWEKOlu4FJgj+3Ty7ZFwJ8CpwF/C1xue68kAbcBlwBvA1fa/pvehN5bF51yxqx6\nmqM+7f49ZRRAvYahQjyijX3uAdZM2nY98IjtFcAjZR3gYmBFWTYAd3QnzIgYagYOuv2lJi0rRNvf\nknTapM1rgQvK63uBx4Dryvav2DbwuKSFkpbY3t2tgAdRKo/hkPGiNRuRCnEqJzcludeAk8vrpcAr\nTfvtLNt+iqQNksYlje/jnTmGERHDQm5/qUvHnSq2Lc3+R7A9BowBnKBFA/l/R6OSmO4aVSqNes31\nGm+mXtaky8NuJK2h6rNYANxp+5ZJ738O+DVgP/A68BnbL810zLlWiD+QtKR86RJgT9m+Czi1ab9l\nZVtEzGeubv/V7tKKpAXA7VT9FiuB9ZJWTtrtO8Aq2x8GNgH/pdVx51ohbgauAG4pfz7YtP0aSRuB\nc4C3RuH6YSqIiM5UM1W6WiGeDUzY3gFQcs5aYHtjB9uPNu3/OPArrQ7azrCb+6k6UBZL2gncRJUI\nH5B0FfAScHnZfQvVkJsJqmE3n251/IiYJ2Z3g9jFksab1sfKZbaGqforzpnheFcB32j1pe30Mq+f\n5q3VU+xr4OpWx4yI+WeWFeIbtld15XulXwFWAR9ptW9mqkRE73X/mSpt9VdIuhC4EfiI7ZbDWeba\nqRIRMQs+fIOHdpbWngRWSFou6WhgHVUfxiGSzgT+CLjM9p4pjvFTUiFGRF90c3yh7f2SrgG2Ug27\nudv2Nkk3A+O2NwNfBN4H/Fk1q5iXbV8203GTEGPeyuiBPuvyOETbW6g6cpu3faHp9YWzPWYSYkT0\nnvMY0oiBkoqwZrlBbEREMfj5MAkxhlcqvuHS5ZkqPZGEGBH9kYQYEUG5QWzdQbSWhBgRPSecJnNE\nxCFJiBERRRJiRAS5hhjTm82t7zO0JEZFriFGRDQkIUazuTwUKY/OjNHQ9m29apWEGBG9Z5IQozLX\nx2VOdYxUijG00qkSEVHRwcHPiEmIPdSNyjBiJBg4mCZzRATpVImIaJaEGBFRJCFGt9TZuzzTtdD0\nekdbcg0xIqLB4PQyz2uN6qmT3uZBrQyn2ycVY0wrTeaICNJkjs4MemUYMWtDUCEe0WoHSXdL2iPp\n2aZtX5T0PUnPSPoLSQub3rtB0oSk5yVd1KvAI2LI2O0vNWmnQrwH+G/AV5q2PQTcYHu/pFuBG4Dr\nJK0E1gG/CJwCPCzpQ7YPdDfs4ZLrahHDMTC7ZYVo+1vADydt+2vb+8vq48Cy8notsNH2O7ZfBCaA\ns7sYb0QMIwMHD7a/1KRlQmzDZ4BvlNdLgVea3ttZtv0USRskjUsa38c7XQgjIgbaiDSZpyXpRmA/\ncN9sP2t7DBgDOEGLBr+WjojODEGTec4JUdKVwKXAavvQT7oLOLVpt2VlW0TMax7dYTeS1gC/DXzE\n9ttNb20G/kTSl6g6VVYA3+44yhh46TiKGRk8CjNVJN0PXAAslrQTuImqV/kY4CFJAI/b/ne2t0l6\nANhO1ZS+er73MEdEMQoVou31U2y+a4b9fxf43U6CinrNZsphKsNo2yhfQ4yIaJtd63CadiUhxrRS\n/UVXpUKMiKg4FWJEBAzL1L0kxIjovdz+KyKiYsAHBn8EXjfmMkdEzMzlEQLtLm2QtKbcZnBC0vVT\nvH+MpD8t7z8h6bRWx0xCjIi+8EG3vbQiaQFwO3AxsBJYX24/2OwqYK/tDwJfBm5tddwkxIjoj+5W\niGcDE7Z32H4X2Eh1+8Fma4F7y+tNwGqVqXXTGYhriD9m7xsPe9NPgDfqjmUaixnM2BLX7A1qbKMY\n1881XvyYvVsf9qbFs/jssZLGm9bHyh2yGqa61eA5k45xaJ9yM+u3gJOY4ecZiIRo+2ckjdteVXcs\nUxnU2BLX7A1qbKMel+013Yin19Jkjohh1M6tBg/tI+lI4APAmzMdNAkxIobRk8AKScslHU31LKfN\nk/bZDFxRXn8c+GbTvVunNBBN5mKs9S61GdTYEtfsDWpsiWsWyjXBa4CtwALg7nL7wZuBcdubqe7K\n9VVJE1TPhVrX6rhqkTAjIuaNNJkjIookxIiIYiASYqspOH2M41RJj0raLmmbpGvL9kWSHpL0Qvnz\nxJriWyDpO5K+XtaXlylJE2WK0tE1xbVQ0iZJ35P0nKTzBuGcSfps+Xt8VtL9ko6t65xJulvSHknP\nNm2b8hyp8gclxmckndXnuL5Y/i6fkfQXkhY2vXdDiet5SRf1Kq661J4Q25yC0y/7gc/bXgmcC1xd\nYrkeeMT2CuCRsl6Ha4HnmtZvBb5cpibtpZqqVIfbgL+y/QvAL1HFWOs5k7QU+A1gle3TqS68r6O+\nc3YPMHks3nTn6GKqB7StADYAd/Q5roeA021/GPg+1TOUKL8L64BfLJ/57+X3d3TYrnUBzgO2Nq3f\nANxQd1wllgeBjwHPA0vKtiXA8zXEsozql+ajwNcBUY24P3Kq89jHuD4AvEjpoGvaXus54/AshUVU\noym+DlxU5zkDTgOebXWOgD8C1k+1Xz/imvTevwbuK6/f87tJ1cN7Xr//zfVyqb1CZOopOEtriuWQ\ncmeMM4EngJNt7y5vvQacXENIv0/16NfGRM+TgB/Z3l/W6zpvy4HXgT8uzfk7JR1PzefM9i7g94CX\ngd3AW8BTDMY5a5juHA3S78RngG+U14MUV08MQkIcOJLeB/w58Ju2/675PVf/NfZ1rJKkS4E9tp/q\n5/e26UjgLOAO22cCP2FS87imc3Yi1eT+5VTPCD+en24aDow6zlErkm6kuox0X92x9MsgJMR2puD0\njaSjqJLhfba/Vjb/QNKS8v4SYE+fwzofuEzS31Ld1eOjVNftFpYpSVDfedsJ7LT9RFnfRJUg6z5n\nFwIv2n7d9j7ga1TncRDOWcN056j23wlJVwKXAp8syXog4uq1QUiI7UzB6Ytya6C7gOdsf6npreYp\nQFdQXVvsG9s32F5m+zSq8/NN258EHqWaklRLXCW214BXJP182bQa2E7N54yqqXyupOPK32sjrtrP\nWZPpztFm4FdLb/O5wFtNTeuek7SG6vLMZbbfnhTvOlU3Xl1O1enz7X7F1Rd1X8Qs//lcQtWb9X+B\nG2uM459TNVueAZ4uyyVU1+seAV4AHgYW1RjjBcDXy+t/TPUPcgL4M+CYmmI6Axgv5+0vgRMH4ZwB\n/wn4HvAs8FXgmLrOGXA/1bXMfVRV9VXTnSOqDrPby+/Dd6l6yvsZ1wTVtcLG78AfNu1/Y4nreeDi\nOv699XLJ1L2IiGIQmswREQMhCTEiokhCjIgokhAjIookxIiIIgkxIqJIQoyIKP4/nwGoMPJq1AIA\nAAAASUVORK5CYII=\n", 666 | "text/plain": [ 667 | "" 668 | ] 669 | }, 670 | "metadata": {}, 671 | "output_type": "display_data" 672 | } 673 | ], 674 | "source": [ 675 | "# Perform a sanity check on some random validation samples\n", 676 | "ix = random.randint(0, len(preds_val_t))\n", 677 | "imshow(X_train[int(X_train.shape[0]*0.9):][ix])\n", 678 | "plt.show()\n", 679 | "imshow(np.squeeze(Y_train[int(Y_train.shape[0]*0.9):][ix]))\n", 680 | "plt.show()\n", 681 | "imshow(np.squeeze(preds_val_t[ix]))\n", 682 | "plt.show()" 683 | ] 684 | }, 685 | { 686 | "cell_type": "markdown", 687 | "metadata": {}, 688 | "source": [ 689 | "## Encode and submit our results\n", 690 | "\n", 691 | " Run-Length Encoding（RLE）行程长度的原理是将一扫描行中的颜色值相同的相邻像素用一个计数值和那些像素的颜色值来代替。例如:aaabccccccddeee，则可用3a1b6c2d3e来代替。对于拥有大面积，相同颜色区域的图像，用RLE压缩方法非常有效。由RLE原理派生出许多具体行程压缩方法" 692 | ] 693 | }, 694 | { 695 | "cell_type": "code", 696 | "execution_count": 25, 697 | "metadata": {}, 698 | "outputs": [], 699 | "source": [ 700 | "# Run-length encoding stolen from https://www.kaggle.com/rakhlin/fast-run-length-encoding-python\n", 701 | "def rle_encoding(x):\n", 702 | " dots = np.where(x.T.flatten() == 1)[0]\n", 703 | " run_lengths = []\n", 704 | " prev = -2\n", 705 | " for b in dots:\n", 706 | " if (b>prev+1): run_lengths.extend((b + 1, 0))\n", 707 | " run_lengths[-1] += 1\n", 708 | " prev = b\n", 709 | " return run_lengths\n", 710 | "\n", 711 | "def prob_to_rles(x, cutoff=0.5):\n", 712 | " lab_img = label(x > cutoff)\n", 713 | " for i in range(1, lab_img.max() + 1):\n", 714 | " yield rle_encoding(lab_img == i)" 715 | ] 716 | }, 717 | { 718 | "cell_type": "code", 719 | "execution_count": 26, 720 | "metadata": {}, 721 | "outputs": [], 722 | "source": [ 723 | "new_test_ids = []\n", 724 | "rles = []\n", 725 | "for n, id_ in enumerate(test_ids):\n", 726 | " rle = list(prob_to_rles(preds_test_upsampled[n]))\n", 727 | " rles.extend(rle)\n", 728 | " new_test_ids.extend([id_] * len(rle))" 729 | ] 730 | }, 731 | { 732 | "cell_type": "code", 733 | "execution_count": 27, 734 | "metadata": {}, 735 | "outputs": [], 736 | "source": [ 737 | "# Create submission DataFrame\n", 738 | "sub = pd.DataFrame()\n", 739 | "sub['ImageId'] = new_test_ids\n", 740 | "sub['EncodedPixels'] = pd.Series(rles).apply(lambda x: ' '.join(str(y) for y in x))" 741 | ] 742 | }, 743 | { 744 | "cell_type": "code", 745 | "execution_count": null, 746 | "metadata": {}, 747 | "outputs": [], 748 | "source": [ 749 | "sub.to_csv('sub-dsbowl2018-1.csv', index=False)" 750 | ] 751 | } 752 | ], 753 | "metadata": { 754 | "kernelspec": { 755 | "display_name": "Python 3", 756 | "language": "python", 757 | "name": "python3" 758 | }, 759 | "language_info": { 760 | "codemirror_mode": { 761 | "name": "ipython", 762 | "version": 3 763 | }, 764 | "file_extension": ".py", 765 | "mimetype": "text/x-python", 766 | "name": "python", 767 | "nbconvert_exporter": "python", 768 | "pygments_lexer": "ipython3", 769 | "version": "3.5.2" 770 | } 771 | }, 772 | "nbformat": 4, 773 | "nbformat_minor": 2 774 | } 775 | --------------------------------------------------------------------------------