def model(self):
input_layer = Input(shape=self.SHAPE)
down_1 = Convolution2D(64,
kernel_size=4,
strides=2,
padding='same',
activation=LeakyReLU(alpha=0.2))(input_layer)
down_2 = Convolution2D(64 * 2,
kernel_size=4,
strides=2,
padding='same',
activation=LeakyReLU(alpha=0.2))(down_1)
norm_2 = BatchNormalization()(down_2)
down_3 = Convolution2D(64 * 4,
kernel_size=4,
strides=2,
padding='same',
activation=LeakyReLU(alpha=0.2))(norm_2)
norm_3 = BatchNormalization()(down_3)
down_4 = Convolution2D(64 * 8,
kernel_size=4,
strides=2,
padding='same',
activation=LeakyReLU(alpha=0.2))(norm_3)
norm_4 = BatchNormalization()(down_4)
down_5 = Convolution2D(64 * 8,
kernel_size=4,
strides=2,
padding='same',
activation=LeakyReLU(alpha=0.2))(norm_4)
norm_5 = BatchNormalization()(down_5)
down_6 = Convolution2D(64 * 8,
kernel_size=4,
strides=2,
padding='same',
activation=LeakyReLU(alpha=0.2))(norm_5)
norm_6 = BatchNormalization()(down_6)
down_7 = Convolution2D(64 * 8,
kernel_size=4,
strides=2,
padding='same',
activation=LeakyReLU(alpha=0.2))(norm_6)
norm_7 = BatchNormalization()(down_7)
upsample_1 = UpSampling2D(size=2)(norm_7)
up_conv_1 = Convolution2D(64 * 8,
kernel_size=4,
strides=1,
padding='same',
activation='relu')(upsample_1)
norm_up_1 = BatchNormalization(momentum=0.8)(up_conv_1)
add_skip_1 = Concatenate()([norm_up_1, norm_6])
upsample_2 = UpSampling2D(size=2)(add_skip_1)
up_conv_2 = Convolution2D(64 * 8,
kernel_size=4,
strides=1,
padding='same',
activation='relu')(upsample_2)
norm_up_2 = BatchNormalization(momentum=0.8)(up_conv_2)
add_skip_2 = Concatenate()([norm_up_2, norm_5])
upsample_3 = UpSampling2D(size=2)(add_skip_2)
up_conv_3 = Convolution2D(64 * 8,
kernel_size=4,
strides=1,
padding='same',
activation='relu')(upsample_3)
norm_up_3 = BatchNormalization(momentum=0.8)(up_conv_3)
add_skip_3 = Concatenate()([norm_up_3, norm_4])
upsample_4 = UpSampling2D(size=2)(add_skip_3)
up_conv_4 = Convolution2D(64 * 4,
kernel_size=4,
strides=1,
padding='same',
activation='relu')(upsample_4)
norm_up_4 = BatchNormalization(momentum=0.8)(up_conv_4)
add_skip_4 = Concatenate()([norm_up_4, norm_3])
upsample_5 = UpSampling2D(size=2)(add_skip_4)
up_conv_5 = Convolution2D(64 * 2,
kernel_size=4,
strides=1,
padding='same',
activation='relu')(upsample_5)
norm_up_5 = BatchNormalization(momentum=0.8)(up_conv_5)
add_skip_5 = Concatenate()([norm_up_5, norm_2])
upsample_6 = UpSampling2D(size=2)(add_skip_5)
up_conv_6 = Convolution2D(64,
kernel_size=4,
strides=1,
padding='same',
activation='relu')(upsample_6)
norm_up_6 = BatchNormalization(momentum=0.8)(up_conv_6)
add_skip_6 = Concatenate()([norm_up_6, down_1])
last_upsample = UpSampling2D(size=2)(add_skip_6)
output_layer = Convolution2D(self.C,
kernel_size=4,
strides=1,
padding='same',
activation='tanh')(last_upsample)
return Model(input_layer, output_layer)
def load_model_cnn(input_dim,
data_set_size,
l2_reg=0.01,
activation='relu',
hidden_layer_size=64,
hidden_layer_num=3,
dropout_rate=0.25):
print('Building CNN-Model.')
model = Sequential()
print('SIZEEEEE: ', input_dim)
# Perfect hidden size: h, h*2
# Perfect pool size : 8, 8
# Convolutional Layer 1
model.add(
Convolution2D(hidden_layer_size,
1,
3,
border_mode='same',
input_shape=(1, 1, input_dim)))
model.add(Activation(activation))
model.add(Convolution2D(hidden_layer_size, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(1, 8), border_mode='valid'))
model.add(Dropout(dropout_rate))
# Convolutional Layer 2
model.add(Convolution2D(hidden_layer_size * 2, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(Convolution2D(hidden_layer_size * 2, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(1, 8), border_mode='valid'))
model.add(Dropout(dropout_rate))
# Fully connected Layer
model.add(Flatten())
model.add(Dense(1280, W_regularizer=l2(l2_reg), init='lecun_uniform'))
model.add(BatchNormalization(epsilon=0.001, mode=0))
model.add(Activation(activation))
model.add(Dropout(dropout_rate / 2))
# model.add(Dense(hidden_layer_size * 4, W_regularizer=l2(l2_reg),
# init='lecun_uniform'))
# model.add(BatchNormalization(epsilon=0.001, mode=0))
# model.add(Activation(activation))
# model.add(Dropout(dropout_rate / 2))
model.add(
Dense(hidden_layer_size,
W_regularizer=l2(l2_reg),
init='lecun_uniform'))
model.add(BatchNormalization(epsilon=0.001, mode=0))
model.add(Activation(activation))
model.add(Dropout(dropout_rate / 2))
# model.add(Dense(hidden_layer_size * 4, W_regularizer=l2(l2_reg),
# init='lecun_uniform'))
# model.add(BatchNormalization(epsilon=0.001, mode=0))
# model.add(Activation(activation))
# model.add(Dropout(dropout_rate / 2))
model.add(Dense(1280, W_regularizer=l2(l2_reg), init='lecun_uniform'))
model.add(BatchNormalization(epsilon=0.001, mode=0))
model.add(Activation(activation))
model.add(Dropout(dropout_rate / 2))
model.add(Reshape((hidden_layer_size * 2, 1, int(int(input_dim / 8) / 8))))
# Deconvolution 1:
# model.add(Unpooling2D(poolsize=(1, 8)))
# model.add(UpSampling2D((1, 8)))
# model.add(Convolution2D(hidden_layer_size * 2, 1, 3))
# model.add(Deconvolution2D(hidden_layer_size * 2, 1, 3,
# (None, hidden_layer_size * 2, 1, int(input_dim/8))))
# model.add(Activation(activation))
# model.add(Deconvolution2D(hidden_layer_size * 2, 1, 3,
# (None, hidden_layer_size, 1, int(input_dim/8))))
# model.add(Activation(activation))
#
# # model.add(Unpooling2D(poolsize=(1, 8)))
# model.add(UpSampling2D((1, 8)))
# model.add(Deconvolution2D(hidden_layer_size, 1, 3,
# (None, hidden_layer_size, 1, input_dim)))
# model.add(Activation(activation))
# model.add(Deconvolution2D(hidden_layer_size, 1, 3,
# (None, 1, 1, input_dim)))
# model.add(Activation(activation))
# model.add(Deconvolution2D(1, 1, 3,
# (None, 1, 1, input_dim)))
# model.add(Activation(activation))
model.add(UpSampling2D((1, 8)))
model.add(Convolution2D(hidden_layer_size * 2, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(Convolution2D(hidden_layer_size * 2, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(UpSampling2D((1, 8)))
model.add(Convolution2D(hidden_layer_size, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(Convolution2D(hidden_layer_size, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(Convolution2D(1, 1, 3, border_mode='same'))
model.add(Activation(activation))
model.add(Activation("linear"))
model.summary()
return model
def generator_upsampling(cat_dim, cont_dim, noise_dim, img_dim, model_name="generator_upsampling", dset="mnist"):
"""
Generator model of the DCGAN
args : img_dim (tuple of int) num_chan, height, width
pretr_weights_file (str) file holding pre trained weights
returns : model (keras NN) the Neural Net model
"""
s = img_dim[1]
f = 128
if dset == "mnist":
start_dim = int(s / 4)
nb_upconv = 2
elif dset == "celebA":
start_dim = int(s / 16)
nb_upconv = 4
else:
o = s
nb_upconv = 0
while o > 7:
o = o/2
nb_upconv += 1
start_dim = int(o)
if K.image_dim_ordering() == "th":
bn_axis = 1
reshape_shape = (f, start_dim, start_dim)
output_channels = img_dim[0]
else:
reshape_shape = (start_dim, start_dim, f)
bn_axis = -1
output_channels = img_dim[-1]
cat_input = Input(shape=cat_dim, name="cat_input")
cont_input = Input(shape=cont_dim, name="cont_input")
noise_input = Input(shape=noise_dim, name="noise_input")
# gen_input = merge([cat_input, cont_input, noise_input], mode="concat")
gen_input = Concatenate()([noise_input, cont_input, cat_input])
x = Dense(1024)(gen_input)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Dense(f * start_dim * start_dim)(x)
x = BatchNormalization()(x)
x = Activation("relu")(x)
x = Reshape(reshape_shape)(x)
# Upscaling blocks
for i in range(nb_upconv):
x = UpSampling2D(size=(2, 2))(x)
nb_filters = int(f / (2 ** (i + 1)))
x = Conv2D(nb_filters, (3, 3), padding="same")(x)
x = BatchNormalization(axis=bn_axis)(x)
x = Activation("relu")(x)
# x = Conv2D(nb_filters, (3, 3), padding="same")(x)
# x = BatchNormalization(axis=bn_axis)(x)
# x = Activation("relu")(x)
x = Conv2D(output_channels, (3, 3), name="gen_Conv2D_final", padding="same", activation='tanh')(x)
generator_model = Model(inputs=[cat_input, cont_input, noise_input], outputs=[x], name=model_name)
return generator_model
def create_segnet(args, indices=True, ker_init="he_normal") -> tModel:
input_shape = tuple(args.input_shape)
encoder = VGG16_encoder(input_shape, init=True)
L = [layer for i, layer in enumerate(encoder.layers)] # type: List[Layer]
#for layer in L: layer.trainable = False # freeze VGG16
L.reverse()
x = encoder.output
x = Dropout(0.5)(x)
# Block 5
if indices:
x = DePool2D(L[0],
size=L[0].pool_size,
input_shape=encoder.output_shape[1:])(x)
else:
x = UpSampling2D(size=L[0].pool_size,
input_shape=encoder.output_shape[1:])(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[1].filters,
L[1].kernel_size,
padding=L[1].padding,
kernel_initializer=ker_init)(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[2].filters,
L[2].kernel_size,
padding=L[2].padding,
kernel_initializer=ker_init)(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[3].filters,
L[3].kernel_size,
padding=L[3].padding,
kernel_initializer=ker_init)(x)))
x = Dropout(0.5)(x)
# Block 4
if indices: x = DePool2D(L[4], size=L[4].pool_size)(x)
else: x = UpSampling2D(size=L[4].pool_size)(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[5].filters,
L[5].kernel_size,
padding=L[5].padding,
kernel_initializer=ker_init)(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[6].filters,
L[6].kernel_size,
padding=L[6].padding,
kernel_initializer=ker_init)(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[7].filters,
L[7].kernel_size,
padding=L[7].padding,
kernel_initializer=ker_init)(x)))
x = Dropout(0.5)(x)
# Block 3
if indices: x = DePool2D(L[8], size=L[8].pool_size)(x)
else: x = UpSampling2D(size=L[8].pool_size)(x)
# x = ZeroPadding2D(padding=(0, 1))(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[10].filters,
L[10].kernel_size,
padding=L[10].padding,
kernel_initializer=ker_init)(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[11].filters,
L[11].kernel_size,
padding=L[11].padding,
kernel_initializer=ker_init)(x)))
x = Dropout(0.5)(x)
# Block 2
if indices: x = DePool2D(L[12], size=L[12].pool_size)(x)
else: x = UpSampling2D(size=L[12].pool_size)(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[13].filters,
L[13].kernel_size,
padding=L[13].padding,
kernel_initializer=ker_init)(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[14].filters,
L[14].kernel_size,
padding=L[14].padding,
kernel_initializer=ker_init)(x)))
# Block 1
if indices: x = DePool2D(L[15], size=L[15].pool_size)(x)
else: x = UpSampling2D(size=L[15].pool_size)(x)
x = Activation('relu')(BatchNormalization()(Conv2D(
L[16].filters,
L[16].kernel_size,
padding=L[16].padding,
kernel_initializer=ker_init)(x)))
x = Activation('relu')(BatchNormalization()(Conv2D(
L[17].filters,
L[17].kernel_size,
padding=L[17].padding,
kernel_initializer=ker_init)(x)))
x = Conv2D(args.num_classes, (1, 1),
padding='valid',
kernel_initializer=ker_init)(x)
if args.num_classes == 1:
x = Activation('sigmoid')(x)
elif args.num_classes > 1:
x = Activation('softmax')(x)
predictions = x
segnet = Model(inputs=encoder.inputs, outputs=predictions) # type: tModel
return segnet
def segnet(input_shape= (512, 512, 3), classes=5):
img_input = Input(shape=input_shape)
X = img_input
# Encoding layers
# Block 1
X = Convolution2D(64, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(64, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = MaxPooling2D()(X)
# Block 2
X = Convolution2D(128, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(128, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = MaxPooling2D()(X)
# Block 3
X = Convolution2D(256, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(256, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(256, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = MaxPooling2D()(X)
# Block 4
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = MaxPooling2D()(X)
# Block 5
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = MaxPooling2D()(X)
# Decoding layers
# Block 1
X = UpSampling2D()(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
# Block 2
X = UpSampling2D()(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(512, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(256, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
# Block 3
X = UpSampling2D()(X)
X = Convolution2D(256, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(256, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(128, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
# Block 4
X = UpSampling2D()(X)
X = Convolution2D(128, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(64, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
# Block 5
X = UpSampling2D()(X)
X = Convolution2D(64, (kernel, kernel), padding="same")(X)
X = BatchNormalization()(X)
X = Activation("relu")(X)
X = Convolution2D(classes, (1, 1), padding="valid")(X)
X = BatchNormalization()(X)
X = Reshape((input_shape[0]*input_shape[1], classes), input_shape = input_shape)(X)
X = Permute((1, 2))(X)
X = Activation("softmax")(X)
model = Model(img_input, X)
return model
def create_up_sampling_module(input_layer, n_filters, size=(2, 2)):
up_sample = UpSampling2D(size=size)(input_layer)
convolution = create_convolution_block(up_sample, n_filters)
return convolution
def VGGSegNet(nClasses,shape,W,lr):
vgg_level=3
input_height=shape[0]
input_width=shape[1]
img_input = Input(shape=(input_height,input_width,1))
x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv1')(img_input)
x = Conv2D(64, (3, 3), activation='relu', padding='same', name='block1_conv2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x)
f1 = x
# Block 2
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv1')(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same', name='block2_conv2')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x)
f2 = x
# Block 3
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv1')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x)
f3 = x
# Block 4
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x)
f4 = x
# Block 5
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x)
x = Conv2D(512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x)
x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x)
f5 = x
x = Flatten(name='flatten')(x)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dense(4096, activation='relu', name='fc2')(x)
x = Dense( 1000 , activation='softmax', name='predictions')(x)
# vgg = Model( img_input , x )
levels = [f1 , f2 , f3 , f4 , f5 ]
o = levels[ vgg_level ]
o = ( ZeroPadding2D( (1,1) ))(o)
o = ( Conv2D(512, (3, 3), padding='valid'))(o)
o = ( BatchNormalization())(o)
o = ( UpSampling2D( (2,2)))(o)
o = ( ZeroPadding2D( (1,1)))(o)
o = ( Conv2D( 256, (3, 3), padding='valid'))(o)
o = ( BatchNormalization())(o)
o = ( UpSampling2D((2,2) ) )(o)
o = ( ZeroPadding2D((1,1) ))(o)
o = ( Conv2D( 128 , (3, 3), padding='valid' ))(o)
o = ( BatchNormalization())(o)
o = ( UpSampling2D((2,2) ))(o)
o = ( ZeroPadding2D((1,1) ))(o)
o = ( Conv2D( 64 , (3, 3), padding='valid' ))(o)
o = ( BatchNormalization())(o)
o = ( UpSampling2D((2,2) ))(o)
o = ( ZeroPadding2D((1,1) ))(o)
o = ( Conv2D( 64 , (3, 3), padding='valid' ))(o)
o = ( BatchNormalization())(o)
o = Conv2D( nClasses , (3, 3) , padding='same')( o )
o_shape = Model(img_input , o ).output_shape
outputHeight = o_shape[1]
outputWidth = o_shape[2]
if nClasses>1:
o = (Reshape(( -1 , outputHeight*outputWidth )))(o)
o = (Permute((2, 1)))(o)
o = (Activation('softmax'))(o)
if nClasses==1:
o = (Activation('sigmoid'))(o)
model = Model( img_input , o )
model.outputWidth = outputWidth
model.outputHeight = outputHeight
if W !='':
model.load_weights(W)
if nClasses>1:
model.compile(loss="categorical_crossentropy", optimizer = Adam(lr = 1e-4) , metrics=['accuracy'] )
if nClasses==1:
model.compile(loss="binary_crossentropy", optimizer = Adam(lr = 1e-4) , metrics=['accuracy'] )
model.summary()
# img_w = shape[1]
# img_h = shape[0]
# n_labels = nClasses
#
# kernel = 3
# pad = 1
# pool_size = 2
#
# encoding_layers = [
# Convolution2D(64, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(64, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# MaxPooling2D(pool_size=(pool_size, pool_size)),
#
# Convolution2D(128, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(128, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# MaxPooling2D(pool_size=(pool_size, pool_size)),
#
# Convolution2D(256, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(256, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(256, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# MaxPooling2D(pool_size=(pool_size, pool_size)),
#
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# MaxPooling2D(pool_size=(pool_size, pool_size)),
#
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# MaxPooling2D(pool_size=(pool_size, pool_size)),
# ]
#
# decoding_layers = [
# UpSampling2D(size=(pool_size,pool_size)),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
#
# UpSampling2D(size=(pool_size,pool_size)),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(512, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(256, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
#
# UpSampling2D(size=(pool_size,pool_size)),
# Convolution2D(256, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(256, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(128, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
#
# UpSampling2D(size=(pool_size,pool_size)),
# Convolution2D(128, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(64, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
#
# UpSampling2D(size=(pool_size,pool_size)),
# Convolution2D(64, kernel, kernel, border_mode='same'),
# BatchNormalization(),
# Activation('relu'),
# Convolution2D(n_labels, 1, 1, border_mode='valid'),
# BatchNormalization(),
# ]
#
#
# segnet_basic = Sequential()
#
# segnet_basic.add(Layer(input_shape=(img_h, img_w,1)))
#
#
# segnet_basic.encoding_layers = encoding_layers
# for l in segnet_basic.encoding_layers:
# segnet_basic.add(l)
#
#
# segnet_basic.decoding_layers = decoding_layers
# for l in segnet_basic.decoding_layers:
# segnet_basic.add(l)
#
#
# segnet_basic.add(Reshape((nClasses, img_h * img_w), input_shape=(nClasses,img_h, img_w)))
# segnet_basic.add(Permute((2, 1)))
# if nClasses>1:
# segnet_basic.add(Activation('softmax'))
# if nClasses==1:
# segnet_basic.add(Activation('sigmoid'))
# if nClasses>1:
# segnet_basic.compile(loss="categorical_crossentropy", optimizer = Adam(lr = 1e-4) , metrics=['accuracy'] )
# if nClasses==1:
# segnet_basic.compile(loss="binary_crossentropy", optimizer = Adam(lr = 1e-4) , metrics=['accuracy'] )
# segnet_basic.summary()
return model
def get_unet():
with tf.device('/device:GPU:0'):
inputs = Input((192, 192, 3), name='Input')
conv1 = Conv2D(64, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv1_1')(inputs)
conv1 = BatchNormalization(name='BN1_1')(conv1)
conv1 = Activation('relu', name='Activation1_1')(conv1)
conv1 = Conv2D(64, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv1_2')(conv1)
conv1 = BatchNormalization(name='BN1_2')(conv1)
conv1 = Activation('relu', name='Activation1_2')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2), name='MaxPool1')(conv1)
conv2 = Conv2D(128, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv2_1')(pool1)
conv2 = BatchNormalization(name='BN2_1')(conv2)
conv2 = Activation('relu', name='Activation2_1')(conv2)
conv2 = Conv2D(128, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv2_2')(conv2)
conv2 = BatchNormalization(name='BN2_2')(conv2)
conv2 = Activation('relu', name='Activation2_2')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2), name='MaxPool2')(conv2)
conv3 = Conv2D(192, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv3_1')(pool2)
conv3 = BatchNormalization(name='BN3_1')(conv3)
conv3 = Activation('relu', name='Activation3_1')(conv3)
conv3 = Conv2D(192, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv3_2')(conv3)
conv3 = BatchNormalization(name='BN3_2')(conv3)
conv3 = Activation('relu', name='Activation3_2')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2), name='MaxPool3')(conv3)
conv4 = Conv2D(256, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv4_1')(pool3)
conv4 = BatchNormalization(name='BN4_1')(conv4)
conv4 = Activation('relu', name='Activation4_1')(conv4)
conv4 = Conv2D(256, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv4_2')(conv4)
conv4 = BatchNormalization(name='BN4_2')(conv4)
conv4 = Activation('relu', name='Activation4_2')(conv4)
drop4 = Dropout(0.2, name='Dropout1')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2), name='MaxPool4')(drop4)
conv5 = Conv2D(512, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv5_1')(pool4)
conv5 = BatchNormalization(name='BN5_1')(conv5)
conv5 = Activation('relu', name='Activation5_1')(conv5)
conv5 = Conv2D(512, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv5_2')(conv5)
conv5 = BatchNormalization(name='BN5_2')(conv5)
conv5 = Activation('relu', name='Activation5_2')(conv5)
drop5 = Dropout(0.2, name='Dropout2')(conv5)
with tf.device('/device:GPU:1'):
up6 = Conv2D(384, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal',
name='conv6_1')(UpSampling2D(size=(2, 2),
name='Up1')(drop5))
merge6 = keras.layers.Concatenate(name='concat1')([drop4, up6])
conv6 = Conv2D(256, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv6_2')(merge6)
conv6 = BatchNormalization(name='BN6_1')(conv6)
conv6 = Activation('relu', name='Activation6_1')(conv6)
conv6 = Conv2D(224, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv6_3')(conv6)
conv6 = BatchNormalization(name='BN6_2')(conv6)
conv6 = Activation('relu', name='Activation6_2')(conv6)
up7 = Conv2D(224, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal',
name='conv7_1')(UpSampling2D(size=(2, 2),
name='Up2')(conv6))
merge7 = keras.layers.Concatenate(name='concat2')([conv3, up7])
conv7 = Conv2D(192, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv7_2')(merge7)
conv7 = BatchNormalization(name='BN7_1')(conv7)
conv7 = Activation('relu', name='Activation7_1')(conv7)
conv7 = Conv2D(160, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv7_3')(conv7)
conv7 = BatchNormalization(name='BN7_2')(conv7)
conv7 = Activation('relu', name='Activation7_2')(conv7)
up8 = Conv2D(128, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal',
name='conv8_1')(UpSampling2D(size=(2, 2),
name='Up3')(conv7))
merge8 = keras.layers.Concatenate(name='concat3')([conv2, up8])
conv8 = Conv2D(96, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv8_2')(merge8)
conv8 = BatchNormalization(name='BN8_1')(conv8)
conv8 = Activation('relu', name='Activation8_1')(conv8)
conv8 = Conv2D(64, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv8_3')(conv8)
conv8 = BatchNormalization(name='BN8_2')(conv8)
conv8 = Activation('relu', name='Activation8_2')(conv8)
up9 = Conv2D(64, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal',
name='conv9_1')(UpSampling2D(size=(2, 2),
name='Up4')(conv8))
merge9 = keras.layers.Concatenate(name='concat4')([conv1, up9])
conv9 = Conv2D(32, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv9_2')(merge9)
conv9 = BatchNormalization(name='BN9_1')(conv9)
conv9 = Activation('relu', name='Activation9_1')(conv9)
conv9 = Conv2D(16, (3, 3),
padding='same',
kernel_initializer='he_normal',
name='conv9_3')(conv9)
conv9 = BatchNormalization(name='BN9_2')(conv9)
conv9 = Activation('relu', name='Activation9_2')(conv9)
conv10 = Conv2D(1, 1, activation='sigmoid', name='conv10_1')(conv9)
model = Model(inputs, conv10)
model.compile(loss='binary_crossentropy',
optimizer=SGD(lr=0.003, momentum=0.9, nesterov=True),
metrics=[dice_coef, jaccard_coef, 'acc'])
return model
def segnet(nClasses, optimizer=None, input_height=360, input_width=480):
kernel = 3
filter_size = 64
pad = 1
pool_size = 2
img_input = Input(shape=(input_height, input_width, 3))
x = ZeroPadding2D(padding=(pad, pad))(img_input)
x = Convolution2D(filter_size, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
l1 = x
x = MaxPooling2D(pool_size=(pool_size, pool_size))(x)
x = ZeroPadding2D(padding=(pad, pad))(x)
x = Convolution2D(128, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
l2 = x
x = MaxPooling2D(pool_size=(pool_size, pool_size))(x)
x = ZeroPadding2D(padding=(pad, pad))(x)
x = Convolution2D(256, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
l3 = x
x = MaxPooling2D(pool_size=(pool_size, pool_size))(x)
x = ZeroPadding2D(padding=(pad, pad))(x)
x = Convolution2D(512, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
l4 = x
x = Activation('relu')(x)
# decoder
x = ZeroPadding2D(padding=(pad, pad))(x)
x = Convolution2D(512, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
# x = Add()([l4, x])
x = UpSampling2D(size=(pool_size, pool_size))(x)
x = ZeroPadding2D(padding=(pad, pad))(x)
x = Convolution2D(256, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
# x = Add()([l3, x])
x = UpSampling2D(size=(pool_size, pool_size))(x)
x = ZeroPadding2D(padding=(pad, pad))(x)
x = Convolution2D(128, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
# x = Add()([l2, x])
x = UpSampling2D(size=(pool_size, pool_size))(x)
x = ZeroPadding2D(padding=(pad, pad))(x)
x = Convolution2D(filter_size, (kernel, kernel), padding='valid')(x)
x = BatchNormalization()(x)
# x = Add()([l1, x])
x = Convolution2D(nClasses, (1, 1), padding='valid')(x)
out = CrfRnnLayer(image_dims=(input_height, input_width),
num_classes=nClasses,
theta_alpha=160.,
theta_beta=3.,
theta_gamma=3.,
num_iterations=5,
name='crfrnn')([x, img_input])
a = Model(inputs=img_input, outputs=out)
model = []
a.outputHeight = a.output_shape[1]
a.outputWidth = a.output_shape[2]
out = Reshape((a.outputHeight * a.outputWidth, nClasses),
input_shape=(nClasses, a.outputHeight, a.outputWidth))(out)
out = Activation('softmax')(out)
model = Model(inputs=img_input, outputs=out)
model.outputHeight = a.outputHeight
model.outputWidth = a.outputWidth
return model
def Unet_HC(shp=cfg.shape_train_data, weights_path=cfg.path_load_weights):
print('-- Current file: model.py -- Unet_HC model')
act = 'elu'
inputs = Input(shp, name='main_input')
conv1 = Convolution2D(32, 3, 3, activation=act, border_mode='same')(inputs)
conv1 = Convolution2D(32, 3, 3, activation=act, border_mode='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Convolution2D(64, 3, 3, activation=act, border_mode='same')(pool1)
conv2 = Convolution2D(64, 3, 3, activation=act, border_mode='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Convolution2D(128, 3, 3, activation=act, border_mode='same')(pool2)
conv3 = Convolution2D(128, 3, 3, activation=act, border_mode='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Convolution2D(256, 3, 3, activation=act, border_mode='same')(pool3)
conv4 = Convolution2D(256, 3, 3, activation=act, border_mode='same')(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Convolution2D(512, 3, 3, activation=act, border_mode='same')(pool4)
conv5 = Convolution2D(512, 3, 3, activation=act, border_mode='same')(conv5)
#Hypercolumns
#hc_conv5 = UpSampling2D(size=(16, 16))(conv5) #8x8, f = 16
#hc_conv4 = UpSampling2D(size=(8, 8))(conv4) #16x16, f = 8
hc_conv3 = UpSampling2D(size=(4, 4))(conv3) #32x32, f = 4
hc_conv2 = UpSampling2D(size=(2, 2))(conv2) #64x64, f = 2
hc = merge([conv1, hc_conv2, hc_conv3], mode='concat',
concat_axis=1) #(None, 992, 128, 128)
hc_red_conv1 = Convolution2D(128,
3,
3,
border_mode='same',
init='he_normal',
activation=act)(hc)
hc_red_conv2 = Convolution2D(64,
3,
3,
border_mode='same',
init='he_normal',
activation=act)(hc_red_conv1)
hc_red_conv3 = Convolution2D(shp[0],
1,
1,
init='he_normal',
activation='linear',
name='aux_output')(hc_red_conv2)
up6 = merge([UpSampling2D(size=(2, 2))(conv5), conv4],
mode='concat',
concat_axis=1)
conv6 = Convolution2D(256, 3, 3, activation=act, border_mode='same')(up6)
conv6 = Convolution2D(256, 3, 3, activation=act, border_mode='same')(conv6)
up7 = merge([UpSampling2D(size=(2, 2))(conv6), conv3],
mode='concat',
concat_axis=1)
conv7 = Convolution2D(128, 3, 3, activation=act, border_mode='same')(up7)
conv7 = Convolution2D(128, 3, 3, activation=act, border_mode='same')(conv7)
up8 = merge([UpSampling2D(size=(2, 2))(conv7), conv2],
mode='concat',
concat_axis=1)
conv8 = Convolution2D(64, 3, 3, activation=act, border_mode='same')(up8)
conv8 = Convolution2D(64, 3, 3, activation=act, border_mode='same')(conv8)
up9 = merge([UpSampling2D(size=(2, 2))(conv8), conv1],
mode='concat',
concat_axis=1)
conv9 = Convolution2D(32, 3, 3, activation=act, border_mode='same')(up9)
conv9 = Convolution2D(32, 3, 3, activation=act, border_mode='same')(conv9)
conv10 = Convolution2D(3, 1, 1, activation='linear',
name='main_output')(conv9)
model = Model(input=inputs, output=[conv10, hc_red_conv3])
if weights_path <> '':
model.load_weights(weights_path)
model.compile(optimizer=Adam(lr=cfg.learning_rate),
loss={
'main_output': huber,
'aux_output': huber
},
loss_weights={
'main_output': 0.8,
'aux_output': 0.2
})
return model
def __init__(self, digit_size, num_classes, latent_dim, sess_name=''):
self.sess = tf.Session()
self.digit_size = digit_size
self.latent_dim = latent_dim
self.a = tf.placeholder(tf.float32,
shape=(None, self.digit_size, self.digit_size,
1))
self.b = tf.placeholder(tf.float32, shape=(None, num_classes))
self.c = tf.placeholder(tf.float32, shape=(None, latent_dim))
self.img = Input(tensor=self.a)
self.lbls = Input(tensor=self.b)
self.z = Input(tensor=self.c)
############## Build Discriminator #################
with tf.variable_scope('discriminator'):
x = Conv2D(128,
kernel_size=(7, 7),
strides=(2, 2),
padding='same',
activation='relu')(self.img)
x = self.add_units_to_conv2d(x, self.lbls)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(64,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(16,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
h = Flatten()(x)
disc_output = Dense(1, activation='sigmoid')(h)
self.discriminator = Model([self.img, self.lbls], disc_output)
############# Build Generator #####################
with tf.variable_scope('generator'):
x = concatenate([self.z, self.lbls])
x = Dense(7 * 7 * 128, activation='relu')(x)
x = Reshape((7, 7, 128))(x)
x = UpSampling2D(size=(2, 2))(x)
x = Conv2D(64,
kernel_size=(5, 5),
padding='same',
activation='relu')(x)
x = Conv2D(32,
kernel_size=(3, 3),
padding='same',
activation='relu')(x)
x = UpSampling2D(size=(2, 2))(x)
gen_output = Conv2D(1,
kernel_size=(5, 5),
activation='sigmoid',
padding='same')(x)
self.generator = Model([self.z, self.lbls], gen_output)
################ GAN ##################
self.generated_img = self.generator([self.z, self.lbls])
self.discr_real_img = self.discriminator([self.img, self.lbls])
self.discr_fake_img = self.discriminator(
[self.generated_img, self.lbls])
#self.cgan = Model([self.img, self.lbls], discr_fake_img)
############## Define Losses #################
log_d_img = tf.reduce_mean(-tf.log(self.discr_real_img + 1e-10))
log_d_gen_img = tf.reduce_mean(-tf.log(1. - self.discr_fake_img +
1e-10))
self.GenLoss = -log_d_gen_img
self.DiscrLoss = 0.5 * (log_d_gen_img + log_d_img)
############## Optimizers #############
GenOpt = tf.train.RMSPropOptimizer(0.0003)
DiscrOpt = tf.train.RMSPropOptimizer(0.0001)
Gen_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
'generator')
Discr_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
'discriminator')
self.gen_step = GenOpt.minimize(self.GenLoss, var_list=Gen_vars)
self.discr_step = DiscrOpt.minimize(self.DiscrLoss,
var_list=Discr_vars)
self.saver = tf.train.Saver()
self.sess.run(tf.global_variables_initializer())
if (sess_name):
self.saver.restore(self.sess, './' + sess_name)
def EURNet(shp=cfg.shape_train_data, weights_path=cfg.path_load_weights):
print('-- Current file: model.py -- EURNet model')
split = True
#Encoder
inputs = Input(shp, name='main_input')
conv1 = inception_block(inputs, 32, batch_mode=2, split=split)
pool1 = custom_convolution2D(32,
3,
3,
border_mode='same',
subsample=(2, 2))(conv1)
pool1 = Dropout(0.5)(pool1)
conv2 = inception_block(pool1, 64, batch_mode=2, split=split)
pool2 = custom_convolution2D(64,
3,
3,
border_mode='same',
subsample=(2, 2))(conv2)
pool2 = Dropout(0.5)(pool2)
conv3 = inception_block(pool2, 128, batch_mode=2, split=split)
pool3 = custom_convolution2D(128,
3,
3,
border_mode='same',
subsample=(2, 2))(conv3)
pool3 = Dropout(0.5)(pool3)
conv4 = inception_block(pool3, 256, batch_mode=2, split=split)
pool4 = custom_convolution2D(256,
3,
3,
border_mode='same',
subsample=(2, 2))(conv4)
pool4 = Dropout(0.5)(pool4)
conv5 = inception_block(pool4, 512, batch_mode=2, split=split)
conv5 = Dropout(0.5)(conv5)
#Hypercolumns
hc_conv3 = UpSampling2D(size=(4, 4))(conv3)
hc_conv2 = UpSampling2D(size=(2, 2))(conv2)
hc = merge([conv1, hc_conv2, hc_conv3], mode='concat', concat_axis=1)
i1 = inception_block(hc, 128, batch_mode=2, split=split)
i1 = Dropout(0.5)(i1)
i2 = inception_block(i1, 64, batch_mode=2, split=split)
i2 = Dropout(0.5)(i2)
hc_red_conv3 = Convolution2D(shp[0],
1,
1,
init='he_normal',
activation='linear',
name='aux_output')(
i2) #W_regularizer=l2(0.01)
#Decoder
up6 = merge([UpSampling2D(size=(2, 2))(conv5), conv4],
mode='concat',
concat_axis=1)
conv6 = inception_block(up6, 256, batch_mode=2, split=split)
conv6 = Dropout(0.5)(conv6)
up7 = merge([UpSampling2D(size=(2, 2))(conv6), conv3],
mode='concat',
concat_axis=1)
conv7 = inception_block(up7, 128, batch_mode=2, split=split)
conv7 = Dropout(0.5)(conv7)
up8 = merge([UpSampling2D(size=(2, 2))(conv7), conv2],
mode='concat',
concat_axis=1)
conv8 = inception_block(up8, 64, batch_mode=2, split=split)
conv8 = Dropout(0.5)(conv8)
up9 = merge([UpSampling2D(size=(2, 2))(conv8), conv1],
mode='concat',
concat_axis=1)
conv9 = inception_block(up9, 32, batch_mode=2, split=split)
conv9 = Dropout(0.5)(conv9)
conv10 = Convolution2D(shp[0],
1,
1,
init='he_normal',
activation='linear',
name='main_output')(conv9) #W_regularizer=l2(0.01)
model = Model(input=inputs, output=[conv10, hc_red_conv3])
if weights_path <> '':
model.load_weights(weights_path)
model.compile(optimizer=Adam(lr=cfg.learning_rate),
loss={
'main_output': huber,
'aux_output': huber
},
loss_weights={
'main_output': 0.8,
'aux_output': 0.2
})
return model
def HC(shp=cfg.shape_train_data, weights_path=cfg.path_load_weights):
print('-- Current file: model.py -- HC model')
split = True
# Encoder
inputs = Input(shp)
conv1 = inception_block(inputs, 32, batch_mode=2, split=split)
pool1 = custom_convolution2D(32,
3,
3,
border_mode='same',
subsample=(2, 2))(conv1)
pool1 = Dropout(0.5)(pool1)
conv2 = inception_block(pool1, 64, batch_mode=2, split=split)
pool2 = custom_convolution2D(64,
3,
3,
border_mode='same',
subsample=(2, 2))(conv2)
pool2 = Dropout(0.5)(pool2)
conv3 = inception_block(pool2, 128, batch_mode=2, split=split)
pool3 = custom_convolution2D(128,
3,
3,
border_mode='same',
subsample=(2, 2))(conv3)
pool3 = Dropout(0.5)(pool3)
conv4 = inception_block(pool3, 256, batch_mode=2, split=split)
pool4 = custom_convolution2D(256,
3,
3,
border_mode='same',
subsample=(2, 2))(conv4)
pool4 = Dropout(0.5)(pool4)
conv5 = inception_block(pool4, 512, batch_mode=2, split=split)
conv5 = Dropout(0.5)(conv5)
# Hypercolumns
hc_conv5 = UpSampling2D(size=(16, 16))(conv5) #8x8, f = 16
hc_conv4 = UpSampling2D(size=(8, 8))(conv4) #16x16, f = 8
hc_conv3 = UpSampling2D(size=(4, 4))(conv3) #32x32, f = 4
hc_conv2 = UpSampling2D(size=(2, 2))(conv2) #64x64, f = 2
hc = merge([conv1, hc_conv2, hc_conv3, hc_conv4, hc_conv5],
mode='concat',
concat_axis=1)
#hc = merge([conv1, hc_conv2, hc_conv3], mode='concat', concat_axis=1)
i1 = inception_block(hc, 128, batch_mode=2, split=split)
i1 = Dropout(0.5)(i1)
i2 = inception_block(i1, 64, batch_mode=2, split=split)
i2 = Dropout(0.5)(i2)
hc_red_conv3 = Convolution2D(shp[0],
1,
1,
init='he_normal',
activation='linear',
name='aux_output')(i2)
model = Model(input=inputs, output=[hc_red_conv3])
if weights_path <> '':
model.load_weights(weights_path)
model.compile(loss=huber, optimizer=Adam(clipnorm=1.))
return model
def SUnet(shp=cfg.shape_train_data, weights_path=cfg.path_load_weights):
print('-- Current file: model.py -- Unet model with inception modules')
split = False
# Encoder
inputs = Input(shp)
conv1 = inception_block(inputs, 32, batch_mode=2, split=split)
pool1 = custom_convolution2D(32,
3,
3,
border_mode='same',
subsample=(2, 2))(conv1)
pool1 = Dropout(0.5)(pool1)
conv2 = inception_block(pool1, 64, batch_mode=2, split=split)
pool2 = custom_convolution2D(64,
3,
3,
border_mode='same',
subsample=(2, 2))(conv2)
pool2 = Dropout(0.5)(pool2)
conv3 = inception_block(pool2, 128, batch_mode=2, split=split)
pool3 = custom_convolution2D(128,
3,
3,
border_mode='same',
subsample=(2, 2))(conv3)
pool3 = Dropout(0.5)(pool3)
conv4 = inception_block(pool3, 256, batch_mode=2, split=split)
pool4 = custom_convolution2D(256,
3,
3,
border_mode='same',
subsample=(2, 2))(conv4)
pool4 = Dropout(0.5)(pool4)
conv5 = inception_block(pool4, 512, batch_mode=2, split=split)
conv5 = Dropout(0.5)(conv5)
# Decoder
up6 = merge([UpSampling2D(size=(2, 2))(conv5), conv4],
mode='concat',
concat_axis=1)
conv6 = inception_block(up6, 256, batch_mode=2, split=split)
conv6 = Dropout(0.5)(conv6)
up7 = merge([UpSampling2D(size=(2, 2))(conv6), conv3],
mode='concat',
concat_axis=1)
conv7 = inception_block(up7, 128, batch_mode=2, split=split)
conv7 = Dropout(0.5)(conv7)
up8 = merge([UpSampling2D(size=(2, 2))(conv7), conv2],
mode='concat',
concat_axis=1)
conv8 = inception_block(up8, 64, batch_mode=2, split=split)
conv8 = Dropout(0.5)(conv8)
up9 = merge([UpSampling2D(size=(2, 2))(conv8), conv1],
mode='concat',
concat_axis=1)
conv9 = inception_block(up9, 32, batch_mode=2, split=split)
conv9 = Dropout(0.5)(conv9)
conv10 = Convolution2D(shp[0],
1,
1,
init='he_normal',
activation='sigmoid')(conv9)
model = Model(input=inputs, output=[conv10])
if weights_path <> '':
model.load_weights(weights_path)
model.compile(loss=huber, optimizer=Adam(lr=cfg.learning_rate))
return model
def segnet(nClasses, optimizer=None, input_height=360, input_width=480):
kernel = 3
filter_size = 64
pad = 1
pool_size = 2
model = models.Sequential()
model.add(Layer(input_shape=(3, input_height, input_width)))
# encoder
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(filter_size, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(128, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(256, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(512, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
# decoder
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(512, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(256, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(128, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(UpSampling2D(size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad, pad)))
model.add(Convolution2D(filter_size, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Convolution2D(
nClasses,
1,
1,
border_mode='valid',
))
model.outputHeight = model.output_shape[-2]
model.outputWidth = model.output_shape[-1]
model.add(
Reshape((nClasses, model.output_shape[-2] * model.output_shape[-1]),
input_shape=(nClasses, model.output_shape[-2],
model.output_shape[-1])))
model.add(Permute((2, 1)))
model.add(Activation('softmax'))
if optimizer != None:
model.compile(loss="categorical_crossentropy",
optimizer=optimizer,
metrics=['accuracy'])
return model
res8 = seperableConv_bottleneck_block_with_se(pool4,
filters=384,
cardinality=8,
strides=1,
weight_decay=5e-4)
res8 = seperableConv_bottleneck_block_with_se(
res8, filters=384, cardinality=32, strides=1,
weight_decay=5e-4) #12x12x384
with tf.device('/device:GPU:3'):
up1 = Conv2D(256, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(res8)) #24x24x256
merge1 = keras.layers.Add()([res7, up1])
upres8 = seperableConv_bottleneck_block_with_se(
merge1, filters=256, cardinality=32, strides=1,
weight_decay=5e-4) #24x24x256
up2 = Conv2D(192, (3, 3),
activation='relu',
padding='same',
kernel_initializer='he_normal')(
UpSampling2D(size=(2, 2))(upres8)) #48x48x192
merge2 = keras.layers.Add()([res6, up2])
upres7 = seperableConv_bottleneck_block_with_se(
merge2, filters=192, cardinality=32, strides=1,
weight_decay=5e-4) #48x48x192
def isensee2017(nClasses,shape,W,lr, n_base_filters=16, depth=5, dropout_rate=0.3,
n_segmentation_levels=3, optimizer=Adam, initial_learning_rate=5e-4,
loss_function=weighted_dice_coefficient_loss, activation_name="sigmoid"):
"""
This function builds a model proposed by Isensee et al. for the BRATS 2017 competition:
https://www.cbica.upenn.edu/sbia/Spyridon.Bakas/MICCAI_BraTS/MICCAI_BraTS_2017_proceedings_shortPapers.pdf
This network is highly similar to the model proposed by Kayalibay et al. "CNN-based Segmentation of Medical
Imaging Data", 2017: https://arxiv.org/pdf/1701.03056.pdf
:param input_shape:
:param n_base_filters:
:param depth:
:param dropout_rate:
:param n_segmentation_levels:
:param nClasses:
:param optimizer:
:param initial_learning_rate:
:param loss_function:
:param activation_name:
:return:
"""
inputs = Input(shape)
current_layer = inputs
level_output_layers = list()
level_filters = list()
for level_number in range(depth):
n_level_filters = (2**level_number) * n_base_filters
level_filters.append(n_level_filters)
if current_layer is inputs:
in_conv = create_convolution_block(current_layer, n_level_filters)
else:
in_conv = create_convolution_block(current_layer, n_level_filters, strides=(2, 2))
context_output_layer = create_context_module(in_conv, n_level_filters, dropout_rate=dropout_rate)
summation_layer = Add()([in_conv, context_output_layer])
level_output_layers.append(summation_layer)
current_layer = summation_layer
segmentation_layers = list()
for level_number in range(depth - 2, -1, -1):
up_sampling = create_up_sampling_module(current_layer, level_filters[level_number])
concatenation_layer = concatenate([level_output_layers[level_number], up_sampling], axis=3)
localization_output = create_localization_module(concatenation_layer, level_filters[level_number])
current_layer = localization_output
if level_number < n_segmentation_levels:
segmentation_layers.insert(0, create_convolution_block(current_layer, n_filters=nClasses, kernel=(1, 1)))
output_layer = None
for level_number in reversed(range(n_segmentation_levels)):
segmentation_layer = segmentation_layers[level_number]
if output_layer is None:
output_layer = segmentation_layer
else:
output_layer = Add()([output_layer, segmentation_layer])
if level_number > 0:
output_layer = UpSampling2D(size=(2, 2))(output_layer)
activation_block = Activation(activation_name)(output_layer)
model = Model(inputs=inputs, outputs=activation_block)
if W !='':
model.load_weights(W)
model.compile(optimizer=optimizer(lr=initial_learning_rate), loss=loss_function)
model.summary()
return model
def segnet(
input_shape,
n_labels,
kernel=3,
pool_size=(2, 2),
output_mode="softmax",
use_residual=False,
use_argmax=True):
# encoder
inputs = Input(shape=input_shape)
residual_connections = []
conv_1 = Conv2D(64, kernel, padding="same")(inputs)
conv_1 = BatchNormalization()(conv_1)
conv_1 = Activation("relu")(conv_1)
conv_2 = Conv2D(64, kernel, padding="same")(conv_1)
conv_2 = BatchNormalization()(conv_2)
conv_2 = Activation("relu")(conv_2)
if use_argmax: pool_1, mask_1 = MaxPoolingWithArgmax2D(pool_size)(conv_2)
else: pool_1 = MaxPooling2D(pool_size)(conv_2)
if use_residual: residual_connections.append(pool_1)
conv_3 = Conv2D(128, kernel, padding="same")(pool_1)
conv_3 = BatchNormalization()(conv_3)
conv_3 = Activation("relu")(conv_3)
conv_4 = Conv2D(128, kernel, padding="same")(conv_3)
conv_4 = BatchNormalization()(conv_4)
conv_4 = Activation("relu")(conv_4)
if use_argmax: pool_2, mask_2 = MaxPoolingWithArgmax2D(pool_size)(conv_4)
else: pool_2 = MaxPooling2D(pool_size)(conv_4)
if use_residual: residual_connections.append(pool_2)
conv_5 = Conv2D(256, kernel, padding="same")(pool_2)
conv_5 = BatchNormalization()(conv_5)
conv_5 = Activation("relu")(conv_5)
conv_6 = Conv2D(256, kernel, padding="same")(conv_5)
conv_6 = BatchNormalization()(conv_6)
conv_6 = Activation("relu")(conv_6)
conv_7 = Conv2D(256, kernel, padding="same")(conv_6)
conv_7 = BatchNormalization()(conv_7)
conv_7 = Activation("relu")(conv_7)
if use_argmax: pool_3, mask_3 = MaxPoolingWithArgmax2D(pool_size)(conv_7)
else: pool_3 = MaxPooling2D(pool_size)(conv_7)
if use_residual: residual_connections.append(pool_3)
conv_8 = Conv2D(512, kernel, padding="same")(pool_3)
conv_8 = BatchNormalization()(conv_8)
conv_8 = Activation("relu")(conv_8)
conv_9 = Conv2D(512, kernel, padding="same")(conv_8)
conv_9 = BatchNormalization()(conv_9)
conv_9 = Activation("relu")(conv_9)
conv_10 = Conv2D(512, kernel, padding="same")(conv_9)
conv_10 = BatchNormalization()(conv_10)
conv_10 = Activation("relu")(conv_10)
if use_argmax: pool_4, mask_4 = MaxPoolingWithArgmax2D(pool_size)(conv_10)
else: pool_4 = MaxPooling2D(pool_size)(conv_10)
if use_residual: residual_connections.append(pool_4)
conv_11 = Conv2D(512, kernel, padding="same")(pool_4)
conv_11 = BatchNormalization()(conv_11)
conv_11 = Activation("relu")(conv_11)
conv_12 = Conv2D(512, kernel, padding="same")(conv_11)
conv_12 = BatchNormalization()(conv_12)
conv_12 = Activation("relu")(conv_12)
conv_13 = Conv2D(512, kernel, padding="same")(conv_12)
conv_13 = BatchNormalization()(conv_13)
conv_13 = Activation("relu")(conv_13)
if use_argmax: pool_5, mask_5 = MaxPoolingWithArgmax2D(pool_size)(conv_13)
else: pool_5 = MaxPooling2D(pool_size)(conv_13)
if use_residual: residual_connections.append(pool_5)
print("Done building encoder..")
# decoder
if use_residual: pool_5 = Add()([pool_5, residual_connections[-1]])
if use_argmax: unpool_1 = MaxUnpooling2D(pool_size)([pool_5, mask_5])
else: unpool_1 = UpSampling2D(pool_size)(pool_5)
conv_14 = Conv2D(512, kernel, padding="same")(unpool_1)
conv_14 = BatchNormalization()(conv_14)
conv_14 = Activation("relu")(conv_14)
conv_15 = Conv2D(512, kernel, padding="same")(conv_14)
conv_15 = BatchNormalization()(conv_15)
conv_15 = Activation("relu")(conv_15)
conv_16 = Conv2D(512, kernel, padding="same")(conv_15)
conv_16 = BatchNormalization()(conv_16)
conv_16 = Activation("relu")(conv_16)
if use_residual: conv_16 = Add()([conv_16, residual_connections[-2]])
if use_argmax: unpool_2 = MaxUnpooling2D(pool_size)([conv_16, mask_4])
else: unpool_2 = UpSampling2D(pool_size)(conv_16)
conv_17 = Conv2D(512, kernel, padding="same")(unpool_2)
conv_17 = BatchNormalization()(conv_17)
conv_17 = Activation("relu")(conv_17)
conv_18 = Conv2D(512, kernel, padding="same")(conv_17)
conv_18 = BatchNormalization()(conv_18)
conv_18 = Activation("relu")(conv_18)
conv_19 = Conv2D(256, kernel, padding="same")(conv_18)
conv_19 = BatchNormalization()(conv_19)
conv_19 = Activation("relu")(conv_19)
if use_residual: conv_19 = Add()([conv_19, residual_connections[-3]])
if use_argmax: unpool_3 = MaxUnpooling2D(pool_size)([conv_19, mask_3])
else: unpool_3 = UpSampling2D(pool_size)(conv_19)
conv_20 = Conv2D(256, kernel, padding="same")(unpool_3)
conv_20 = BatchNormalization()(conv_20)
conv_20 = Activation("relu")(conv_20)
conv_21 = Conv2D(256, kernel, padding="same")(conv_20)
conv_21 = BatchNormalization()(conv_21)
conv_21 = Activation("relu")(conv_21)
conv_22 = Conv2D(128, kernel, padding="same")(conv_21)
conv_22 = BatchNormalization()(conv_22)
conv_22 = Activation("relu")(conv_22)
if use_residual: conv_22 = Add()([conv_22, residual_connections[-4]])
if use_argmax: unpool_4 = MaxUnpooling2D(pool_size)([conv_22, mask_2])
else: unpool_4 = UpSampling2D(pool_size)(conv_22)
conv_23 = Conv2D(128, kernel, padding="same")(unpool_4)
conv_23 = BatchNormalization()(conv_23)
conv_23 = Activation("relu")(conv_23)
conv_24 = Conv2D(64, kernel, padding="same")(conv_23)
conv_24 = BatchNormalization()(conv_24)
conv_24 = Activation("relu")(conv_24)
if use_residual: conv_24 = Add()([conv_24, residual_connections[-5]])
if use_argmax: unpool_5 = MaxUnpooling2D(pool_size)([conv_24, mask_1])
else: unpool_5 = UpSampling2D(pool_size)(conv_24)
conv_25 = Conv2D(64, kernel, padding="same")(unpool_5)
conv_25 = BatchNormalization()(conv_25)
conv_25 = Activation("relu")(conv_25)
conv_26 = Conv2D(n_labels, 1, padding="same")(conv_25)
conv_26 = BatchNormalization()(conv_26)
outputs = Activation(output_mode)(conv_26)
print("Done building decoder..")
model = Model(inputs=inputs, outputs=outputs, name="SegNet")
return model
def SegNet(nClasses,shape,W,lr):
input_height=shape[0]
input_width=shape[1]
kernel = 3
filter_size = 64
pad = 1
pool_size = 2
model = Sequential()
model.add(Layer(input_shape=(input_height , input_width , 1)))
# encoder
model.add(ZeroPadding2D(padding=(pad,pad)))
model.add(Convolution2D(filter_size, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad,pad)))
model.add(Convolution2D(128, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad,pad)))
model.add(Convolution2D(256, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(pool_size, pool_size)))
model.add(ZeroPadding2D(padding=(pad,pad)))
model.add(Convolution2D(512, kernel, kernel, border_mode='valid'))
model.add(BatchNormalization())
model.add(Activation('relu'))
# decoder
model.add( ZeroPadding2D(padding=(pad,pad)))
model.add( Convolution2D(512, kernel, kernel, border_mode='valid'))
model.add( BatchNormalization())
model.add( UpSampling2D(size=(pool_size,pool_size)))
model.add( ZeroPadding2D(padding=(pad,pad)))
model.add( Convolution2D(256, kernel, kernel, border_mode='valid'))
model.add( BatchNormalization())
model.add( UpSampling2D(size=(pool_size,pool_size)))
model.add( ZeroPadding2D(padding=(pad,pad)))
model.add( Convolution2D(128, kernel, kernel, border_mode='valid'))
model.add( BatchNormalization())
model.add( UpSampling2D(size=(pool_size,pool_size)))
model.add( ZeroPadding2D(padding=(pad,pad)))
model.add( Convolution2D(filter_size, kernel, kernel, border_mode='valid'))
model.add( BatchNormalization())
model.add(Convolution2D( nClasses , 1, 1, border_mode='valid'))
model.outputHeight = model.output_shape[-2]
model.outputWidth = model.output_shape[-1]
if nClasses==1:
model.add(Activation('sigmoid'))
if nClasses>1:
model.add(Activation('relu'))
model.add(Reshape((shape[0] * shape[1],nClasses), input_shape=(shape[0], shape[1],nClasses)))
# model.add(Permute((2, 1)))
model.add(Activation('softmax'))
if W !='':
model.load_weights(W)
if nClasses == 1:
model.compile(loss='binary_crossentropy',optimizer=Adam(lr=0.0008),metrics=['accuracy'])
if nClasses > 1:
model.compile(loss='categorical_crossentropy',optimizer=Adadelta(lr=1.0),metrics=['accuracy'])
model.summary()
return model
def create_model(self):
init_img_width = self.img_width // 4
init_img_height = self.img_height // 4
random_input = Input(shape=(self.random_input_dim, ))
text_input1 = Input(shape=(self.text_input_dim, ))
random_dense = Dense(self.random_input_dim)(random_input)
text_layer1 = Dense(1024)(text_input1)
merged = concatenate([random_dense, text_layer1])
generator_layer = Activation('tanh')(merged)
generator_layer = Dense(128 * init_img_width *
init_img_height)(generator_layer)
generator_layer = BatchNormalization()(generator_layer)
generator_layer = Activation('tanh')(generator_layer)
generator_layer = Reshape(
(init_img_width, init_img_height, 128),
input_shape=(128 * init_img_width *
init_img_height, ))(generator_layer)
generator_layer = UpSampling2D(size=(2, 2))(generator_layer)
generator_layer = Conv2D(64, kernel_size=5,
padding='same')(generator_layer)
generator_layer = Activation('tanh')(generator_layer)
generator_layer = UpSampling2D(size=(2, 2))(generator_layer)
generator_layer = Conv2D(self.img_channels,
kernel_size=5,
padding='same')(generator_layer)
generator_output = Activation('tanh')(generator_layer)
self.generator = Model([random_input, text_input1], generator_output)
self.generator.compile(loss='mean_squared_error', optimizer="SGD")
print('generator: ', self.generator.summary())
text_input2 = Input(shape=(self.text_input_dim, ))
text_layer2 = Dense(1024)(text_input2)
img_input2 = Input(shape=(self.img_width, self.img_height,
self.img_channels))
img_layer2 = Conv2D(64, kernel_size=(5, 5), padding='same')(img_input2)
img_layer2 = Activation('tanh')(img_layer2)
img_layer2 = MaxPooling2D(pool_size=(2, 2))(img_layer2)
img_layer2 = Conv2D(128, kernel_size=5)(img_layer2)
img_layer2 = Activation('tanh')(img_layer2)
img_layer2 = MaxPooling2D(pool_size=(2, 2))(img_layer2)
img_layer2 = Flatten()(img_layer2)
img_layer2 = Dense(1024)(img_layer2)
merged = concatenate([img_layer2, text_layer2])
discriminator_layer = Activation('tanh')(merged)
discriminator_layer = Dense(1)(discriminator_layer)
discriminator_output = Activation('sigmoid')(discriminator_layer)
self.discriminator = Model([img_input2, text_input2],
discriminator_output)
d_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)
self.discriminator.compile(loss='binary_crossentropy',
optimizer=d_optim)
print('discriminator: ', self.discriminator.summary())
model_output = self.discriminator([self.generator.output, text_input1])
self.model = Model([random_input, text_input1], model_output)
self.discriminator.trainable = False
g_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)
self.model.compile(loss='binary_crossentropy', optimizer=g_optim)
print('generator-discriminator: ', self.model.summary())
def UNet(nClasses,shape,W,lr):
inputs = Input((shape[0], shape[1],1))
conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(inputs)
print ("conv1 shape:",conv1.shape)
conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv1)
print ("conv1 shape:",conv1.shape)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
print ("pool1 shape:",pool1.shape)
conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool1)
print ("conv2 shape:",conv2.shape)
conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv2)
print ("conv2 shape:",conv2.shape)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
print ("pool2 shape:",pool2.shape)
conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool2)
print ("conv3 shape:",conv3.shape)
conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv3)
print ("conv3 shape:",conv3.shape)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
print ("pool3 shape:",pool3.shape)
conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool3)
conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool4)
conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(512, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(drop5))
merge6 = merge([drop4,up6], mode = 'concat', concat_axis = 3)
conv6 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge6)
conv6 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv6)
up7 = Conv2D(256, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv6))
merge7 = merge([conv3,up7], mode = 'concat', concat_axis = 3)
conv7 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge7)
conv7 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv7)
up8 = Conv2D(128, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv7))
merge8 = merge([conv2,up8], mode = 'concat', concat_axis = 3)
conv8 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge8)
conv8 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv8)
up9 = Conv2D(64, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv8))
merge9 = merge([conv1,up9], mode = 'concat', concat_axis = 3)
conv9 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge9)
conv9 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)
conv9 = Conv2D(2, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)
o_shape = Model(inputs , conv9 ).output_shape
outputHeight = o_shape[1]
outputWidth = o_shape[2]
if nClasses>1:
conv10 = Conv2D(nClasses, 1)(conv9)
Reshape1 = Reshape((shape[0] * shape[1],nClasses), input_shape=(shape[0], shape[1],nClasses))(conv10)
# o = (Permute((2, 1)))(o)
o = (Activation('softmax'))(Reshape1)
if nClasses==1:
o = Conv2D(1, 1, activation = 'sigmoid')(conv9)
model = Model( inputs , o )
model.outputWidth = outputWidth
model.outputHeight = outputHeight
if W !='':
model.load_weights(W)
if nClasses>1:
model.compile(loss="categorical_crossentropy", optimizer=Adam(lr =lr) , metrics=['categorical_accuracy'] )
if nClasses==1:
model.compile(loss="binary_crossentropy", optimizer = Adam(lr = lr) , metrics=['accuracy'] )
model.summary()
return model
def generate_model(num_classes,
num_channel=3,
input_size=(300, 400),
output_size=(300, 400)):
# U-Net for binary segmentation
inputs = Input((num_channel, ) + input_size)
conv1 = Conv2D(64, kernel_size=(3, 3), padding='same')(inputs)
conv1 = BatchNormalization(axis=1)(PReLU()(conv1))
conv1 = Conv2D(64, kernel_size=(3, 3), padding='same')(conv1)
conv1 = BatchNormalization(axis=1)(PReLU()(conv1))
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(128, kernel_size=(3, 3), padding='same')(pool1)
conv2 = BatchNormalization(axis=1)(PReLU()(conv2))
conv2 = Conv2D(128, kernel_size=(3, 3), padding='same')(conv2)
conv2 = BatchNormalization(axis=1)(PReLU()(conv2))
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(256, kernel_size=(3, 3), padding='same')(pool2)
conv3 = BatchNormalization(axis=1)(PReLU()(conv3))
conv3 = Conv2D(256, kernel_size=(3, 3), padding='same')(conv3)
conv3 = BatchNormalization(axis=1)(PReLU()(conv3))
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(512, kernel_size=(3, 3), padding='same')(pool3)
conv4 = BatchNormalization(axis=1)(PReLU()(conv4))
conv4 = Conv2D(512, kernel_size=(3, 3), padding='same')(conv4)
conv4 = BatchNormalization(axis=1)(PReLU()(conv4))
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = Conv2D(1024, kernel_size=(3, 3), padding='same')(pool4)
conv5 = BatchNormalization(axis=1)(PReLU()(conv5))
conv5 = Conv2D(1024, kernel_size=(3, 3), padding='same')(conv5)
conv5 = BatchNormalization(axis=1)(PReLU()(conv5))
up6 = Conv2D(512, kernel_size=(2, 2),
padding='same')(UpSampling2D(size=(2, 2))(conv5))
concat6 = concatenate([conv4, up6], axis=1)
conv6 = Conv2D(512, kernel_size=(3, 3), padding='same')(concat6)
conv6 = BatchNormalization(axis=1)(PReLU()(conv6))
conv6 = Conv2D(512, kernel_size=(3, 3), padding='same')(conv6)
conv6 = BatchNormalization(axis=1)(PReLU()(conv6))
up7 = Conv2D(256, kernel_size=(2, 2),
padding='same')(UpSampling2D(size=(2, 2))(conv6))
concat7 = concatenate([conv3, up7], axis=1)
conv7 = Conv2D(256, kernel_size=(3, 3), padding='same')(concat7)
conv7 = BatchNormalization(axis=1)(PReLU()(conv7))
conv7 = Conv2D(256, kernel_size=(3, 3), padding='same')(conv7)
conv7 = BatchNormalization(axis=1)(PReLU()(conv7))
up8 = Conv2D(128, kernel_size=(2, 2),
padding='same')(UpSampling2D(size=(2, 2))(conv7))
concat8 = concatenate([conv2, up8], axis=1)
conv8 = Conv2D(128, kernel_size=(3, 3), padding='same')(concat8)
conv8 = BatchNormalization(axis=1)(PReLU()(conv8))
conv8 = Conv2D(128, kernel_size=(3, 3), padding='same')(conv8)
conv8 = BatchNormalization(axis=1)(PReLU()(conv8))
up9 = Conv2D(64, kernel_size=(2, 2),
padding='same')(UpSampling2D(size=(2, 2))(conv8))
concat9 = concatenate([conv1, up9], axis=1)
conv9 = Conv2D(64, kernel_size=(3, 3), padding='same')(concat9)
conv9 = BatchNormalization(axis=1)(PReLU()(conv9))
conv9 = Conv2D(64, kernel_size=(3, 3), padding='same')(conv9)
conv9 = BatchNormalization(axis=1)(PReLU()(conv9))
pred = Conv2D(num_classes, kernel_size=(1, 1))(conv9)
pred = PReLU()(pred)
pred = Reshape((num_classes, output_size[0] * output_size[1]))(pred)
pred = Permute((2, 1))(pred)
pred = Activation('softmax')(pred)
pred = Reshape(output_size + (num_classes, ))(pred)
model = Model(inputs=inputs, outputs=pred)
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['categorical_accuracy'])
return model
def generator_unet_upsampling(img_dim,
bn_mode,
model_name="generator_unet_upsampling"):
nb_filters = 64
if K.image_dim_ordering() == "th":
bn_axis = 1
nb_channels = img_dim[0]
min_s = min(img_dim[1:])
else:
bn_axis = -1
nb_channels = img_dim[-1]
min_s = min(img_dim[:-1])
unet_input = Input(shape=img_dim, name="unet_input")
# Prepare encoder filters
nb_conv = int(np.floor(np.log(min_s) / np.log(2)))
if VERBOSE: print(nb_conv, "number of convolutions")
list_nb_filters = [nb_filters * min(8, (2**i)) for i in range(nb_conv)]
# Encoder
xw_wid, yw_wid = _get_conv_size(unet_input)
list_encoder = [
Convolution2D(list_nb_filters[0],
xw_wid,
yw_wid,
subsample=(2, 2),
name="unet_conv2D_1",
border_mode="same")(unet_input)
]
for i, f in enumerate(list_nb_filters[1:]):
name = "unet_conv2D_%s" % (i + 2)
conv = conv_block_unet(list_encoder[-1], f, name, bn_mode, bn_axis)
list_encoder.append(conv)
# Prepare decoder filters
list_nb_filters = list_nb_filters[:-2][::-1]
if len(list_nb_filters) < nb_conv - 1:
list_nb_filters.append(nb_filters)
# Decoder
list_decoder = [
up_conv_block_unet(list_encoder[-1],
list_encoder[-2],
list_nb_filters[0],
"unet_upconv2D_1",
bn_mode,
bn_axis,
dropout=True)
]
for i, f in enumerate(list_nb_filters[1:]):
name = "unet_upconv2D_%s" % (i + 2)
# Dropout only on first few layers
if i < 2:
d = True
else:
d = False
conv = up_conv_block_unet(list_decoder[-1],
list_encoder[-(i + 3)],
f,
name,
bn_mode,
bn_axis,
dropout=d)
list_decoder.append(conv)
x = Activation("relu")(list_decoder[-1])
x = UpSampling2D(size=(2, 2))(x)
xw_wid, yw_wid = _get_conv_size(x)
x = Convolution2D(nb_channels,
xw_wid,
xw_wid,
name="last_conv",
border_mode="same")(x)
x = Activation("tanh")(x)
generator_unet = Model(input=[unet_input], output=[x])
return generator_unet
def deconv2d(layer_input):
"""Layers used during upsampling"""
u = UpSampling2D(size=2)(layer_input)
u = Conv2D(256, kernel_size=3, strides=1, padding='same')(u)
u = Activation('relu')(u)
return u
else:
print ("Building Model...")
model = Sequential()
model.add(Conv2D(48, (5, 5), padding='same', input_shape=x_train.shape[1:]))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(96, (5, 5), padding='same'))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(192, (5, 5), padding='same'))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(192, (5, 5), padding='same'))
model.add(Activation("relu"))
model.add(UpSampling2D(size=(2,2)))
model.add(Conv2D(192, (5, 5), padding='same'))
model.add(Activation("relu"))
model.add(UpSampling2D(size=(2,2)))
model.add(Conv2D(96, (5, 5), padding='same'))
model.add(Activation("relu"))
model.add(UpSampling2D(size=(2,2)))
model.add(Conv2D(48, (5, 5), padding='same'))
model.add(Activation("relu"))
model.add(Conv2D(3, (1, 1), padding='same'))
model.add(Activation("sigmoid"))
model.compile(optimizer=Adam(lr=lr), loss='mse')
plot_model(model, to_file='model.png', show_shapes=True)
###################################
if float(2 * np.sqrt(np.array(history.losses[-1]))) < 1.6:
lrate = 0.006
momentum = 0.4
decay_rate = 0.0
return lrate
else:
lrate = 0.01
return lrate
generator = Sequential()
generator.add(
Convolution2D(20, 3, 3, border_mode='valid', input_shape=input_shape))
generator.add(BatchNormalization(mode=2))
generator.add(Activation('relu'))
generator.add(UpSampling2D(size=(2, 2)))
generator.add(Convolution2D(20, 3, 3, init='glorot_uniform'))
generator.add(BatchNormalization(mode=2))
generator.add(Activation('relu'))
generator.add(Convolution2D(20, 3, 3, init='glorot_uniform'))
generator.add(BatchNormalization(mode=2))
generator.add(Activation('relu'))
generator.add(MaxPooling2D(pool_size=(3, 3)))
generator.add(Convolution2D(4, 3, 3, init='glorot_uniform'))
generator.add(BatchNormalization(mode=2))
generator.add(Activation('relu'))
generator.add(Reshape((28, 28, 1)))
generator.compile(loss='binary_crossentropy', optimizer='adam')
generator.summary()
############# DISCRIMINATOR
decay_rate = 5e-5
momentum = 0.9
sgd = SGD(lr=learning_rate, momentum=momentum, decay=decay_rate, nesterov=True)
shape2
recog0 = Sequential()
recog0.add(
Convolution2D(20, 4, 4, border_mode='valid', input_shape=input_shape))
recog0.add(BatchNormalization(mode=2))
recog0.add(MaxPooling2D(pool_size=(2, 2)))
recog = recog0
recog.add(Activation('relu'))
recog.add(MaxPooling2D(pool_size=(2, 2)))
recog.add(UpSampling2D(size=(2, 2)))
recog.add(Convolution2D(20, 1, 1, init='glorot_uniform'))
recog.add(BatchNormalization(mode=2))
recog.add(Activation('relu'))
for i in range(0, 8):
print(i, recog0.layers[i].name)
recog_res = recog0
part = 8
recog0.layers[part].name
get_0_layer_output = K.function(
[recog0.layers[0].input, K.learning_phase()], [recog0.layers[part].output])
get_0_layer_output([x_train, 0])[0][0]
graph.add_node(Convolution2D(64,
3,
3,
border_mode='same',
activation='linear',
init='glorot_uniform',
dim_ordering='tf'),
name='R41',
input='BNN1')
graph.add_node(Activation('relu'), name='AR41', input='R41')
graph.add_node(BatchNormalization(axis=-1), name='BNR41', input='AR41')
graph.add_node(Dropout(0.3), input='BNR41', name='RD3')
#################################################################
graph.add_node(UpSampling2D(size=(2, 2), dim_ordering='tf'),
name='RU3',
input='RD3')
##############################################################
graph.add_node(Convolution2D(64,
3,
3,
border_mode='same',
activation='linear',
init='glorot_uniform',
dim_ordering='tf'),
name='R32',
inputs=['RU3', 'LD3', 'ND2'])
graph.add_node(Activation('relu'), name='AR32', input='R32')
graph.add_node(BatchNormalization(axis=-1), name='BNR32', input='AR32')
def build_generator(self):
# noise = Input(shape=(self.latent_dim,))
# x = Reshape((1,1,self.latent_dim))(noise)
# x = Conv2DTranspose(self.latent_dim,4,use_bias=False)(x)
# x = BatchNormalization(momentum=0.8)(x)
# x = LeakyReLU(alpha=0.2)(x)
# x = self.conv_inception_block_down(x, [64]*4, [3]*4, 1)
# x = self.conv_inception_block_up(x, [64]*4, [3]*4, 2)
# x = self.conv_inception_block_down(x, [32]*4, [3]*4, 1)
# x = self.conv_inception_block_up(x, [32]*4, [3]*4, 2)
# x = self.conv_inception_block_down(x, [16]*4, [3]*4, 1)
# x = self.conv_inception_block_up(x, [16]*4, [3]*4, 2)
# x = Conv2D(self.channels,(3,3),padding='same')(x)
# img = Activation('linear')(x)
# model = Model(noise, img)
# model.summary()
# return Model(noise, img)
model = Sequential()
# model.add(Dense(128 * 4 * 4, activation="relu", input_dim=self.latent_dim))
model.add(Reshape((1, 1, self.latent_dim)))
model.add(Conv2DTranspose(128, kernel_size=4))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(Conv2D(128, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(UpSampling2D())
model.add(Conv2D(64, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(Conv2D(64, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(UpSampling2D())
model.add(Conv2D(32, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(Conv2D(32, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(UpSampling2D())
model.add(Conv2D(16, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(Conv2D(16, kernel_size=3, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(Activation("relu"))
model.add(Conv2D(self.channels, kernel_size=1, padding="same"))
model.add(Activation("linear"))
noise = Input(shape=(self.latent_dim, ))
img = model(noise)
model.summary()
return Model(noise, img)
x = Input(shape=(96, 96, 3)) # Encoder conv1_1 = Conv2D(64, (3, 3), activation='relu', padding='same')(x) pool1 = MaxPooling2D((2, 2), padding='same')(conv1_1) conv1_2 = Conv2D(32, (3, 3), activation='relu', padding='same')(pool1) pool2 = MaxPooling2D((2, 2), padding='same')(conv1_2) conv1_3 = Conv2D(32, (3, 3), activation='relu', padding='same')(pool2) pool3 = MaxPooling2D((2, 2), padding='same')(conv1_3) conv1_4 = Conv2D(16, (3, 3), activation='relu', padding='same')(pool3) h = MaxPooling2D((2, 2), padding='same')(conv1_4) # Decoder conv2_1 = Conv2D(16, (3, 3), activation='relu', padding='same')(h) up1 = UpSampling2D((2, 2))(conv2_1) conv2_2 = Conv2D(32, (3, 3), activation='relu', padding='same')(up1) up2 = UpSampling2D((2, 2))(conv2_2) conv2_3 = Conv2D(32, (3, 3), activation='relu', padding='same')(up2) up3 = UpSampling2D((2, 2))(conv2_3) conv2_4 = Conv2D(64, (3, 3), activation='relu', padding='same')(up3) up4 = UpSampling2D((2, 2))(conv2_4) r = Conv2D(3, (3, 3), activation='sigmoid', padding='same')(up4) autoencoder = Model(inputs=x, outputs=r) autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy') autoencoder.summary() # plot_model(autoencoder, to_file='model.png')
