├── LICENSE ├── README.md ├── fig ├── Network_img.PNG ├── network.PNG └── sample_results.PNG └── src └── comp_net_raw.py /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 raun1 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Pretrained optimal-compnet model on 1st fold of Oasis Brain MRI dataset link - https://drive.google.com/file/d/1o70IS00y5psMI8G5FQAciu5A4xcnkhsX/view?usp=sharing (let me know if this gets corrupted ) 2 | ### Please note that the green sigmoid in the image should be an concatenation. We simply concatenate the pairwise addition of the intermediate branches and then send that whole concatenation (NO SIGMOID on it) to the reconstruction branch 3 | 4 | Network Architecture for the MICCAI_2018 paper : CompNet: Complementary Segmentation Network for Brain MRI Extraction. To view the paper on Archive click the following https://arxiv.org/abs/1804.00521 5 | 6 | ![alt text](https://github.com/raun1/Complementary_Segmentation_Network/blob/master/fig/Network_img.PNG) 7 | ## Comp Net summary 8 | Architecture of our complementary segmentation network, the optimal CompNet. 9 | The dense blocks (DB), corresponding to the gray bars, are used in each encoder 10 | and decoder. The triple (x,y,z) in each dense block indicates that it has x convolutional 11 | layers with a kernel size 3×3; each layer has y filters, except for the last one that has z 12 | filters. SO: segmentation output for the brain mask; CO: complementary segmentation 13 | output for the non-brain mask; RO: reconstruction output for the input image. These 14 | three outputs produced by the Sigmoid function are the final predictions; while all 15 | other Sigmoids produce intermediate outputs, except for the green one that is the concatenation of the summation from each intermediate layers. Best viewed in color. 16 | 17 | *ROI and CO branches - 18 | We take the downsampling branch of a U-Net as it is, however we split the upsampling branch into two halves, one to obtain the Region of Interest and the other for Complementary aka non region of interest. Losses here are negative dice for ROI and positive dice for Non-ROI region.* 19 | 20 | *Reconstruction Branch - 21 | Next we merge these two ROI and non ROI outputs using "Summation" operation and then pass it into another U-Net, This U-Net is the reconstruction branch. The input is the summed image from previous step and the output is the "original" image that we start with. The loss of reconstruction branch is MSE.* 22 | 23 | ``` 24 | The code in this repository provides only the stand alone code for this architecture. You may implement it as is, or convert it into modular structure 25 | if you so wish. The dataset of OASIS can obtained from the link above and the preprocessiong steps involved are mentioned in the paper. 26 | You have to provide the inputs. 27 | ``` 28 | 29 | 30 | email me - rd31879@uga.edu for any questions !! Am happy to discuss 31 | 32 | ## Built With/Things Needed to implement experiments 33 | 34 | * [Python](https://www.python.org/downloads/) - Python-2 35 | * [Keras](http://www.keras.io) - Deep Learning Framework used 36 | * [Numpy](http://www.numpy.org/) - Numpy 37 | * [Sklearn](http://scikit-learn.org/stable/install.html) - Scipy/Sklearn/Scikit-learn 38 | * [CUDA](https://developer.nvidia.com/cuda-80-ga2-download-archive) - CUDA-8 39 | * [CUDNN](https://developer.nvidia.com/rdp/assets/cudnn_library-pdf-5prod) - CUDNN-5 You have to register to get access to CUDNN 40 | * [OASIS](https://www.oasis-brains.org/) - Oasis-dataset website 41 | * [12 gb TitanX]- To implement this exact network 42 | 43 | ## Basic Idea 44 | 45 | 46 | ### Pre-requisites 47 | This architecture can be understood after learning about the U-Net [https://arxiv.org/abs/1505.04597] {PLEASE READ U-NET before reading this paper} and W-Net [https://arxiv.org/abs/1711.08506] {Optional}. 48 | * Please see line 1541 in comp_net_raw.py file in src for the main essence of complementary network - i.e. summing up the intermediate outputs of segmentation and complementary branches and then concatenating them for reconstruction layer. 49 | * Hyper parameters to be set - 50 | * l2_Lambda - used for regularizing/penalizing parameters of the current layer 51 | * Mainly used to prevent overfitting and is incorporated in the loss function 52 | * Please see keras.io for more details 53 | * DropP sets the % of dropout at the end of every dense block 54 | * Kernel_size is the kernel size of the convolution filters 55 | * Please see readme for additional resources. 56 | * Lines 73 - 648 is the common encoder of the segmentation and complementary branches. 57 | * Layers such as xconv1a,xmerge1........ belong to the complementary upsampling branch branch of the architecture. 58 | * The convolution layers's number indicates its level and so up6 and xup6 are at the same level 59 | * and are parallel to each other 60 | * Layers such as xxconv1a,xxmerge1 .... belong to the reconstruction branch. 61 | * For more details of the multi outputs please see my isbi repository here 62 | https://github.com/raun1/ISBI2018-Diagnostic-Classification-Of-Lung-Nodules-Using-3D-Neural-Networks 63 | * Basically to summarize, we have two branches one which has negative dice with ground truth brain mask 64 | and is the segmentation branch 65 | * We then have another branch with positive dice with ground truth masks 66 | * The THEME of comp-net is to sum up the two sections, future works will provide a better way to do this and a generalized version :) 67 | * We do this theme of summing at every stage of the intermediate outputs i.e. the first intermediate output of segmentation branch 68 | is summed with first intermediate output of the complementary branch. 69 | * We obtain a final summary of the outputs of the segmentation branch and complementary branch and also sum these two new summaries 70 | * Finally we concat all of these summations and send to the reconstruction branch 71 | * reconstruction branch is a simple structure of dense multi-output U-Net and the ground truth is the input image and loss is MSE. 72 | 73 | 74 | ### Building your own Comp Net from whatever U-Net you have 75 | 76 | * Copy the upsampling branch of your U-Net 77 | * Duplicate it 78 | * Use same loss functions as the original U-Net BUT change its sign {Warning - Make sure your loss function is defined for the opposite sign and try to think intuitively what it acheives. Example dice is simply overlap between two objects and optimizing negative dice gives us maximum possible overlap, but positive dice lowest value is 0 since you CANNOT quantify how much seperation is there between two objects using the DICE score but simply quantify if the two overlap or not and if they overlap how much } 79 | * Add the two upsampling branch outputs pairwise for each channel using keras's model.add layer 80 | * Feed that into the new reconstruction U-Net where the loss function is MSE with the Input image of the first U-Net i.e. the original input 81 | 82 | 83 | ![alt text](https://github.com/raun1/Complementary_Segmentation_Network/blob/master/fig/sample_results.PNG) 84 | Sample results 85 | 86 | -------------------------------------------------------------------------------- /fig/Network_img.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raun1/MICCAI2018---Complementary_Segmentation_Network-Raw-Code/6522812f2e25304d4c4dfa572cd0df6549a9ff47/fig/Network_img.PNG -------------------------------------------------------------------------------- /fig/network.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raun1/MICCAI2018---Complementary_Segmentation_Network-Raw-Code/6522812f2e25304d4c4dfa572cd0df6549a9ff47/fig/network.PNG -------------------------------------------------------------------------------- /fig/sample_results.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/raun1/MICCAI2018---Complementary_Segmentation_Network-Raw-Code/6522812f2e25304d4c4dfa572cd0df6549a9ff47/fig/sample_results.PNG -------------------------------------------------------------------------------- /src/comp_net_raw.py: -------------------------------------------------------------------------------- 1 | 2 | # coding: utf-8 3 | 4 | # In[2]: 5 | 6 | import keras 7 | import scipy as sp 8 | import scipy.misc, scipy.ndimage.interpolation 9 | from medpy import metric 10 | import numpy as np 11 | import os 12 | from keras import losses 13 | import tensorflow as tf 14 | from keras.models import Model 15 | from keras.layers import Input,merge, concatenate, Conv2D, MaxPooling2D, Activation, UpSampling2D,Dropout,Conv2DTranspose,add,multiply 16 | from keras.layers.normalization import BatchNormalization as bn 17 | from keras.callbacks import ModelCheckpoint, TensorBoard 18 | from keras.optimizers import RMSprop 19 | from keras import regularizers 20 | from keras import backend as K 21 | from keras.optimizers import Adam 22 | from keras.callbacks import ModelCheckpoint 23 | import numpy as np 24 | import nibabel as nib 25 | CUDA_VISIBLE_DEVICES = [1] 26 | os.environ['CUDA_VISIBLE_DEVICES']=','.join([str(x) for x in CUDA_VISIBLE_DEVICES]) 27 | #oasis files 1-457 28 | # Please see line 1541 for the main essence of complementary network - i.e. summing up the intermediate outputs and then concatenating them for reconstruction layer 29 | #Hyper parameters to be set - 30 | #l2_Lambda - used for regularizing/penalizing parameters of the current layer 31 | #Mainly used to prevent overfitting and is incorporated in the loss function 32 | #Please see keras.io for more details 33 | #DropP sets the % of dropout at the end of every dense block 34 | #Kernel_size is the kernel size of the convolution filters 35 | #Please see readme for additional resources. 36 | #Lines 73 - 648 is the common encoder of the segmentation and complementary branches. 37 | #Layers such as xconv1a,xmerge1........ belong to the complementary upsampling branch branch of the architecture. 38 | #The convolution layers's number indicates its level and so up6 and xup6 are at the same level 39 | #and are parallel to each other 40 | #Layers such as xxconv1a,xxmerge1 .... belong to the reconstruction branch. 41 | #for more details of the multi outputs please see my isbi repository here 42 | #https://github.com/raun1/ISBI2018-Diagnostic-Classification-Of-Lung-Nodules-Using-3D-Neural-Networks 43 | #Basically to summarize, we have two branches one which has negative dice with ground truth brain mask 44 | #and is the segmentation branch 45 | #We then have another branch with positive dice with ground truth masks 46 | #The THEME of comp-net is to sum up the two sections, future works will provide a better way to do this and a generalized version :) 47 | #We do this theme of summing at every stage of the intermediate outputs i.e. the first intermediate output of segmentation branch 48 | #is summed with first intermediate output of the complementary branch. 49 | #We obtain a final summary of the outputs of the segmentation branch and complementary branch and also sum these two new summaries 50 | #Finally we concat all of these summations and send to the reconstruction branch 51 | #reconstruction branch is a simple structure of dense multi-output U-Net and the ground truth is the input image and loss is MSE. 52 | 53 | 54 | # In[3]: 55 | 56 | import numpy as np 57 | import cv2 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | #Dice coefficient 66 | 67 | smooth = 1. 68 | def dice_coef(y_true, y_pred): 69 | y_true_f = K.flatten(y_true) 70 | y_pred_f = K.flatten(y_pred) 71 | intersection = K.sum(y_true_f * y_pred_f) 72 | return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth) 73 | 74 | # Negative dice to obtain region of interest (ROI-Branch loss) 75 | def dice_coef_loss(y_true, y_pred): 76 | return -dice_coef(y_true, y_pred) 77 | 78 | # Positive dice to minimize overlap with region of interest (Complementary branch (CO) loss) 79 | def neg_dice_coef_loss(y_true, y_pred): 80 | return dice_coef(y_true, y_pred) 81 | 82 | 83 | 84 | def CompNet(input_shape,learn_rate=1e-3): 85 | l2_lambda = 0.0002 86 | DropP = 0.3 87 | kernel_size=3 88 | 89 | inputs = Input(input_shape) 90 | 91 | conv1a = Conv2D( 12, (kernel_size, kernel_size), activation='relu', padding='same', 92 | kernel_regularizer=regularizers.l2(l2_lambda) )(inputs) 93 | 94 | 95 | conv1a = bn()(conv1a) 96 | 97 | conv1b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 98 | kernel_regularizer=regularizers.l2(l2_lambda) )(conv1a) 99 | 100 | conv1b = bn()(conv1b) 101 | 102 | merge1=concatenate([conv1a,conv1b]) 103 | 104 | conv1c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 105 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 106 | 107 | conv1c = bn()(conv1c) 108 | 109 | merge2=concatenate([conv1a,conv1b,conv1c]) 110 | 111 | conv1d = Conv2D(32, (kernel_size, kernel_size), activation='relu', padding='same', 112 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 113 | 114 | conv1d = bn()(conv1d) 115 | 116 | 117 | pool1 = MaxPooling2D(pool_size=(2, 2))(conv1d) 118 | 119 | pool1 = Dropout(DropP)(pool1) 120 | 121 | 122 | 123 | 124 | 125 | conv2a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 126 | kernel_regularizer=regularizers.l2(l2_lambda) )(pool1) 127 | 128 | conv2a = bn()(conv2a) 129 | 130 | conv2b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 131 | kernel_regularizer=regularizers.l2(l2_lambda) )(conv2a) 132 | 133 | conv2b = bn()(conv2b) 134 | 135 | merge1=concatenate([conv2a,conv2b]) 136 | 137 | conv2c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 138 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 139 | 140 | conv2c = bn()(conv2c) 141 | 142 | merge2=concatenate([conv2a,conv2b,conv2c]) 143 | 144 | conv2d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 145 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 146 | 147 | conv2d = bn()(conv2d) 148 | 149 | 150 | merge3=concatenate([conv2a,conv2b,conv2c,conv2d]) 151 | 152 | 153 | 154 | conv2e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 155 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 156 | 157 | conv2e = bn()(conv2e) 158 | 159 | merge4=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e]) 160 | 161 | 162 | conv2f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 163 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 164 | 165 | conv2f = bn()(conv2f) 166 | 167 | 168 | merge5=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f]) 169 | 170 | conv2g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 171 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 172 | 173 | conv2g = bn()(conv2g) 174 | 175 | merge6=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f,conv2g]) 176 | 177 | 178 | conv2h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 179 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 180 | 181 | conv2h = bn()(conv2h) 182 | 183 | merge7=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f,conv2g,conv2h]) 184 | 185 | 186 | conv2i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 187 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 188 | 189 | conv2i = bn()(conv2g) 190 | 191 | merge8=concatenate([conv2a,conv2b,conv2c,conv2d,conv2e,conv2f,conv2g,conv2h,conv2i]) 192 | 193 | conv2j = Conv2D(64, (kernel_size, kernel_size), activation='relu', padding='same', 194 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 195 | 196 | conv2j = bn()(conv2g) 197 | 198 | 199 | pool2 = MaxPooling2D(pool_size=(2, 2))(conv2j) 200 | 201 | pool2 = Dropout(DropP)(pool2) 202 | 203 | 204 | 205 | 206 | 207 | 208 | 209 | conv3a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 210 | kernel_regularizer=regularizers.l2(l2_lambda) )(pool2) 211 | 212 | conv3a = bn()(conv3a) 213 | 214 | conv3b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 215 | kernel_regularizer=regularizers.l2(l2_lambda) )(conv3a) 216 | 217 | conv3b = bn()(conv3b) 218 | 219 | merge1=concatenate([conv3a,conv3b]) 220 | 221 | conv3c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 222 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 223 | 224 | conv3c = bn()(conv3c) 225 | 226 | merge2=concatenate([conv3a,conv3b,conv3c]) 227 | 228 | conv3d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 229 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 230 | 231 | conv3d = bn()(conv3d) 232 | 233 | 234 | merge3=concatenate([conv3a,conv3b,conv3c,conv3d]) 235 | 236 | 237 | 238 | conv3e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 239 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 240 | 241 | conv3e = bn()(conv3e) 242 | 243 | merge4=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e]) 244 | 245 | 246 | conv3f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 247 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 248 | 249 | conv3f = bn()(conv3f) 250 | 251 | 252 | merge5=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f]) 253 | 254 | conv3g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 255 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 256 | 257 | conv3g = bn()(conv3g) 258 | 259 | merge6=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g]) 260 | 261 | 262 | conv3h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 263 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 264 | 265 | conv3h = bn()(conv3h) 266 | 267 | merge7=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h]) 268 | 269 | 270 | conv3i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 271 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 272 | 273 | conv3i = bn()(conv3i) 274 | 275 | merge8=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i]) 276 | 277 | conv3j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 278 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 279 | 280 | conv3j = bn()(conv3j) 281 | 282 | 283 | merge9=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j]) 284 | 285 | 286 | conv3k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 287 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 288 | 289 | conv3k = bn()(conv3k) 290 | 291 | 292 | merge10=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k]) 293 | conv3l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 294 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 295 | conv3l = bn()(conv3l) 296 | 297 | merge11=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l]) 298 | conv3m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 299 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 300 | conv3m = bn()(conv3m) 301 | 302 | 303 | merge12=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m]) 304 | conv3n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 305 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 306 | conv3n = bn()(conv3n) 307 | 308 | 309 | 310 | 311 | merge13=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n]) 312 | conv3o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 313 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 314 | conv3o = bn()(conv3o) 315 | 316 | 317 | 318 | merge14=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o]) 319 | conv3p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 320 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 321 | conv3p = bn()(conv3p) 322 | 323 | 324 | merge15=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p]) 325 | conv3q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 326 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 327 | conv3q = bn()(conv3q) 328 | 329 | 330 | merge16=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q]) 331 | conv3r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 332 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 333 | conv3r = bn()(conv3r) 334 | 335 | 336 | merge17=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q,conv3r]) 337 | conv3s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 338 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 339 | conv3s = bn()(conv3s) 340 | 341 | 342 | merge18=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q,conv3r,conv3s]) 343 | conv3t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 344 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 345 | conv3t = bn()(conv3t) 346 | 347 | merge19=concatenate([conv3a,conv3b,conv3c,conv3d,conv3e,conv3f,conv3g,conv3h,conv3i,conv3j,conv3k,conv3l,conv3m,conv3n,conv3o,conv3p,conv3q,conv3r,conv3s,conv3t]) 348 | conv3u=Conv2D(128, (kernel_size, kernel_size), activation='relu', padding='same', 349 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 350 | conv3u = bn()(conv3u) 351 | 352 | 353 | pool3 = MaxPooling2D(pool_size=(2, 2))(conv3u) 354 | 355 | pool3 = Dropout(DropP)(pool3) 356 | 357 | 358 | conv4a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 359 | kernel_regularizer=regularizers.l2(l2_lambda) )(pool3) 360 | 361 | conv4a = bn()(conv4a) 362 | 363 | conv4b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 364 | kernel_regularizer=regularizers.l2(l2_lambda) )(conv4a) 365 | 366 | conv4b = bn()(conv4b) 367 | 368 | merge1=concatenate([conv4a,conv4b]) 369 | 370 | conv4c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 371 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 372 | 373 | conv4c = bn()(conv4c) 374 | 375 | merge2=concatenate([conv4a,conv4b,conv4c]) 376 | 377 | conv4d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 378 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 379 | 380 | conv4d = bn()(conv4d) 381 | 382 | 383 | merge3=concatenate([conv4a,conv4b,conv4c,conv4d]) 384 | 385 | 386 | 387 | conv4e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 388 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 389 | 390 | conv4e = bn()(conv4e) 391 | 392 | merge4=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e]) 393 | 394 | 395 | conv4f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 396 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 397 | 398 | conv4f = bn()(conv4f) 399 | 400 | 401 | merge5=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f]) 402 | 403 | conv4g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 404 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 405 | 406 | conv4g = bn()(conv4g) 407 | 408 | merge6=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g]) 409 | 410 | 411 | conv4h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 412 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 413 | 414 | conv4h = bn()(conv4h) 415 | 416 | merge7=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h]) 417 | 418 | 419 | conv4i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 420 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 421 | 422 | conv4i = bn()(conv4i) 423 | 424 | merge8=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i]) 425 | 426 | conv4j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 427 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 428 | 429 | conv4j = bn()(conv4j) 430 | 431 | 432 | merge9=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j]) 433 | 434 | 435 | conv4k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 436 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 437 | 438 | conv4k = bn()(conv4k) 439 | 440 | 441 | merge10=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k]) 442 | conv4l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 443 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 444 | conv4l = bn()(conv4l) 445 | 446 | merge11=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l]) 447 | conv4m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 448 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 449 | conv4m = bn()(conv4m) 450 | 451 | 452 | merge12=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m]) 453 | conv4n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 454 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 455 | conv4n = bn()(conv4n) 456 | 457 | 458 | 459 | 460 | merge13=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m,conv4n]) 461 | conv4o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 462 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 463 | conv4o = bn()(conv4o) 464 | 465 | 466 | 467 | merge14=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m,conv4n,conv4o]) 468 | conv4p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 469 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 470 | conv4p = bn()(conv4p) 471 | 472 | 473 | merge15=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m,conv4n,conv4o,conv4p]) 474 | conv4q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 475 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 476 | conv4q = bn()(conv4q) 477 | 478 | 479 | merge16=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m,conv4n,conv4o,conv4p,conv4q]) 480 | conv4r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 481 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 482 | conv4r = bn()(conv4r) 483 | 484 | 485 | merge17=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m,conv4n,conv4o,conv4p,conv4q,conv4r]) 486 | conv4s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 487 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 488 | conv4s = bn()(conv4s) 489 | 490 | 491 | merge18=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m,conv4n,conv4o,conv4p,conv4q,conv4r,conv4s]) 492 | conv4t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 493 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 494 | conv4t = bn()(conv4t) 495 | 496 | merge19=concatenate([conv4a,conv4b,conv4c,conv4d,conv4e,conv4f,conv4g,conv4h,conv4i,conv4j,conv4k,conv4l,conv4m,conv4n,conv4o,conv4p,conv4q,conv4r,conv4s,conv4t]) 497 | conv4u=Conv2D(256, (kernel_size, kernel_size), activation='relu', padding='same', 498 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 499 | conv4u = bn()(conv4u) 500 | 501 | pool4 = MaxPooling2D(pool_size=(2, 2))(conv4u) 502 | 503 | pool4 = Dropout(DropP)(pool4) 504 | 505 | 506 | 507 | 508 | 509 | conv5a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 510 | kernel_regularizer=regularizers.l2(l2_lambda) )(pool4) 511 | 512 | conv5a = bn()(conv5a) 513 | 514 | conv5b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 515 | kernel_regularizer=regularizers.l2(l2_lambda) )(conv5a) 516 | 517 | conv5b = bn()(conv5b) 518 | 519 | merge1=concatenate([conv5a,conv5b]) 520 | 521 | conv5c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 522 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 523 | 524 | conv5c = bn()(conv5c) 525 | 526 | merge2=concatenate([conv5a,conv5b,conv5c]) 527 | 528 | conv5d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 529 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 530 | 531 | conv5d = bn()(conv5d) 532 | 533 | 534 | merge3=concatenate([conv5a,conv5b,conv5c,conv5d]) 535 | 536 | 537 | 538 | conv5e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 539 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 540 | 541 | conv5e = bn()(conv5e) 542 | 543 | merge4=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e]) 544 | 545 | 546 | conv5f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 547 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 548 | 549 | conv5f = bn()(conv5f) 550 | 551 | 552 | merge5=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f]) 553 | 554 | conv5g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 555 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 556 | 557 | conv5g = bn()(conv5g) 558 | 559 | merge6=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g]) 560 | 561 | 562 | conv5h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 563 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 564 | 565 | conv5h = bn()(conv5h) 566 | 567 | merge7=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h]) 568 | 569 | 570 | conv5i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 571 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 572 | 573 | conv5i = bn()(conv5i) 574 | 575 | merge8=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i]) 576 | 577 | conv5j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 578 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 579 | 580 | conv5j = bn()(conv5j) 581 | 582 | 583 | merge9=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j]) 584 | 585 | 586 | conv5k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 587 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 588 | 589 | conv5k = bn()(conv5k) 590 | 591 | 592 | merge10=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k]) 593 | conv5l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 594 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 595 | conv5l = bn()(conv5l) 596 | 597 | merge11=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l]) 598 | conv5m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 599 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 600 | conv5m = bn()(conv5m) 601 | 602 | 603 | merge12=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m]) 604 | conv5n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 605 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 606 | conv5n = bn()(conv5n) 607 | 608 | 609 | 610 | 611 | merge13=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m,conv5n]) 612 | conv5o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 613 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 614 | conv5o = bn()(conv5o) 615 | 616 | 617 | 618 | merge14=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m,conv5n,conv5o]) 619 | conv5p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 620 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 621 | conv5p = bn()(conv5p) 622 | 623 | 624 | merge15=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m,conv5n,conv5o,conv5p]) 625 | conv5q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 626 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 627 | conv5q = bn()(conv5q) 628 | 629 | 630 | merge16=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m,conv5n,conv5o,conv5p,conv5q]) 631 | conv5r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 632 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 633 | conv5r = bn()(conv5r) 634 | 635 | 636 | merge17=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m,conv5n,conv5o,conv5p,conv5q,conv5r]) 637 | conv5s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 638 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 639 | conv5s = bn()(conv5s) 640 | 641 | 642 | merge18=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m,conv5n,conv5o,conv5p,conv5q,conv5r,conv5s]) 643 | conv5t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 644 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 645 | conv5t = bn()(conv5t) 646 | 647 | merge19=concatenate([conv5a,conv5b,conv5c,conv5d,conv5e,conv5f,conv5g,conv5h,conv5i,conv5j,conv5k,conv5l,conv5m,conv5n,conv5o,conv5p,conv5q,conv5r,conv5s,conv5t]) 648 | conv5u=Conv2D(512, (kernel_size, kernel_size), activation='relu', padding='same', 649 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 650 | conv5u = bn()(conv5u) 651 | 652 | 653 | 654 | 655 | up6 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(conv5u), conv4u],name='up6', axis=3) 656 | 657 | out6=Conv2DTranspose(12,(2, 2), strides=(8, 8), padding='same')(up6) 658 | out6 = bn()(out6) 659 | output1 = Conv2D(1, (1, 1), activation='sigmoid',name='output1')(out6) 660 | 661 | up6 = Dropout(DropP)(up6) 662 | 663 | conv6a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 664 | kernel_regularizer=regularizers.l2(l2_lambda) )(up6) 665 | 666 | conv6a = bn()(conv6a) 667 | 668 | merge0=concatenate([up6,conv6a]) 669 | 670 | conv6b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 671 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 672 | 673 | conv6b = bn()(conv6b) 674 | 675 | merge1=concatenate([up6,conv6a,conv6b]) 676 | 677 | conv6c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 678 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 679 | 680 | conv6c = bn()(conv6c) 681 | 682 | merge2=concatenate([up6,conv6a,conv6b,conv6c]) 683 | 684 | conv6d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 685 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 686 | 687 | conv6d = bn()(conv6d) 688 | 689 | 690 | merge3=concatenate([up6,conv6a,conv6b,conv6c,conv6d]) 691 | 692 | 693 | conv6e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 694 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 695 | 696 | conv6e = bn()(conv6e) 697 | 698 | merge4=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e]) 699 | 700 | 701 | conv6f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 702 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 703 | 704 | conv6f = bn()(conv6f) 705 | 706 | 707 | merge5=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f]) 708 | 709 | conv6g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 710 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 711 | 712 | conv6g = bn()(conv6g) 713 | 714 | merge6=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g]) 715 | 716 | 717 | conv6h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 718 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 719 | 720 | conv6h = bn()(conv6h) 721 | 722 | merge7=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h]) 723 | 724 | 725 | conv6i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 726 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 727 | 728 | conv6i = bn()(conv6i) 729 | 730 | merge8=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i]) 731 | 732 | conv6j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 733 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 734 | 735 | conv6j = bn()(conv6j) 736 | 737 | 738 | merge9=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j]) 739 | 740 | 741 | conv6k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 742 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 743 | 744 | conv6k = bn()(conv6k) 745 | 746 | 747 | merge10=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k]) 748 | conv6l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 749 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 750 | conv6l = bn()(conv6l) 751 | 752 | merge11=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l]) 753 | conv6m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 754 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 755 | conv6m = bn()(conv6m) 756 | 757 | 758 | merge12=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m]) 759 | conv6n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 760 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 761 | conv6n = bn()(conv6n) 762 | 763 | 764 | 765 | 766 | merge13=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m,conv6n]) 767 | conv6o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 768 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 769 | conv6o = bn()(conv6o) 770 | 771 | 772 | 773 | merge14=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m,conv6n,conv6o]) 774 | conv6p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 775 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 776 | conv6p = bn()(conv6p) 777 | 778 | 779 | merge15=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m,conv6n,conv6o,conv6p]) 780 | conv6q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 781 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 782 | conv6q = bn()(conv6q) 783 | 784 | 785 | merge16=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m,conv6n,conv6o,conv6p,conv6q]) 786 | conv6r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 787 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 788 | conv6r = bn()(conv6r) 789 | 790 | 791 | merge17=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m,conv6n,conv6o,conv6p,conv6q,conv6r]) 792 | conv6s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 793 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 794 | conv6s = bn()(conv6s) 795 | 796 | 797 | merge18=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m,conv6n,conv6o,conv6p,conv6q,conv6r,conv6s]) 798 | conv6t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 799 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 800 | conv6t = bn()(conv6t) 801 | 802 | merge19=concatenate([up6,conv6a,conv6b,conv6c,conv6d,conv6e,conv6f,conv6g,conv6h,conv6i,conv6j,conv6k,conv6l,conv6m,conv6n,conv6o,conv6p,conv6q,conv6r,conv6s,conv6t]) 803 | conv6u=Conv2D(256, (kernel_size, kernel_size), activation='relu', padding='same', 804 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 805 | conv6u = bn()(conv6u) 806 | 807 | 808 | 809 | 810 | 811 | up7 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(conv6u), conv3u],name='up7', axis=3) 812 | 813 | up7 = Dropout(DropP)(up7) 814 | #add second output here 815 | out7=Conv2DTranspose(12,(2, 2), strides=(4, 4), padding='same')(up7) 816 | out7 = bn()(out7) 817 | output2 = Conv2D(1, (1, 1), activation='sigmoid',name='output2')(out7) 818 | conv7a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 819 | kernel_regularizer=regularizers.l2(l2_lambda) )(up7) 820 | 821 | conv7a = bn()(conv7a) 822 | 823 | merge0=concatenate([up7,conv7a]) 824 | 825 | conv7b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 826 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 827 | 828 | conv7b = bn()(conv7b) 829 | 830 | merge1=concatenate([up7,conv7a,conv7b]) 831 | 832 | conv7c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 833 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 834 | 835 | conv7c = bn()(conv7c) 836 | 837 | merge2=concatenate([up7,conv7a,conv7b,conv7c]) 838 | 839 | conv7d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 840 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 841 | 842 | conv7d = bn()(conv7d) 843 | 844 | 845 | merge3=concatenate([up7,conv7a,conv7b,conv7c,conv7d]) 846 | 847 | 848 | 849 | conv7e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 850 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 851 | 852 | conv7e = bn()(conv7e) 853 | 854 | merge4=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e]) 855 | 856 | 857 | conv7f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 858 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 859 | 860 | conv7f = bn()(conv7f) 861 | 862 | 863 | merge5=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f]) 864 | 865 | conv7g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 866 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 867 | 868 | conv7g = bn()(conv7g) 869 | 870 | merge6=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g]) 871 | 872 | 873 | conv7h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 874 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 875 | 876 | conv7h = bn()(conv7h) 877 | 878 | merge7=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h]) 879 | 880 | 881 | conv7i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 882 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 883 | 884 | conv7i = bn()(conv7i) 885 | 886 | merge8=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i]) 887 | 888 | conv7j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 889 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 890 | 891 | conv7j = bn()(conv7j) 892 | 893 | 894 | merge9=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j]) 895 | 896 | 897 | conv7k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 898 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 899 | 900 | conv7k = bn()(conv7k) 901 | 902 | 903 | merge10=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k]) 904 | conv7l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 905 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 906 | conv7l = bn()(conv7l) 907 | 908 | merge11=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l]) 909 | conv7m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 910 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 911 | conv7m = bn()(conv7m) 912 | 913 | 914 | merge12=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m]) 915 | conv7n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 916 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 917 | conv7n = bn()(conv7n) 918 | 919 | 920 | 921 | 922 | merge13=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m,conv7n]) 923 | conv7o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 924 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 925 | conv7o = bn()(conv7o) 926 | 927 | 928 | 929 | merge14=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m,conv7n,conv7o]) 930 | conv7p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 931 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 932 | conv7p = bn()(conv7p) 933 | 934 | 935 | merge15=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m,conv7n,conv7o,conv7p]) 936 | conv7q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 937 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 938 | conv7q = bn()(conv7q) 939 | 940 | 941 | merge16=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m,conv7n,conv7o,conv7p,conv7q]) 942 | conv7r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 943 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 944 | conv7r = bn()(conv7r) 945 | 946 | 947 | merge17=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m,conv7n,conv7o,conv7p,conv7q,conv7r]) 948 | conv7s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 949 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 950 | conv7s = bn()(conv7s) 951 | 952 | 953 | merge18=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m,conv7n,conv7o,conv7p,conv7q,conv7r,conv7s]) 954 | conv7t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 955 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 956 | conv7t = bn()(conv7t) 957 | 958 | merge19=concatenate([up7,conv7a,conv7b,conv7c,conv7d,conv7e,conv7f,conv7g,conv7h,conv7i,conv7j,conv7k,conv7l,conv7m,conv7n,conv7o,conv7p,conv7q,conv7r,conv7s,conv7t]) 959 | conv7u=Conv2D(128, (kernel_size, kernel_size), activation='relu', padding='same', 960 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 961 | conv7u = bn()(conv7u) 962 | 963 | 964 | 965 | 966 | up8 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(conv7u), conv2j],name='up8', axis=3) 967 | 968 | up8 = Dropout(DropP)(up8) 969 | #add third outout here 970 | out8=Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(up8) 971 | out8 = bn()(out8) 972 | output3 = Conv2D(1, (1, 1), activation='sigmoid',name='output3')(out8) 973 | conv8a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 974 | kernel_regularizer=regularizers.l2(l2_lambda) )(up8) 975 | 976 | conv8a = bn()(conv8a) 977 | 978 | merge0=concatenate([up8,conv8a]) 979 | 980 | conv8b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 981 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 982 | 983 | conv8b = bn()(conv8b) 984 | 985 | merge1=concatenate([up8,conv8a,conv8b]) 986 | 987 | conv8c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 988 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 989 | 990 | conv8c = bn()(conv8c) 991 | 992 | merge2=concatenate([up8,conv8a,conv8b,conv8c]) 993 | 994 | conv8d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 995 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 996 | 997 | conv8d = bn()(conv8d) 998 | 999 | 1000 | merge3=concatenate([up8,conv8a,conv8b,conv8c,conv8d]) 1001 | 1002 | 1003 | 1004 | conv8e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1005 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1006 | 1007 | conv8e = bn()(conv8e) 1008 | 1009 | merge4=concatenate([up8,conv8a,conv8b,conv8c,conv8d,conv8e]) 1010 | 1011 | 1012 | conv8f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1013 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 1014 | 1015 | conv8f = bn()(conv8f) 1016 | 1017 | 1018 | merge5=concatenate([up8,conv8a,conv8b,conv8c,conv8d,conv8e,conv8f]) 1019 | 1020 | conv8g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1021 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 1022 | 1023 | conv8g = bn()(conv8g) 1024 | 1025 | merge6=concatenate([up8,conv8a,conv8b,conv8c,conv8d,conv8e,conv8f,conv8g]) 1026 | 1027 | 1028 | conv8h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1029 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 1030 | 1031 | conv8h = bn()(conv8h) 1032 | 1033 | merge7=concatenate([up8,conv8a,conv8b,conv8c,conv8d,conv8e,conv8f,conv8g,conv8h]) 1034 | 1035 | 1036 | conv8i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1037 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 1038 | 1039 | conv8i = bn()(conv8i) 1040 | 1041 | merge8=concatenate([up8,conv8a,conv8b,conv8c,conv8d,conv8e,conv8f,conv8g,conv8h,conv8i]) 1042 | 1043 | conv8j = Conv2D(64, (kernel_size, kernel_size), activation='relu', padding='same', 1044 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 1045 | 1046 | conv8j = bn()(conv8j) 1047 | 1048 | 1049 | 1050 | up9 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(conv8j), conv1d],name='up9',axis=3) 1051 | 1052 | up9 = Dropout(DropP)(up9) 1053 | out9=Conv2DTranspose(12,(2, 2), strides=(1, 1), padding='same')(up9) 1054 | out9 = bn()(out9) 1055 | output4 = Conv2D(1, (1, 1), activation='sigmoid',name='output4')(out9) 1056 | 1057 | conv9a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1058 | kernel_regularizer=regularizers.l2(l2_lambda) )(up9) 1059 | 1060 | conv9a = bn()(conv9a) 1061 | 1062 | merge0=concatenate([up9,conv9a]) 1063 | 1064 | conv9b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1065 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 1066 | 1067 | conv9b = bn()(conv9b) 1068 | 1069 | merge1=concatenate([up9,conv9a,conv9b]) 1070 | 1071 | conv9c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1072 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1073 | 1074 | conv9c = bn()(conv9c) 1075 | 1076 | merge2=concatenate([up9,conv9a,conv9b,conv9c]) 1077 | 1078 | conv9d = Conv2D(32, (kernel_size, kernel_size), activation='relu', padding='same', 1079 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1080 | 1081 | conv9d = bn()(conv9d) 1082 | 1083 | 1084 | conv10 = Conv2D(1, (1, 1), activation='sigmoid',name='conv10')(conv9d) 1085 | 1086 | finalmerge=concatenate([out6,out7,out8,out9,conv9d]) 1087 | 1088 | final_op=Conv2D(1, (1, 1), activation='sigmoid',name='final_op')(finalmerge) 1089 | 1090 | # model = Model(inputs=inputs, outputs=[out6,out7,out8,out9,conv10,final_op]) 1091 | 1092 | 1093 | 1094 | 1095 | 1096 | #second branch - brain 1097 | xup6 = concatenate([Conv2DTranspose(24,(2, 2), strides=(2, 2), padding='same')(conv5u), conv4u],name='xup6', axis=3) 1098 | 1099 | xout6=Conv2DTranspose(24,(2, 2), strides=(8, 8), padding='same')(xup6) 1100 | xout6 = bn()(xout6) 1101 | xoutput1 = Conv2D(1, (1, 1), activation='sigmoid',name='xoutput1')(xout6) 1102 | 1103 | xup6 = Dropout(DropP)(xup6) 1104 | 1105 | xconv6a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1106 | kernel_regularizer=regularizers.l2(l2_lambda) )(xup6) 1107 | 1108 | xconv6a = bn()(xconv6a) 1109 | 1110 | merge0=concatenate([xup6,xconv6a]) 1111 | 1112 | xconv6b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1113 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 1114 | 1115 | xconv6b = bn()(xconv6b) 1116 | 1117 | merge1=concatenate([xup6,xconv6a,xconv6b]) 1118 | 1119 | xconv6c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1120 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1121 | 1122 | xconv6c = bn()(xconv6c) 1123 | 1124 | merge2=concatenate([xup6,xconv6a,xconv6b,xconv6c]) 1125 | 1126 | xconv6d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1127 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1128 | 1129 | xconv6d = bn()(xconv6d) 1130 | 1131 | 1132 | merge3=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d]) 1133 | 1134 | 1135 | 1136 | xconv6e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1137 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1138 | 1139 | xconv6e = bn()(xconv6e) 1140 | 1141 | merge4=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e]) 1142 | 1143 | 1144 | xconv6f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1145 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 1146 | 1147 | xconv6f = bn()(xconv6f) 1148 | 1149 | 1150 | merge5=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f]) 1151 | 1152 | xconv6g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1153 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 1154 | 1155 | xconv6g = bn()(xconv6g) 1156 | 1157 | merge6=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g]) 1158 | 1159 | 1160 | xconv6h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1161 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 1162 | 1163 | xconv6h = bn()(xconv6h) 1164 | 1165 | merge7=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h]) 1166 | 1167 | 1168 | xconv6i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1169 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 1170 | 1171 | xconv6i = bn()(xconv6i) 1172 | 1173 | merge8=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i]) 1174 | 1175 | xconv6j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1176 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 1177 | 1178 | xconv6j = bn()(xconv6j) 1179 | 1180 | 1181 | merge9=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j]) 1182 | 1183 | 1184 | xconv6k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1185 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 1186 | 1187 | xconv6k = bn()(xconv6k) 1188 | 1189 | 1190 | merge10=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k]) 1191 | xconv6l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1192 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 1193 | xconv6l = bn()(xconv6l) 1194 | 1195 | merge11=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l]) 1196 | xconv6m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1197 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 1198 | xconv6m = bn()(xconv6m) 1199 | 1200 | 1201 | merge12=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m]) 1202 | xconv6n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1203 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 1204 | xconv6n = bn()(xconv6n) 1205 | 1206 | 1207 | 1208 | 1209 | merge13=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m,xconv6n]) 1210 | xconv6o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1211 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 1212 | xconv6o = bn()(xconv6o) 1213 | 1214 | 1215 | 1216 | merge14=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m,xconv6n,xconv6o]) 1217 | xconv6p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1218 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 1219 | xconv6p = bn()(xconv6p) 1220 | 1221 | 1222 | merge15=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m,xconv6n,xconv6o,xconv6p]) 1223 | xconv6q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1224 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 1225 | xconv6q = bn()(xconv6q) 1226 | 1227 | 1228 | merge16=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m,xconv6n,xconv6o,xconv6p,xconv6q]) 1229 | xconv6r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1230 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 1231 | xconv6r = bn()(xconv6r) 1232 | 1233 | 1234 | merge17=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m,xconv6n,xconv6o,xconv6p,xconv6q,xconv6r]) 1235 | xconv6s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1236 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 1237 | xconv6s = bn()(xconv6s) 1238 | 1239 | 1240 | merge18=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m,xconv6n,xconv6o,xconv6p,xconv6q,xconv6r,xconv6s]) 1241 | xconv6t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1242 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 1243 | xconv6t = bn()(xconv6t) 1244 | 1245 | merge19=concatenate([xup6,xconv6a,xconv6b,xconv6c,xconv6d,xconv6e,xconv6f,xconv6g,xconv6h,xconv6i,xconv6j,xconv6k,xconv6l,xconv6m,xconv6n,xconv6o,xconv6p,xconv6q,xconv6r,xconv6s,xconv6t]) 1246 | xconv6u=Conv2D(256, (kernel_size, kernel_size), activation='relu', padding='same', 1247 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 1248 | xconv6u = bn()(xconv6u) 1249 | 1250 | 1251 | 1252 | 1253 | 1254 | xup7 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xconv6u), conv3u],name='xup7', axis=3) 1255 | 1256 | xup7 = Dropout(DropP)(xup7) 1257 | #add second xoutput here 1258 | xout7=Conv2DTranspose(12,(2, 2), strides=(4, 4), padding='same')(xup7) 1259 | xout7 = bn()(xout7) 1260 | xoutput2 = Conv2D(1, (1, 1), activation='sigmoid',name='xoutput2')(xout7) 1261 | xconv7a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1262 | kernel_regularizer=regularizers.l2(l2_lambda) )(xup7) 1263 | 1264 | xconv7a = bn()(xconv7a) 1265 | 1266 | merge0=concatenate([xup7,xconv7a]) 1267 | 1268 | xconv7b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1269 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 1270 | 1271 | xconv7b = bn()(xconv7b) 1272 | 1273 | merge1=concatenate([xup7,xconv7a,xconv7b]) 1274 | 1275 | xconv7c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1276 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1277 | 1278 | xconv7c = bn()(xconv7c) 1279 | 1280 | merge2=concatenate([xup7,xconv7a,xconv7b,xconv7c]) 1281 | 1282 | xconv7d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1283 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1284 | 1285 | xconv7d = bn()(xconv7d) 1286 | 1287 | 1288 | merge3=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d]) 1289 | 1290 | 1291 | 1292 | xconv7e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1293 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1294 | 1295 | xconv7e = bn()(xconv7e) 1296 | 1297 | merge4=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e]) 1298 | 1299 | 1300 | xconv7f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1301 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 1302 | 1303 | xconv7f = bn()(xconv7f) 1304 | 1305 | 1306 | merge5=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f]) 1307 | 1308 | xconv7g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1309 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 1310 | 1311 | xconv7g = bn()(xconv7g) 1312 | 1313 | merge6=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g]) 1314 | 1315 | 1316 | xconv7h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1317 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 1318 | 1319 | xconv7h = bn()(xconv7h) 1320 | 1321 | merge7=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h]) 1322 | 1323 | 1324 | xconv7i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1325 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 1326 | 1327 | xconv7i = bn()(xconv7i) 1328 | 1329 | merge8=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i]) 1330 | 1331 | xconv7j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1332 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 1333 | 1334 | xconv7j = bn()(xconv7j) 1335 | 1336 | 1337 | merge9=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j]) 1338 | 1339 | 1340 | xconv7k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1341 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 1342 | 1343 | xconv7k = bn()(xconv7k) 1344 | 1345 | 1346 | merge10=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k]) 1347 | xconv7l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1348 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 1349 | xconv7l = bn()(xconv7l) 1350 | 1351 | merge11=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l]) 1352 | xconv7m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1353 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 1354 | xconv7m = bn()(xconv7m) 1355 | 1356 | 1357 | merge12=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m]) 1358 | xconv7n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1359 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 1360 | xconv7n = bn()(xconv7n) 1361 | 1362 | 1363 | 1364 | 1365 | merge13=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m,xconv7n]) 1366 | xconv7o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1367 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 1368 | xconv7o = bn()(xconv7o) 1369 | 1370 | 1371 | 1372 | merge14=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m,xconv7n,xconv7o]) 1373 | xconv7p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1374 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 1375 | xconv7p = bn()(xconv7p) 1376 | 1377 | 1378 | merge15=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m,xconv7n,xconv7o,xconv7p]) 1379 | xconv7q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1380 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 1381 | xconv7q = bn()(xconv7q) 1382 | 1383 | 1384 | merge16=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m,xconv7n,xconv7o,xconv7p,xconv7q]) 1385 | xconv7r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1386 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 1387 | xconv7r = bn()(xconv7r) 1388 | 1389 | 1390 | merge17=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m,xconv7n,xconv7o,xconv7p,xconv7q,xconv7r]) 1391 | xconv7s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1392 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 1393 | xconv7s = bn()(xconv7s) 1394 | 1395 | 1396 | merge18=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m,xconv7n,xconv7o,xconv7p,xconv7q,xconv7r,xconv7s]) 1397 | xconv7t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1398 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 1399 | xconv7t = bn()(xconv7t) 1400 | 1401 | merge19=concatenate([xup7,xconv7a,xconv7b,xconv7c,xconv7d,xconv7e,xconv7f,xconv7g,xconv7h,xconv7i,xconv7j,xconv7k,xconv7l,xconv7m,xconv7n,xconv7o,xconv7p,xconv7q,xconv7r,xconv7s,xconv7t]) 1402 | xconv7u=Conv2D(128, (kernel_size, kernel_size), activation='relu', padding='same', 1403 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 1404 | xconv7u = bn()(xconv7u) 1405 | 1406 | 1407 | 1408 | 1409 | xup8 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xconv7u), conv2j],name='xup8', axis=3) 1410 | 1411 | xup8 = Dropout(DropP)(xup8) 1412 | #add third xoutxout here 1413 | xout8=Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xup8) 1414 | xout8 = bn()(xout8) 1415 | xoutput3 = Conv2D(1, (1, 1), activation='sigmoid',name='xoutput3')(xout8) 1416 | xconv8a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1417 | kernel_regularizer=regularizers.l2(l2_lambda) )(xup8) 1418 | 1419 | xconv8a = bn()(xconv8a) 1420 | 1421 | merge0=concatenate([xup8,xconv8a]) 1422 | 1423 | xconv8b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1424 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 1425 | 1426 | xconv8b = bn()(xconv8b) 1427 | 1428 | merge1=concatenate([xup8,xconv8a,xconv8b]) 1429 | 1430 | xconv8c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1431 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1432 | 1433 | xconv8c = bn()(xconv8c) 1434 | 1435 | merge2=concatenate([xup8,xconv8a,xconv8b,xconv8c]) 1436 | 1437 | xconv8d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1438 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1439 | 1440 | xconv8d = bn()(xconv8d) 1441 | 1442 | 1443 | merge3=concatenate([xup8,xconv8a,xconv8b,xconv8c,xconv8d]) 1444 | 1445 | 1446 | 1447 | xconv8e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1448 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1449 | 1450 | xconv8e = bn()(xconv8e) 1451 | 1452 | merge4=concatenate([xup8,xconv8a,xconv8b,xconv8c,xconv8d,xconv8e]) 1453 | 1454 | 1455 | xconv8f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1456 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 1457 | 1458 | xconv8f = bn()(xconv8f) 1459 | 1460 | 1461 | merge5=concatenate([xup8,xconv8a,xconv8b,xconv8c,xconv8d,xconv8e,xconv8f]) 1462 | 1463 | xconv8g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1464 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 1465 | 1466 | xconv8g = bn()(xconv8g) 1467 | 1468 | merge6=concatenate([xup8,xconv8a,xconv8b,xconv8c,xconv8d,xconv8e,xconv8f,xconv8g]) 1469 | 1470 | 1471 | xconv8h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1472 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 1473 | 1474 | xconv8h = bn()(xconv8h) 1475 | 1476 | merge7=concatenate([xup8,xconv8a,xconv8b,xconv8c,xconv8d,xconv8e,xconv8f,xconv8g,xconv8h]) 1477 | 1478 | 1479 | xconv8i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1480 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 1481 | 1482 | xconv8i = bn()(xconv8i) 1483 | 1484 | merge8=concatenate([xup8,xconv8a,xconv8b,xconv8c,xconv8d,xconv8e,xconv8f,xconv8g,xconv8h,xconv8i]) 1485 | 1486 | xconv8j = Conv2D(64, (kernel_size, kernel_size), activation='relu', padding='same', 1487 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 1488 | 1489 | xconv8j = bn()(xconv8j) 1490 | 1491 | 1492 | 1493 | xup9 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xconv8j), conv1d],name='xup9',axis=3) 1494 | 1495 | xup9 = Dropout(DropP)(xup9) 1496 | xout9=Conv2DTranspose(12,(2, 2), strides=(1, 1), padding='same')(xup9) 1497 | xout9 = bn()(xout9) 1498 | xoutput4 = Conv2D(1, (1, 1), activation='sigmoid',name='xoutput4')(xout9) 1499 | 1500 | xconv9a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1501 | kernel_regularizer=regularizers.l2(l2_lambda) )(xup9) 1502 | 1503 | xconv9a = bn()(xconv9a) 1504 | 1505 | merge0=concatenate([xup9,xconv9a]) 1506 | 1507 | xconv9b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1508 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 1509 | 1510 | xconv9b = bn()(xconv9b) 1511 | 1512 | merge1=concatenate([xup9,xconv9a,xconv9b]) 1513 | 1514 | xconv9c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1515 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1516 | 1517 | xconv9c = bn()(xconv9c) 1518 | 1519 | merge2=concatenate([xup9,xconv9a,xconv9b,xconv9c]) 1520 | 1521 | xconv9d = Conv2D(32, (kernel_size, kernel_size), activation='relu', padding='same', 1522 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1523 | 1524 | xconv9d = bn()(xconv9d) 1525 | 1526 | 1527 | xconv10 = Conv2D(1, (1, 1), activation='sigmoid',name='xconv10')(xconv9d) 1528 | 1529 | xfinalmerge=concatenate([xout6,xout7,xout8,xout9,xconv9d]) 1530 | 1531 | xfinal_op=Conv2D(1, (1, 1), activation='sigmoid',name='xfinal_op')(xfinalmerge) 1532 | 1533 | 1534 | u_net_op0=keras.layers.add([final_op,xfinal_op]) 1535 | u_net_op1=keras.layers.add([conv10,xconv10]) 1536 | u_net_op2=keras.layers.add([output4,xoutput4]) 1537 | u_net_op3=keras.layers.add([output3,xoutput3]) 1538 | u_net_op4=keras.layers.add([output2,xoutput2]) 1539 | u_net_op5=keras.layers.add([output1,xoutput1]) 1540 | 1541 | #Concatenation fed to the reconstruction layer 1542 | u_net_op_merge=concatenate([u_net_op0,u_net_op1,u_net_op2,u_net_op3,u_net_op4,u_net_op5]) 1543 | 1544 | 1545 | 1546 | 1547 | 1548 | 1549 | xxconv1a = Conv2D( 12, (kernel_size, kernel_size), activation='relu', padding='same', 1550 | kernel_regularizer=regularizers.l2(l2_lambda) )(u_net_op_merge) 1551 | 1552 | 1553 | xxconv1a = bn()(xxconv1a) 1554 | 1555 | xxconv1b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1556 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxconv1a) 1557 | 1558 | xxconv1b = bn()(xxconv1b) 1559 | 1560 | merge1=concatenate([xxconv1a,xxconv1b]) 1561 | 1562 | xxconv1c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1563 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1564 | 1565 | xxconv1c = bn()(xxconv1c) 1566 | 1567 | merge2=concatenate([xxconv1a,xxconv1b,xxconv1c]) 1568 | 1569 | xxconv1d = Conv2D(32, (kernel_size, kernel_size), activation='relu', padding='same', 1570 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1571 | 1572 | xxconv1d = bn()(xxconv1d) 1573 | 1574 | 1575 | xxpool1 = MaxPooling2D(pool_size=(2, 2))(xxconv1d) 1576 | 1577 | xxpool1 = Dropout(DropP)(xxpool1) 1578 | 1579 | 1580 | 1581 | 1582 | 1583 | xxconv2a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1584 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxpool1) 1585 | 1586 | xxconv2a = bn()(xxconv2a) 1587 | 1588 | xxconv2b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1589 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxconv2a) 1590 | 1591 | xxconv2b = bn()(xxconv2b) 1592 | 1593 | merge1=concatenate([xxconv2a,xxconv2b]) 1594 | 1595 | xxconv2c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1596 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1597 | 1598 | xxconv2c = bn()(xxconv2c) 1599 | 1600 | merge2=concatenate([xxconv2a,xxconv2b,xxconv2c]) 1601 | 1602 | xxconv2d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1603 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1604 | 1605 | xxconv2d = bn()(xxconv2d) 1606 | 1607 | 1608 | merge3=concatenate([xxconv2a,xxconv2b,xxconv2c,xxconv2d]) 1609 | 1610 | 1611 | 1612 | xxconv2e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1613 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1614 | 1615 | xxconv2e = bn()(xxconv2e) 1616 | 1617 | merge4=concatenate([xxconv2a,xxconv2b,xxconv2c,xxconv2d,xxconv2e]) 1618 | 1619 | 1620 | xxconv2f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1621 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 1622 | 1623 | xxconv2f = bn()(xxconv2f) 1624 | 1625 | 1626 | merge5=concatenate([xxconv2a,xxconv2b,xxconv2c,xxconv2d,xxconv2e,xxconv2f]) 1627 | 1628 | xxconv2g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1629 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 1630 | 1631 | xxconv2g = bn()(xxconv2g) 1632 | 1633 | merge6=concatenate([xxconv2a,xxconv2b,xxconv2c,xxconv2d,xxconv2e,xxconv2f,xxconv2g]) 1634 | 1635 | 1636 | xxconv2h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1637 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 1638 | 1639 | xxconv2h = bn()(xxconv2h) 1640 | 1641 | merge7=concatenate([xxconv2a,xxconv2b,xxconv2c,xxconv2d,xxconv2e,xxconv2f,xxconv2g,xxconv2h]) 1642 | 1643 | 1644 | xxconv2i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1645 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 1646 | 1647 | xxconv2i = bn()(xxconv2g) 1648 | 1649 | merge8=concatenate([xxconv2a,xxconv2b,xxconv2c,xxconv2d,xxconv2e,xxconv2f,xxconv2g,xxconv2h,xxconv2i]) 1650 | 1651 | xxconv2j = Conv2D(64, (kernel_size, kernel_size), activation='relu', padding='same', 1652 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 1653 | 1654 | xxconv2j = bn()(xxconv2g) 1655 | 1656 | 1657 | xxpool2 = MaxPooling2D(pool_size=(2, 2))(xxconv2j) 1658 | 1659 | xxpool2 = Dropout(DropP)(xxpool2) 1660 | 1661 | 1662 | 1663 | 1664 | 1665 | 1666 | 1667 | xxconv3a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1668 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxpool2) 1669 | 1670 | xxconv3a = bn()(xxconv3a) 1671 | 1672 | xxconv3b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1673 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxconv3a) 1674 | 1675 | xxconv3b = bn()(xxconv3b) 1676 | 1677 | merge1=concatenate([xxconv3a,xxconv3b]) 1678 | 1679 | xxconv3c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1680 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1681 | 1682 | xxconv3c = bn()(xxconv3c) 1683 | 1684 | merge2=concatenate([xxconv3a,xxconv3b,xxconv3c]) 1685 | 1686 | xxconv3d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1687 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1688 | 1689 | xxconv3d = bn()(xxconv3d) 1690 | 1691 | 1692 | merge3=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d]) 1693 | 1694 | 1695 | 1696 | xxconv3e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1697 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1698 | 1699 | xxconv3e = bn()(xxconv3e) 1700 | 1701 | merge4=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e]) 1702 | 1703 | 1704 | xxconv3f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1705 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 1706 | 1707 | xxconv3f = bn()(xxconv3f) 1708 | 1709 | 1710 | merge5=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f]) 1711 | 1712 | xxconv3g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1713 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 1714 | 1715 | xxconv3g = bn()(xxconv3g) 1716 | 1717 | merge6=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g]) 1718 | 1719 | 1720 | xxconv3h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1721 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 1722 | 1723 | xxconv3h = bn()(xxconv3h) 1724 | 1725 | merge7=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h]) 1726 | 1727 | 1728 | xxconv3i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1729 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 1730 | 1731 | xxconv3i = bn()(xxconv3i) 1732 | 1733 | merge8=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i]) 1734 | 1735 | xxconv3j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1736 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 1737 | 1738 | xxconv3j = bn()(xxconv3j) 1739 | 1740 | 1741 | merge9=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j]) 1742 | 1743 | 1744 | xxconv3k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1745 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 1746 | 1747 | xxconv3k = bn()(xxconv3k) 1748 | 1749 | 1750 | merge10=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k]) 1751 | xxconv3l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1752 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 1753 | xxconv3l = bn()(xxconv3l) 1754 | 1755 | merge11=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l]) 1756 | xxconv3m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1757 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 1758 | xxconv3m = bn()(xxconv3m) 1759 | 1760 | 1761 | merge12=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m]) 1762 | xxconv3n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1763 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 1764 | xxconv3n = bn()(xxconv3n) 1765 | 1766 | 1767 | 1768 | 1769 | merge13=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m,xxconv3n]) 1770 | xxconv3o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1771 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 1772 | xxconv3o = bn()(xxconv3o) 1773 | 1774 | 1775 | 1776 | merge14=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m,xxconv3n,xxconv3o]) 1777 | xxconv3p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1778 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 1779 | xxconv3p = bn()(xxconv3p) 1780 | 1781 | 1782 | merge15=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m,xxconv3n,xxconv3o,xxconv3p]) 1783 | xxconv3q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1784 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 1785 | xxconv3q = bn()(xxconv3q) 1786 | 1787 | 1788 | merge16=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m,xxconv3n,xxconv3o,xxconv3p,xxconv3q]) 1789 | xxconv3r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1790 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 1791 | xxconv3r = bn()(xxconv3r) 1792 | 1793 | 1794 | merge17=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m,xxconv3n,xxconv3o,xxconv3p,xxconv3q,xxconv3r]) 1795 | xxconv3s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1796 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 1797 | xxconv3s = bn()(xxconv3s) 1798 | 1799 | 1800 | merge18=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m,xxconv3n,xxconv3o,xxconv3p,xxconv3q,xxconv3r,xxconv3s]) 1801 | xxconv3t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1802 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 1803 | xxconv3t = bn()(xxconv3t) 1804 | 1805 | merge19=concatenate([xxconv3a,xxconv3b,xxconv3c,xxconv3d,xxconv3e,xxconv3f,xxconv3g,xxconv3h,xxconv3i,xxconv3j,xxconv3k,xxconv3l,xxconv3m,xxconv3n,xxconv3o,xxconv3p,xxconv3q,xxconv3r,xxconv3s,xxconv3t]) 1806 | xxconv3u=Conv2D(128, (kernel_size, kernel_size), activation='relu', padding='same', 1807 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 1808 | xxconv3u = bn()(xxconv3u) 1809 | 1810 | 1811 | xxpool3 = MaxPooling2D(pool_size=(2, 2))(xxconv3u) 1812 | 1813 | xxpool3 = Dropout(DropP)(xxpool3) 1814 | 1815 | 1816 | xxconv4a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1817 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxpool3) 1818 | 1819 | xxconv4a = bn()(xxconv4a) 1820 | 1821 | xxconv4b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1822 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxconv4a) 1823 | 1824 | xxconv4b = bn()(xxconv4b) 1825 | 1826 | merge1=concatenate([xxconv4a,xxconv4b]) 1827 | 1828 | xxconv4c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1829 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1830 | 1831 | xxconv4c = bn()(xxconv4c) 1832 | 1833 | merge2=concatenate([xxconv4a,xxconv4b,xxconv4c]) 1834 | 1835 | xxconv4d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1836 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1837 | 1838 | xxconv4d = bn()(xxconv4d) 1839 | 1840 | 1841 | merge3=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d]) 1842 | 1843 | 1844 | 1845 | xxconv4e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1846 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1847 | 1848 | xxconv4e = bn()(xxconv4e) 1849 | 1850 | merge4=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e]) 1851 | 1852 | 1853 | xxconv4f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1854 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 1855 | 1856 | xxconv4f = bn()(xxconv4f) 1857 | 1858 | 1859 | merge5=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f]) 1860 | 1861 | xxconv4g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1862 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 1863 | 1864 | xxconv4g = bn()(xxconv4g) 1865 | 1866 | merge6=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g]) 1867 | 1868 | 1869 | xxconv4h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1870 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 1871 | 1872 | xxconv4h = bn()(xxconv4h) 1873 | 1874 | merge7=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h]) 1875 | 1876 | 1877 | xxconv4i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1878 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 1879 | 1880 | xxconv4i = bn()(xxconv4i) 1881 | 1882 | merge8=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i]) 1883 | 1884 | xxconv4j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1885 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 1886 | 1887 | xxconv4j = bn()(xxconv4j) 1888 | 1889 | 1890 | merge9=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j]) 1891 | 1892 | 1893 | xxconv4k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1894 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 1895 | 1896 | xxconv4k = bn()(xxconv4k) 1897 | 1898 | 1899 | merge10=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k]) 1900 | xxconv4l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1901 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 1902 | xxconv4l = bn()(xxconv4l) 1903 | 1904 | merge11=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l]) 1905 | xxconv4m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1906 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 1907 | xxconv4m = bn()(xxconv4m) 1908 | 1909 | 1910 | merge12=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m]) 1911 | xxconv4n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1912 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 1913 | xxconv4n = bn()(xxconv4n) 1914 | 1915 | 1916 | 1917 | 1918 | merge13=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m,xxconv4n]) 1919 | xxconv4o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1920 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 1921 | xxconv4o = bn()(xxconv4o) 1922 | 1923 | 1924 | 1925 | merge14=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m,xxconv4n,xxconv4o]) 1926 | xxconv4p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1927 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 1928 | xxconv4p = bn()(xxconv4p) 1929 | 1930 | 1931 | merge15=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m,xxconv4n,xxconv4o,xxconv4p]) 1932 | xxconv4q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1933 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 1934 | xxconv4q = bn()(xxconv4q) 1935 | 1936 | 1937 | merge16=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m,xxconv4n,xxconv4o,xxconv4p,xxconv4q]) 1938 | xxconv4r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1939 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 1940 | xxconv4r = bn()(xxconv4r) 1941 | 1942 | 1943 | merge17=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m,xxconv4n,xxconv4o,xxconv4p,xxconv4q,xxconv4r]) 1944 | xxconv4s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1945 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 1946 | xxconv4s = bn()(xxconv4s) 1947 | 1948 | 1949 | merge18=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m,xxconv4n,xxconv4o,xxconv4p,xxconv4q,xxconv4r,xxconv4s]) 1950 | xxconv4t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1951 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 1952 | xxconv4t = bn()(xxconv4t) 1953 | 1954 | merge19=concatenate([xxconv4a,xxconv4b,xxconv4c,xxconv4d,xxconv4e,xxconv4f,xxconv4g,xxconv4h,xxconv4i,xxconv4j,xxconv4k,xxconv4l,xxconv4m,xxconv4n,xxconv4o,xxconv4p,xxconv4q,xxconv4r,xxconv4s,xxconv4t]) 1955 | xxconv4u=Conv2D(256, (kernel_size, kernel_size), activation='relu', padding='same', 1956 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 1957 | xxconv4u = bn()(xxconv4u) 1958 | 1959 | xxpool4 = MaxPooling2D(pool_size=(2, 2))(xxconv4u) 1960 | 1961 | xxpool4 = Dropout(DropP)(xxpool4) 1962 | 1963 | 1964 | 1965 | 1966 | 1967 | xxconv5a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1968 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxpool4) 1969 | 1970 | xxconv5a = bn()(xxconv5a) 1971 | 1972 | xxconv5b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1973 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxconv5a) 1974 | 1975 | xxconv5b = bn()(xxconv5b) 1976 | 1977 | merge1=concatenate([xxconv5a,xxconv5b]) 1978 | 1979 | xxconv5c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1980 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 1981 | 1982 | xxconv5c = bn()(xxconv5c) 1983 | 1984 | merge2=concatenate([xxconv5a,xxconv5b,xxconv5c]) 1985 | 1986 | xxconv5d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1987 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 1988 | 1989 | xxconv5d = bn()(xxconv5d) 1990 | 1991 | 1992 | merge3=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d]) 1993 | 1994 | 1995 | 1996 | xxconv5e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 1997 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 1998 | 1999 | xxconv5e = bn()(xxconv5e) 2000 | 2001 | merge4=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e]) 2002 | 2003 | 2004 | xxconv5f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2005 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 2006 | 2007 | xxconv5f = bn()(xxconv5f) 2008 | 2009 | 2010 | merge5=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f]) 2011 | 2012 | xxconv5g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2013 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 2014 | 2015 | xxconv5g = bn()(xxconv5g) 2016 | 2017 | merge6=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g]) 2018 | 2019 | 2020 | xxconv5h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2021 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 2022 | 2023 | xxconv5h = bn()(xxconv5h) 2024 | 2025 | merge7=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h]) 2026 | 2027 | 2028 | xxconv5i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2029 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 2030 | 2031 | xxconv5i = bn()(xxconv5i) 2032 | 2033 | merge8=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i]) 2034 | 2035 | xxconv5j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2036 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 2037 | 2038 | xxconv5j = bn()(xxconv5j) 2039 | 2040 | 2041 | merge9=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j]) 2042 | 2043 | 2044 | xxconv5k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2045 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 2046 | 2047 | xxconv5k = bn()(xxconv5k) 2048 | 2049 | 2050 | merge10=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k]) 2051 | xxconv5l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2052 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 2053 | xxconv5l = bn()(xxconv5l) 2054 | 2055 | merge11=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l]) 2056 | xxconv5m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2057 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 2058 | xxconv5m = bn()(xxconv5m) 2059 | 2060 | 2061 | merge12=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m]) 2062 | xxconv5n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2063 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 2064 | xxconv5n = bn()(xxconv5n) 2065 | 2066 | 2067 | 2068 | 2069 | merge13=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m,xxconv5n]) 2070 | xxconv5o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2071 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 2072 | xxconv5o = bn()(xxconv5o) 2073 | 2074 | 2075 | 2076 | merge14=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m,xxconv5n,xxconv5o]) 2077 | xxconv5p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2078 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 2079 | xxconv5p = bn()(xxconv5p) 2080 | 2081 | 2082 | merge15=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m,xxconv5n,xxconv5o,xxconv5p]) 2083 | xxconv5q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2084 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 2085 | xxconv5q = bn()(xxconv5q) 2086 | 2087 | 2088 | merge16=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m,xxconv5n,xxconv5o,xxconv5p,xxconv5q]) 2089 | xxconv5r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2090 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 2091 | xxconv5r = bn()(xxconv5r) 2092 | 2093 | 2094 | merge17=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m,xxconv5n,xxconv5o,xxconv5p,xxconv5q,xxconv5r]) 2095 | xxconv5s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2096 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 2097 | xxconv5s = bn()(xxconv5s) 2098 | 2099 | 2100 | merge18=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m,xxconv5n,xxconv5o,xxconv5p,xxconv5q,xxconv5r,xxconv5s]) 2101 | xxconv5t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2102 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 2103 | xxconv5t = bn()(xxconv5t) 2104 | 2105 | merge19=concatenate([xxconv5a,xxconv5b,xxconv5c,xxconv5d,xxconv5e,xxconv5f,xxconv5g,xxconv5h,xxconv5i,xxconv5j,xxconv5k,xxconv5l,xxconv5m,xxconv5n,xxconv5o,xxconv5p,xxconv5q,xxconv5r,xxconv5s,xxconv5t]) 2106 | xxconv5u=Conv2D(512, (kernel_size, kernel_size), activation='relu', padding='same', 2107 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 2108 | xxconv5u = bn()(xxconv5u) 2109 | 2110 | 2111 | 2112 | 2113 | xxup6 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xxconv5u), xxconv4u],name='xxup6', axis=3) 2114 | 2115 | xxout6=Conv2DTranspose(12,(2, 2), strides=(8, 8), padding='same')(xxup6) 2116 | xxout6 = bn()(xxout6) 2117 | xxoutput1 = Conv2D(1, (1, 1), activation='sigmoid',name='xxoutput1')(xxout6) 2118 | 2119 | xxup6 = Dropout(DropP)(xxup6) 2120 | 2121 | xxconv6a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2122 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxup6) 2123 | 2124 | xxconv6a = bn()(xxconv6a) 2125 | 2126 | merge0=concatenate([xxup6,xxconv6a]) 2127 | 2128 | xxconv6b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2129 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 2130 | 2131 | xxconv6b = bn()(xxconv6b) 2132 | 2133 | merge1=concatenate([xxup6,xxconv6a,xxconv6b]) 2134 | 2135 | xxconv6c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2136 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 2137 | 2138 | xxconv6c = bn()(xxconv6c) 2139 | 2140 | merge2=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c]) 2141 | 2142 | xxconv6d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2143 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 2144 | 2145 | xxconv6d = bn()(xxconv6d) 2146 | 2147 | 2148 | merge3=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d]) 2149 | 2150 | 2151 | xxconv6e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2152 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 2153 | 2154 | xxconv6e = bn()(xxconv6e) 2155 | 2156 | merge4=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e]) 2157 | 2158 | 2159 | xxconv6f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2160 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 2161 | 2162 | xxconv6f = bn()(xxconv6f) 2163 | 2164 | 2165 | merge5=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f]) 2166 | 2167 | xxconv6g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2168 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 2169 | 2170 | xxconv6g = bn()(xxconv6g) 2171 | 2172 | merge6=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g]) 2173 | 2174 | 2175 | xxconv6h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2176 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 2177 | 2178 | xxconv6h = bn()(xxconv6h) 2179 | 2180 | merge7=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h]) 2181 | 2182 | 2183 | xxconv6i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2184 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 2185 | 2186 | xxconv6i = bn()(xxconv6i) 2187 | 2188 | merge8=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i]) 2189 | 2190 | xxconv6j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2191 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 2192 | 2193 | xxconv6j = bn()(xxconv6j) 2194 | 2195 | 2196 | merge9=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j]) 2197 | 2198 | 2199 | xxconv6k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2200 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 2201 | 2202 | xxconv6k = bn()(xxconv6k) 2203 | 2204 | 2205 | merge10=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k]) 2206 | xxconv6l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2207 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 2208 | xxconv6l = bn()(xxconv6l) 2209 | 2210 | merge11=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l]) 2211 | xxconv6m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2212 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 2213 | xxconv6m = bn()(xxconv6m) 2214 | 2215 | 2216 | merge12=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m]) 2217 | xxconv6n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2218 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 2219 | xxconv6n = bn()(xxconv6n) 2220 | 2221 | 2222 | 2223 | 2224 | merge13=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m,xxconv6n]) 2225 | xxconv6o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2226 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 2227 | xxconv6o = bn()(xxconv6o) 2228 | 2229 | 2230 | 2231 | merge14=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m,xxconv6n,xxconv6o]) 2232 | xxconv6p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2233 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 2234 | xxconv6p = bn()(xxconv6p) 2235 | 2236 | 2237 | merge15=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m,xxconv6n,xxconv6o,xxconv6p]) 2238 | xxconv6q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2239 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 2240 | xxconv6q = bn()(xxconv6q) 2241 | 2242 | 2243 | merge16=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m,xxconv6n,xxconv6o,xxconv6p,xxconv6q]) 2244 | xxconv6r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2245 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 2246 | xxconv6r = bn()(xxconv6r) 2247 | 2248 | 2249 | merge17=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m,xxconv6n,xxconv6o,xxconv6p,xxconv6q,xxconv6r]) 2250 | xxconv6s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2251 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 2252 | xxconv6s = bn()(xxconv6s) 2253 | 2254 | 2255 | merge18=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m,xxconv6n,xxconv6o,xxconv6p,xxconv6q,xxconv6r,xxconv6s]) 2256 | xxconv6t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2257 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 2258 | xxconv6t = bn()(xxconv6t) 2259 | 2260 | merge19=concatenate([xxup6,xxconv6a,xxconv6b,xxconv6c,xxconv6d,xxconv6e,xxconv6f,xxconv6g,xxconv6h,xxconv6i,xxconv6j,xxconv6k,xxconv6l,xxconv6m,xxconv6n,xxconv6o,xxconv6p,xxconv6q,xxconv6r,xxconv6s,xxconv6t]) 2261 | xxconv6u=Conv2D(256, (kernel_size, kernel_size), activation='relu', padding='same', 2262 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 2263 | xxconv6u = bn()(xxconv6u) 2264 | 2265 | 2266 | 2267 | 2268 | 2269 | xxup7 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xxconv6u), xxconv3u],name='xxup7', axis=3) 2270 | 2271 | xxup7 = Dropout(DropP)(xxup7) 2272 | #add second xxoutput here 2273 | xxout7=Conv2DTranspose(12,(2, 2), strides=(4, 4), padding='same')(xxup7) 2274 | xxout7 = bn()(xxout7) 2275 | xxoutput2 = Conv2D(1, (1, 1), activation='sigmoid',name='xxoutput2')(xxout7) 2276 | xxconv7a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2277 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxup7) 2278 | 2279 | xxconv7a = bn()(xxconv7a) 2280 | 2281 | merge0=concatenate([xxup7,xxconv7a]) 2282 | 2283 | xxconv7b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2284 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 2285 | 2286 | xxconv7b = bn()(xxconv7b) 2287 | 2288 | merge1=concatenate([xxup7,xxconv7a,xxconv7b]) 2289 | 2290 | xxconv7c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2291 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 2292 | 2293 | xxconv7c = bn()(xxconv7c) 2294 | 2295 | merge2=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c]) 2296 | 2297 | xxconv7d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2298 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 2299 | 2300 | xxconv7d = bn()(xxconv7d) 2301 | 2302 | 2303 | merge3=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d]) 2304 | 2305 | 2306 | 2307 | xxconv7e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2308 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 2309 | 2310 | xxconv7e = bn()(xxconv7e) 2311 | 2312 | merge4=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e]) 2313 | 2314 | 2315 | xxconv7f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2316 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 2317 | 2318 | xxconv7f = bn()(xxconv7f) 2319 | 2320 | 2321 | merge5=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f]) 2322 | 2323 | xxconv7g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2324 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 2325 | 2326 | xxconv7g = bn()(xxconv7g) 2327 | 2328 | merge6=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g]) 2329 | 2330 | 2331 | xxconv7h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2332 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 2333 | 2334 | xxconv7h = bn()(xxconv7h) 2335 | 2336 | merge7=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h]) 2337 | 2338 | 2339 | xxconv7i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2340 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 2341 | 2342 | xxconv7i = bn()(xxconv7i) 2343 | 2344 | merge8=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i]) 2345 | 2346 | xxconv7j = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2347 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 2348 | 2349 | xxconv7j = bn()(xxconv7j) 2350 | 2351 | 2352 | merge9=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j]) 2353 | 2354 | 2355 | xxconv7k = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2356 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge9) 2357 | 2358 | xxconv7k = bn()(xxconv7k) 2359 | 2360 | 2361 | merge10=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k]) 2362 | xxconv7l=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2363 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge10) 2364 | xxconv7l = bn()(xxconv7l) 2365 | 2366 | merge11=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l]) 2367 | xxconv7m=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2368 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge11) 2369 | xxconv7m = bn()(xxconv7m) 2370 | 2371 | 2372 | merge12=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m]) 2373 | xxconv7n=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2374 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge12) 2375 | xxconv7n = bn()(xxconv7n) 2376 | 2377 | 2378 | 2379 | 2380 | merge13=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m,xxconv7n]) 2381 | xxconv7o=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2382 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge13) 2383 | xxconv7o = bn()(xxconv7o) 2384 | 2385 | 2386 | 2387 | merge14=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m,xxconv7n,xxconv7o]) 2388 | xxconv7p=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2389 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge14) 2390 | xxconv7p = bn()(xxconv7p) 2391 | 2392 | 2393 | merge15=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m,xxconv7n,xxconv7o,xxconv7p]) 2394 | xxconv7q=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2395 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge15) 2396 | xxconv7q = bn()(xxconv7q) 2397 | 2398 | 2399 | merge16=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m,xxconv7n,xxconv7o,xxconv7p,xxconv7q]) 2400 | xxconv7r=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2401 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge16) 2402 | xxconv7r = bn()(xxconv7r) 2403 | 2404 | 2405 | merge17=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m,xxconv7n,xxconv7o,xxconv7p,xxconv7q,xxconv7r]) 2406 | xxconv7s=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2407 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge17) 2408 | xxconv7s = bn()(xxconv7s) 2409 | 2410 | 2411 | merge18=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m,xxconv7n,xxconv7o,xxconv7p,xxconv7q,xxconv7r,xxconv7s]) 2412 | xxconv7t=Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2413 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge18) 2414 | xxconv7t = bn()(xxconv7t) 2415 | 2416 | merge19=concatenate([xxup7,xxconv7a,xxconv7b,xxconv7c,xxconv7d,xxconv7e,xxconv7f,xxconv7g,xxconv7h,xxconv7i,xxconv7j,xxconv7k,xxconv7l,xxconv7m,xxconv7n,xxconv7o,xxconv7p,xxconv7q,xxconv7r,xxconv7s,xxconv7t]) 2417 | xxconv7u=Conv2D(128, (kernel_size, kernel_size), activation='relu', padding='same', 2418 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge19) 2419 | xxconv7u = bn()(xxconv7u) 2420 | 2421 | 2422 | 2423 | 2424 | xxup8 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xxconv7u), xxconv2j],name='xxup8', axis=3) 2425 | 2426 | xxup8 = Dropout(DropP)(xxup8) 2427 | #add third xxoutxxout here 2428 | xxout8=Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xxup8) 2429 | xxout8 = bn()(xxout8) 2430 | xxoutput3 = Conv2D(1, (1, 1), activation='sigmoid',name='xxoutput3')(xxout8) 2431 | xxconv8a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2432 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxup8) 2433 | 2434 | xxconv8a = bn()(xxconv8a) 2435 | 2436 | merge0=concatenate([xxup8,xxconv8a]) 2437 | 2438 | xxconv8b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2439 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 2440 | 2441 | xxconv8b = bn()(xxconv8b) 2442 | 2443 | merge1=concatenate([xxup8,xxconv8a,xxconv8b]) 2444 | 2445 | xxconv8c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2446 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 2447 | 2448 | xxconv8c = bn()(xxconv8c) 2449 | 2450 | merge2=concatenate([xxup8,xxconv8a,xxconv8b,xxconv8c]) 2451 | 2452 | xxconv8d = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2453 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 2454 | 2455 | xxconv8d = bn()(xxconv8d) 2456 | 2457 | 2458 | merge3=concatenate([xxup8,xxconv8a,xxconv8b,xxconv8c,xxconv8d]) 2459 | 2460 | 2461 | 2462 | xxconv8e = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2463 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge3) 2464 | 2465 | xxconv8e = bn()(xxconv8e) 2466 | 2467 | merge4=concatenate([xxup8,xxconv8a,xxconv8b,xxconv8c,xxconv8d,xxconv8e]) 2468 | 2469 | 2470 | xxconv8f = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2471 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge4) 2472 | 2473 | xxconv8f = bn()(xxconv8f) 2474 | 2475 | 2476 | merge5=concatenate([xxup8,xxconv8a,xxconv8b,xxconv8c,xxconv8d,xxconv8e,xxconv8f]) 2477 | 2478 | xxconv8g = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2479 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge5) 2480 | 2481 | xxconv8g = bn()(xxconv8g) 2482 | 2483 | merge6=concatenate([xxup8,xxconv8a,xxconv8b,xxconv8c,xxconv8d,xxconv8e,xxconv8f,xxconv8g]) 2484 | 2485 | 2486 | xxconv8h = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2487 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge6) 2488 | 2489 | xxconv8h = bn()(xxconv8h) 2490 | 2491 | merge7=concatenate([xxup8,xxconv8a,xxconv8b,xxconv8c,xxconv8d,xxconv8e,xxconv8f,xxconv8g,xxconv8h]) 2492 | 2493 | 2494 | xxconv8i = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2495 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge7) 2496 | 2497 | xxconv8i = bn()(xxconv8i) 2498 | 2499 | merge8=concatenate([xxup8,xxconv8a,xxconv8b,xxconv8c,xxconv8d,xxconv8e,xxconv8f,xxconv8g,xxconv8h,xxconv8i]) 2500 | 2501 | xxconv8j = Conv2D(64, (kernel_size, kernel_size), activation='relu', padding='same', 2502 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge8) 2503 | 2504 | xxconv8j = bn()(xxconv8j) 2505 | 2506 | 2507 | 2508 | xxup9 = concatenate([Conv2DTranspose(12,(2, 2), strides=(2, 2), padding='same')(xxconv8j), xxconv1d],name='xxup9',axis=3) 2509 | 2510 | xxup9 = Dropout(DropP)(xxup9) 2511 | xxout9=Conv2DTranspose(12,(2, 2), strides=(1, 1), padding='same')(xxup9) 2512 | xxout9 = bn()(xxout9) 2513 | xxoutput4 = Conv2D(1, (1, 1), activation='sigmoid',name='xxoutput4')(xxout9) 2514 | 2515 | xxconv9a = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2516 | kernel_regularizer=regularizers.l2(l2_lambda) )(xxup9) 2517 | 2518 | xxconv9a = bn()(xxconv9a) 2519 | 2520 | merge0=concatenate([xxup9,xxconv9a]) 2521 | 2522 | xxconv9b = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2523 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge0) 2524 | 2525 | xxconv9b = bn()(xxconv9b) 2526 | 2527 | merge1=concatenate([xxup9,xxconv9a,xxconv9b]) 2528 | 2529 | xxconv9c = Conv2D(12, (kernel_size, kernel_size), activation='relu', padding='same', 2530 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge1) 2531 | 2532 | xxconv9c = bn()(xxconv9c) 2533 | 2534 | merge2=concatenate([xxup9,xxconv9a,xxconv9b,xxconv9c]) 2535 | 2536 | xxconv9d = Conv2D(32, (kernel_size, kernel_size), activation='relu', padding='same', 2537 | kernel_regularizer=regularizers.l2(l2_lambda) )(merge2) 2538 | 2539 | xxconv9d = bn()(xxconv9d) 2540 | 2541 | 2542 | xxconv10 = Conv2D(1, (1, 1), activation='sigmoid',name='xxconv10')(xxconv9d) 2543 | 2544 | xxfinalmerge=concatenate([xxout6,xxout7,xxout8,xxout9,xxconv9d]) 2545 | 2546 | xxfinal_op=Conv2D(1, (1, 1), activation='sigmoid',name='xxfinal_op')(xxfinalmerge) 2547 | 2548 | #model = Model(inputs=[inputs,input_prob,input_prob_inverse], outputs=[conv10,xconv10,third_out]) 2549 | model = Model(inputs=inputs, outputs=[output1,output2,output3,output4,conv10,final_op,xoutput1,xoutput2,xoutput3,xoutput4,xconv10,xfinal_op,xxoutput1,xxoutput2,xxoutput3,xxoutput4,xxconv10,xxfinal_op]) 2550 | 2551 | model.compile(optimizer=Adam(lr=1e-5), loss={'output1':dice_coef_loss,'output2':dice_coef_loss,'output3':dice_coef_loss,'output4':dice_coef_loss,'conv10':dice_coef_loss,'final_op':dice_coef_loss, 2552 | 'xoutput1':neg_dice_coef_loss,'xoutput2':neg_dice_coef_loss,'xoutput3':neg_dice_coef_loss,'xoutput4':neg_dice_coef_loss,'xconv10':neg_dice_coef_loss,'xfinal_op':neg_dice_coef_loss, 2553 | 'xxoutput1':'mse','xxoutput2':'mse','xxoutput3':'mse','xxoutput4':'mse','xxconv10':'mse','xxfinal_op':'mse'}) 2554 | #loss=[neg_dice_coef_loss,'mse',dice_coef_loss], 2555 | #metrics=[neg_dice_coef,'mae',dice_coef]) 2556 | return model 2557 | 2558 | 2559 | # In[8]: 2560 | 2561 | 2562 | model=CompNet(input_shape=(256,256,1)) 2563 | print(model.summary()) 2564 | 2565 | 2566 | # In[62]: 2567 | X_train=np.load("X_train_new.npy") 2568 | X_train=X_train.reshape(X_train.shape+(1,)) 2569 | y_train=np.load("y_train_new.npy").reshape(X_train.shape) 2570 | 2571 | model.fit([X_train], [y_train,y_train,y_train,y_train,y_train,y_train,y_train,y_train,y_train,y_train,y_train,y_train,X_train,X_train,X_train,X_train,X_train,X_train], 2572 | batch_size=4, 2573 | nb_epoch=10, 2574 | #validation_data=([X2_validate],[y_validate]), 2575 | shuffle=True) 2576 | #callbacks=[xyz], 2577 | #class_weight=class_weightt) 2578 | 2579 | 2580 | # In[29]: 2581 | 2582 | 2583 | 2584 | import h5py 2585 | #model.save_weights("basic_unet_weights.h5") 2586 | model.save('dense_comp_net_dsp.h5') 2587 | 2588 | --------------------------------------------------------------------------------