def SkySeg(
input_shape=(256, 256, 3), regularization_factor=1e-4,
learning_rate=7e-4):
input_img = layers.Input(shape=input_shape,
dtype='float32',
name="input_img")
conv_1 = layers.Conv2D(16, 3, strides=(1, 1), name = "conv1",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(input_img)
conv_2 = layers.Conv2D(16, 3, strides=(1, 1), name = "conv2",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(conv_1)
pool_1 = layers.MaxPool2D()(conv_2)
conv_3 = layers.Conv2D(32, 3, strides=(1, 1), name = "conv3",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(pool_1)
conv_4 = layers.Conv2D(32, 3, strides=(1, 1), name = "conv4",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(conv_3)
pool_2 = layers.MaxPool2D()(conv_4)
conv_5 = layers.Conv2D(64, 3, strides=(1, 1), name = "conv5",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(pool_2)
conv_6 = layers.Conv2D(64, 3, strides=(1, 1), name = "conv6",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(conv_5)
pool_3 = layers.MaxPool2D()(conv_6)
conv_7 = layers.Conv2D(64, 3, strides=(1, 1), name = "conv7",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(pool_3)
conv_8 = layers.Conv2D(64, 3, strides=(1, 1), name = "conv8",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(conv_7)
pool_4 = layers.MaxPool2D()(conv_8)
conv_9 = layers.Conv2D(128, 3, strides=(1, 1), name = "conv9",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(pool_4)
conv_10 = layers.Conv2D(128, 3, strides=(1, 1), name = "conv10",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(conv_9)
pool_5 = layers.MaxPool2D()(conv_10)
flat = layers.Flatten()(pool_5)
fc_1 = layers.Dense(4 * 4 * 16,
activation='relu',
name="fc_encode",
kernel_initializer='glorot_uniform')(flat)
fc_2 = layers.Dense(8 * 8 * 128,
activation='relu',
name="fc_decode",
kernel_initializer='glorot_uniform')(fc_1)
rsp = layers.Reshape((8, 8, 128))(fc_2)
up_1 = layers.UpSampling2D()(rsp)
dcon_1 = layers.Conv2DTranspose(128, 3, strides = (1, 1), name = "dconv1",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(up_1)
dcon_2 = layers.Conv2DTranspose(128, 3, strides = (1, 1), name = "dconv2",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(dcon_1)
skip_1 = layers.Add()([conv_10, dcon_2])
up_2 = layers.UpSampling2D()(skip_1)
dcon_3 = layers.Conv2DTranspose(64, 3, strides = (1, 1), name = "dconv3",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(up_2)
dcon_4 = layers.Conv2DTranspose(64, 3, strides = (1, 1), name = "dconv4",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(dcon_3)
skip_2 = layers.Add()([conv_8, dcon_4])
up_3 = layers.UpSampling2D()(skip_2)
dcon_5 = layers.Conv2DTranspose(64, 3, strides = (1, 1), name = "dconv5",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(up_3)
dcon_6 = layers.Conv2DTranspose(64, 3, strides = (1, 1), name = "dconv6",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(dcon_5)
skip_3 = layers.Add()([conv_6, dcon_6])
up_4 = layers.UpSampling2D()(skip_3)
dcon_7 = layers.Conv2DTranspose(32, 3, strides = (1, 1), name = "dconv7",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(up_4)
dcon_8 = layers.Conv2DTranspose(32, 3, strides = (1, 1), name = "dconv8",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(dcon_7)
skip_4 = layers.Add()([conv_4, dcon_8])
up_5 = layers.UpSampling2D()(skip_4)
dcon_9 = layers.Conv2DTranspose(16, 3, strides = (1, 1), name = "dconv9",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(up_5)
dcon_10 = layers.Conv2DTranspose(16, 3, strides = (1, 1), name = "dconv10",\
padding='same', activation="relu", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(dcon_9)
skip_5 = layers.Add()([conv_2, dcon_10])
output = layers.Conv2D(2, 3, strides=(1, 1), name = "output",\
padding='same', activation="softmax", kernel_initializer='glorot_uniform', kernel_regularizer = keras.regularizers.l2(regularization_factor))(skip_5)
model = keras.Model(inputs=[input_img], outputs=output)
model.compile(optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
loss=keras.losses.sparse_categorical_crossentropy,
metrics=[IRBS])
return model
def UNet():
concat_axis = 3
inputss = Input((512, 512, 1))
print(inputss.shape)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='conv1_1')(inputss)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)
conv4 = Dropout(0.2)(conv4)
# pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
# conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)
# conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)
# up_conv5 = UpSampling2D(size=(2, 2))(conv5)
# ch, cw = get_crop_shape(conv4, up_conv5)
# crop_conv4 = layers.Cropping2D(cropping=(ch,cw))(conv4)
# up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
# conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(up6)
# conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv4)
ch, cw = get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch, cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(up7)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch, cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(up8)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch, cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(up9)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)
ch, cw = get_crop_shape(inputss, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0], cw[1])))(conv9)
conv10 = layers.Conv2D(1, (1, 1))(conv9)
print(conv10.shape)
# conv1 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(inputss)
# print(conv1.shape)
# conv1 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv1)
# print(conv1.shape)
# pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
# print(pool1.shape)
# print('\n')
#
# conv2 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool1)
# print(conv2.shape)
# conv2 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv2)
# print(conv2.shape)
# pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
# print(pool2.shape)
# print('\n')
#
# conv3 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool2)
# print(conv3.shape)
# conv3 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv3)
# print(conv3.shape)
# pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
# print(pool3.shape)
# print('\n')
#
# conv4 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool3)
# print(conv4.shape)
# conv4 = Conv2D(256, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv4)
# print(conv4.shape)
# drop4 = Dropout(0.5)(conv4)
# pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
# print(pool4.shape)
# print('\n')
# #
# # conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(pool4)
# # print(conv5.shape)
# # conv5 = Conv2D(1024, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv5)
# # print(conv5.shape)
# # drop5 = Dropout(0.5)(conv5)
# # print('\n')
# #
# # up6 = Conv2D(512, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# # UpSampling2D(size=(2, 2))(drop5))
# # print(up6.shape)
# # print(drop4.shape)
# # merge6 = merge([drop4, up6], mode='concat', concat_axis=3)
# # print('merge: ')
# # print(merge6.shape)
# # 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(128, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# UpSampling2D(size=(2, 2))(conv4))
# merge7 = merge([conv3, up7], mode='concat', concat_axis=3)
# conv7 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge7)
# conv7 = Conv2D(128, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv7)
#
# up8 = Conv2D(64, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# UpSampling2D(size=(2, 2))(conv7))
# merge8 = concatenate([conv2, up8], axis=3)
# conv8 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge8)
# conv8 = Conv2D(64, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv8)
#
# up9 = Conv2D(32, 2, activation='relu', padding='same', kernel_initializer='he_normal')(
# UpSampling2D(size=(2, 2))(conv8))
# merge9 = concatenate([conv1, up9], axis=3)
# conv9 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(merge9)
# conv9 = Conv2D(32, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9)
# conv9 = Conv2D(2, 3, activation='relu', padding='same', kernel_initializer='he_normal')(conv9)
# # conv10 = Conv2D(1, 1, activation='sigmoid')(conv9)
# conv10 = Softmax()(conv9)
print("llllllllllllllllllllllllast")
Outmodel = Model(inputs=inputss, outputs=conv10)
Outmodel.summary()
print(conv10.shape)
return Outmodel
def Model_PSP(pre_trained_model, num_classes=35):
last_pretrained_layer = pre_trained_model.get_layer('conv3_block4_out')
last_output = last_pretrained_layer.output
last_output = layers.Conv2D(filters=128,
kernel_size=(1, 1),
name='Compress_out')(last_output)
#Define the params for the pooling module
#This has to be 1/4 times the input channel depth
INPUT_CHANNEL_DEPTH = 128
INPUT_DIM = 32
TARGET_CHANNEL_DEPTH = INPUT_CHANNEL_DEPTH / 4
Y_KERNEL_DIM = (INPUT_DIM // 2, INPUT_DIM // 2)
B_KERNEL_DIM = (INPUT_DIM // 4, INPUT_DIM // 4)
G_KERNEL_DIM = (INPUT_DIM // 8, INPUT_DIM // 8)
#Now we define the pyramidal pooling architecture
base = last_output
#Define the GAP with 1*1 block size for 1x1 bin
red_blk = layers.GlobalAvgPool2D(name='red_block_pooling')(base)
red_blk = layers.Reshape((1, 1, INPUT_CHANNEL_DEPTH))(red_blk)
red_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='red_1x1_conv')(red_blk)
red_blk = layers.UpSampling2D(size=(256, 256),
interpolation='bilinear',
name='red_upsample')(red_blk)
#Define the average pooling for the yellow block for 2x2 bin
y_blk = layers.AvgPool2D(pool_size=Y_KERNEL_DIM,
name='yellow_blk_pooling')(base)
y_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='yellow_1x1_conv')(y_blk)
y_blk = layers.UpSampling2D(size=(128, 128),
interpolation='bilinear',
name='yellow_upsample')(y_blk)
#Define the average pooling for the blue block for 4x4 bin
blue_blk = layers.AvgPool2D(pool_size=B_KERNEL_DIM,
name='blue_blk_pooling')(base)
blue_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='blue_1x1_conv')(blue_blk)
blue_blk = layers.UpSampling2D(size=(64, 64),
interpolation='bilinear',
name='blue_upsample')(blue_blk)
#Define the average pooling for the green block for 8x8 bins
green_blk = layers.AvgPool2D(pool_size=G_KERNEL_DIM,
name='green_blk_pooling')(base)
green_blk = layers.Conv2D(filters=TARGET_CHANNEL_DEPTH,
kernel_size=(1, 1),
name='green_1x1_conv')(green_blk)
green_blk = layers.UpSampling2D(size=(32, 32),
interpolation='bilinear',
name='green_upsample')(green_blk)
#Now we upsample the base and check all output shapes to ensure that they match
base = layers.UpSampling2D(size=(256 // INPUT_DIM, 256 // INPUT_DIM),
interpolation='bilinear',
name='base_upsample')(base)
print(base.get_shape)
print(red_blk.get_shape)
print(y_blk.get_shape)
print(blue_blk.get_shape)
print(green_blk.get_shape)
#Generate the final output and check shape
PPM = tf.keras.layers.concatenate(
[base, green_blk, blue_blk, y_blk, red_blk])
print(PPM.get_shape)
#Now we define the final convolutional block
output = layers.Conv2D(filters=num_classes,
kernel_size=(3, 3),
padding='same',
name='final_3x3_conv_blk',
activation='softmax')(PPM)
return output
def get_skip_generator(latent_dim=64,
channels=64,
target_size=64,
latent_style_layers=2):
num_upsamples = int(math.log2(target_size) - 2)
side_length = 4
# Learnable constant image
dummy_in = layers.Input(shape=(1, ), name="dummy_in")
x = layers.Dense(side_length * side_length * channels,
name="const_img",
kernel_initializer="zeros",
bias_initializer="random_normal")(dummy_in)
x = layers.Reshape((side_length, side_length, channels))(x)
# RGB output
y = layers.Conv2D(filters=3,
kernel_size=(3, 3),
kernel_initializer="random_normal",
bias_initializer="zeros",
activation="tanh",
padding="same")(x)
# Latent input
latent_in = layers.Input(shape=(latent_dim, ), name="latent_in")
noise_inputs = []
for i in range(num_upsamples):
# Style block without upsampling
noise_in = layers.Input(shape=(side_length, side_length, 1),
name=f"noise_in_{side_length}x{side_length}")
noise_inputs.append(noise_in)
x = style_block(x,
latent_in,
noise_in,
channels=channels,
latent_style_layers=latent_style_layers,
upsample=False,
name=f"{side_length}x{side_length}")
# Style block with upsampling
side_length = 2 * side_length
noise_in = layers.Input(
shape=(side_length, side_length, 1),
name=f"noise_in_upsample_{side_length}x{side_length}")
noise_inputs.append(noise_in)
x = style_block(x,
latent_in,
noise_in,
channels=channels,
latent_style_layers=latent_style_layers,
upsample=True,
name=f"upsample_{side_length}x{side_length}")
# Convert deep image to RGB
z = layers.Conv2D(filters=3,
kernel_size=(3, 3),
kernel_initializer="random_normal",
bias_initializer="zeros",
activation="tanh",
padding="same",
name=f"to_rgb_{side_length}x{side_length}")(x)
# Add deep RGB to upsampled current RGB
y = layers.UpSampling2D(
size=(2, 2),
interpolation="bilinear",
name=f"rgb_upsampling_{side_length}x{side_length}")(y)
y = layers.Add(name=f"add_deep_rgb_{side_length}x{side_length}")(
[y, z])
generator = tf.keras.Model(inputs=[dummy_in, latent_in] + noise_inputs,
outputs=y,
name="generator")
return generator
def __init__(self, img_shape, num_class, d=32, weights=weights_url):
concat_axis = 3
inputs = layers.Input(shape=img_shape)
conv1 = layers.Conv2D(d, (3, 3),
activation='relu',
padding='same',
name='conv1_1')(inputs)
conv1 = layers.Conv2D(d, (3, 3), activation='relu',
padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(pool1)
conv2 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(pool2)
conv3 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(pool3)
conv4 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)
conv5 = layers.Conv2D(d * 16, (3, 3),
activation='relu',
padding='same')(pool4)
conv5 = layers.Conv2D(d * 16, (3, 3),
activation='relu',
padding='same')(conv5)
up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5)
ch, cw = self.get_crop_shape(conv4, up_conv5)
crop_conv4 = layers.Cropping2D(cropping=(ch, cw))(conv4)
up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(up6)
conv6 = layers.Conv2D(d * 8, (3, 3), activation='relu',
padding='same')(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6)
ch, cw = self.get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch, cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(up7)
conv7 = layers.Conv2D(d * 4, (3, 3), activation='relu',
padding='same')(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = self.get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch, cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(up8)
conv8 = layers.Conv2D(d * 2, (3, 3), activation='relu',
padding='same')(conv8)
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = self.get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch, cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(d, (3, 3), activation='relu',
padding='same')(up9)
conv9 = layers.Conv2D(d, (3, 3), activation='relu',
padding='same')(conv9)
ch, cw = self.get_crop_shape(inputs, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0],
cw[1])))(conv9)
conv10 = layers.Conv2D(num_class, (1, 1), activation="sigmoid")(conv9)
super().__init__(inputs=inputs, outputs=conv10)
if weights is not None:
self.load_weight_file(weights)
def __init__(self,
num_channels,
use_2d=True,
kernel_size=2,
activation='relu',
use_attention=False,
use_batchnorm=False,
use_transpose=False,
use_bias=True,
strides=2,
data_format='channels_last',
name="upsampling_conv_block",
**kwargs):
super(Up_Conv, self).__init__(name=name)
self.data_format = data_format
self.use_attention = use_attention
if use_transpose:
if use_2d:
self.upconv_layer = tfkl.Conv2DTranspose(
num_channels,
kernel_size,
padding='same',
strides=strides,
data_format=self.data_format)
else:
self.upconv_layer = tfkl.Conv3DTranspose(
num_channels,
kernel_size,
padding='same',
strides=strides,
data_format=self.data_format)
else:
if use_2d:
self.upconv_layer = tfkl.UpSampling2D(size=strides)
else:
self.upconv_layer = tfkl.UpSampling3D(size=strides)
if self.use_attention:
self.attention = Attention_Gate(num_channels=num_channels,
use_2d=use_2d,
kernel_size=1,
activation=activation,
padding='same',
strides=strides,
use_bias=use_bias,
data_format=self.data_format)
self.conv = Conv_Block(num_channels=num_channels,
use_2d=use_2d,
num_conv_layers=1,
kernel_size=kernel_size,
activation=activation,
use_batchnorm=use_batchnorm,
use_dropout=False,
data_format=self.data_format)
self.conv_block = Conv_Block(num_channels=num_channels,
use_2d=use_2d,
num_conv_layers=2,
kernel_size=3,
activation=activation,
use_batchnorm=use_batchnorm,
use_dropout=False,
data_format=self.data_format)
def build_mv2_hourglass_model(number_of_keypoints):
hourglas_stage_num = 4
input_shape = (192, 192, 3) # h, w, c
input = layers.Input(shape=input_shape)
## HEADER
# cnn with regularizer
x = layers.Conv2D(filters=16,
kernel_size=(3, 3),
strides=(2, 2),
padding='SAME',
kernel_regularizer=l2_regularizer_00004)(input)
# batch norm
x = layers.BatchNormalization(momentum=0.999)(x)
# activation
x = layers.ReLU(max_value=6)(x)
# 128, 112
x = _inverted_bottleneck(x,
up_channel_rate=1,
channels=16,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=1,
channels=16,
is_subsample=False,
kernel_size=3)
# 64, 56
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=True,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
captured_h, captured_w = int(x.shape[1]), int(x.shape[2])
print(f"captured_h, captured_w: {captured_h}, {captured_w}")
# HOURGLASS recursively
# stage = 4
#
x, middle_output_layers = _hourglass_module(
x,
stage_index=hourglas_stage_num,
number_of_keypoints=number_of_keypoints)
print("before")
for l in middle_output_layers:
print(f" l.shape: {l.shape}")
for layer_index, middle_layer in enumerate(middle_output_layers):
layer_stage = layer_index + 1
h, w = middle_layer.shape[1], middle_layer.shape[2]
if h == captured_h and w == captured_w:
continue
else:
upsampling_size = (captured_h // h, captured_w // w)
middle_output_layers[layer_index] = layers.UpSampling2D(
size=upsampling_size, interpolation='bilinear')(middle_layer)
print("after")
for l in middle_output_layers:
print(f" l.shape: {l.shape}")
model = models.Model(input, outputs=middle_output_layers)
return model
def UpSampling(x, nfilter):
# Maybe should test bilinear
x = KL.UpSampling2D(interpolation="nearest")(x)
x = KL.Conv2D(nfilter, (1, 1))(x)
x = KL.BatchNormalization()(x)
return x
def build_BiFPN(features, num_channels, id, freeze_bn=False):
if id == 0:
_, _, C3, C4, C5 = features
P3_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P3'.format(id))(
C3)
P4_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P4'.format(id))(
C4)
P5_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P5'.format(id))(
C5)
P6_in = ConvBlock(num_channels, kernel_size=3, strides=2, freeze_bn=freeze_bn, name='BiFPN_{}_P6'.format(id))(
C5)
P7_in = ConvBlock(num_channels, kernel_size=3, strides=2, freeze_bn=freeze_bn, name='BiFPN_{}_P7'.format(id))(
P6_in)
else:
P3_in, P4_in, P5_in, P6_in, P7_in = features
P3_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P3'.format(id))(
P3_in)
P4_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P4'.format(id))(
P4_in)
P5_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P5'.format(id))(
P5_in)
P6_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P6'.format(id))(
P6_in)
P7_in = ConvBlock(num_channels, kernel_size=1, strides=1, freeze_bn=freeze_bn, name='BiFPN_{}_P7'.format(id))(
P7_in)
# upsample
P7_U = layers.UpSampling2D()(P7_in)
P6_td = layers.Add()([P7_U, P6_in])
P6_td = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_U_P6'.format(id))(P6_td)
P6_U = layers.UpSampling2D()(P6_td)
P5_td = layers.Add()([P6_U, P5_in])
P5_td = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_U_P5'.format(id))(P5_td)
P5_U = layers.UpSampling2D()(P5_td)
P4_td = layers.Add()([P5_U, P4_in])
P4_td = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_U_P4'.format(id))(P4_td)
P4_U = layers.UpSampling2D()(P4_td)
P3_out = layers.Add()([P4_U, P3_in])
P3_out = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_U_P3'.format(id))(P3_out)
# downsample
P3_D = layers.MaxPooling2D(strides=(2, 2))(P3_out)
P4_out = layers.Add()([P3_D, P4_td, P4_in])
P4_out = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_D_P4'.format(id))(P4_out)
P4_D = layers.MaxPooling2D(strides=(2, 2))(P4_out)
P5_out = layers.Add()([P4_D, P5_td, P5_in])
P5_out = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_D_P5'.format(id))(P5_out)
P5_D = layers.MaxPooling2D(strides=(2, 2))(P5_out)
P6_out = layers.Add()([P5_D, P6_td, P6_in])
P6_out = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_D_P6'.format(id))(P6_out)
P6_D = layers.MaxPooling2D(strides=(2, 2))(P6_out)
P7_out = layers.Add()([P6_D, P7_in])
P7_out = DepthwiseSeparableConvBlock(num_channels, kernel_size=3, strides=1, freeze_bn=freeze_bn,
name='BiFPN_{}_D_P7'.format(id))(P7_out)
return P3_out, P4_out, P5_out, P6_out, P7_out
def cnn_custom_unet(inputs,
filters=16,
num_layers=4,
activation='relu',
use_batch_norm=True,
use_bias=None,
upsample_mode='deconv',
dropout=0.3,
dropout_change_per_layer=0,
dropout_type='spatial',
use_dropout_on_upsampling=False):
# array to hold outputs of blocks
# in the contracting path
# for later use
# in the expanding path
down_blocks = []
# build the contracting path
# Create the downsampling layers
net = inputs
for i in range(num_layers):
name = f'contract_{i+1}'
net = unet_conv_block(inputs=net,
filters=filters,
padding='same',
activation=activation,
use_batch_norm=use_batch_norm,
use_bias=use_bias,
dropout=dropout,
dropout_type=dropout_type,
name=name)
# save this layer for later reference
down_blocks.append(net)
# add pooling
net = layers.MaxPooling2D((2, 2), strides=2, name=f'{name}_pool')(net)
# increase the number of filters
filters = filters * 2
# increase dropout if required
dropout = dropout + dropout_change_per_layer
# build the lateral path
net = unet_conv_block(inputs=net,
filters=filters,
padding='same',
activation=activation,
use_batch_norm=use_batch_norm,
use_bias=use_bias,
dropout=dropout,
dropout_type=dropout_type,
name='lateral')
if not use_dropout_on_upsampling:
# disable dropout for expansion part of network
dropout = 0
dropout_change_per_layer = 0
# build the expanding path
i = num_layers
for conv in reversed(down_blocks):
# decrease the number of filters
filters = filters // 2
name = f'expand_{i}'
# decrease dropout if required
dropout -= dropout_change_per_layer
# upsample
if upsample_mode == 'deconv':
net = layers.Conv2DTranspose(filters, (2, 2),
strides=(2, 2),
padding='same',
name=f'{name}_upconv')(net)
else:
net = layers.UpSampling2D(strides=(2, 2),
name=f'{name}_upconv')(net)
# cropping is not needed due to same padding
# TODO attention concatenation
# concatenate
net = layers.concatenate([net, conv], name=f'{name}_concatenate')
# add one more convolutional block
net = unet_conv_block(inputs=net,
filters=filters,
padding='same',
activation=activation,
use_batch_norm=use_batch_norm,
use_bias=use_bias,
dropout=dropout,
dropout_type=dropout_type,
name=name)
i = i - 1
# we are done
return net
def generator_model():
start_imagesize = 128
imagesize = 128
nodes = 64
max_nodes = 512
max_count = 0
stride = 2
bn_layer_list = []
keep = True
input_layer = Input(shape = (imagesize, imagesize, 3))
con2d_layer = layers.Conv2D(nodes, 3, stride, padding = 'same')(input_layer)
hidden_layer = layers.PReLU()(con2d_layer)
bn_layer_list.append(layers.BatchNormalization()(hidden_layer))
imagesize = math.ceil(imagesize / stride)
while keep:
if nodes < max_nodes:
nodes *= 2
else:
max_count += 1
con2d_layer = layers.Conv2D(nodes, 3, stride,padding = 'same')(bn_layer_list[-1])
hidden_layer = layers.PReLU()(con2d_layer)
bn_layer_list.append(layers.BatchNormalization()(hidden_layer))
imagesize = math.ceil(imagesize / stride)
if imagesize == 1:
keep = False
keep = True
while keep:
if imagesize != 1:
input_data = layers.concatenate([bn_layer, bn_layer_list.pop()])
else:
input_data = bn_layer_list.pop()
upsample_layer = layers.UpSampling2D((4,4))(input_data)
con2d_layer = layers.Conv2D(nodes, 3, stride,padding = 'same')(upsample_layer)
hidden_layer = layers.PReLU()(con2d_layer)
bn_layer = layers.BatchNormalization()(hidden_layer)
imagesize = math.ceil(imagesize * stride)
if max_count != 1:
max_count -= 1
else:
nodes /= 2
if imagesize == (start_imagesize / 2):
keep = False
upsample_layer = layers.UpSampling2D((4,4))(bn_layer)
output_layer = layers.Conv2D(3, 3, stride,padding = 'same', activation = 'tanh')(upsample_layer)
#output_layer = layers.Conv2DTranspose(3, 3, stride,padding = 'same', activation = 'tanh')(bn_layer)
#con2d_layer = layers.Conv2D(64, 3, padding = 'same', activation = 'relu')(bn_layer_1)
#bn_layer_2 = layers.BatchNormalization()(con2d_layer)
#add_layer_1 = layers.add([bn_layer_1, bn_layer_2])
#con2d_layer = layers.Conv2D(64, 3, padding = 'same', activation = 'relu')(add_layer_1)
#bn_layer_3 = layers.BatchNormalization()(con2d_layer)
#add_layer_2 = layers.add([add_layer_1, bn_layer_3])
#con2d_layer = layers.Conv2D(64, 3, padding = 'same', activation = 'relu')(add_layer_2)
#bn_layer_4 = layers.BatchNormalization()(con2d_layer)
#add_layer_3 = layers.add([add_layer_2, bn_layer_4])
#con2d_layer = layers.Conv2D(3, 3, padding = 'same', activation = 'tanh')(add_layer_3)
#output_layer = layers.maximum([input_layer, con2d_layer])
return Model(input_layer, output_layer)
def upsample_simple(filters, kernel_size, strides, padding):
return layers.UpSampling2D(strides)
c9 = layers.Conv2D(8, (3, 3),
kernel_initializer='he_uniform',
bias_initializer='zeros',
activation='relu',
padding='same')(u9)
c9 = layers.Conv2D(8, (3, 3),
kernel_initializer='he_uniform',
bias_initializer='zeros',
activation='relu',
padding='same')(c9)
d = layers.Conv2D(1, (1, 1), activation='sigmoid')(c9)
d = layers.Cropping2D((EDGE_CROP, EDGE_CROP))(d)
d = layers.ZeroPadding2D((EDGE_CROP, EDGE_CROP))(d)
if NET_SCALING is not None:
d = layers.UpSampling2D(NET_SCALING)(d)
seg_model = models.Model(inputs=[input_img], outputs=[d])
print()
#print()
#print(seg_model.summary())
print()
## evalaution criteria
# dice coefficicent
def dice_coef(y_true, y_pred, smooth=1):
intersection = K.sum(y_true * y_pred, axis=[1, 2, 3])
union = K.sum(y_true, axis=[1, 2, 3]) + K.sum(y_pred, axis=[1, 2, 3])
return K.mean((2. * intersection + smooth) / (union + smooth), axis=0)
def _build_generator(self):
embedding = layers.Input(shape=(self.embedding_dim, ))
x = layers.Dense(256)(embedding)
mean_logsigma = layers.LeakyReLU(0.2)(x)
c = layers.Lambda(generate_c)(mean_logsigma)
z_noise = layers.Input(shape=(100, ))
gen_input = layers.Concatenate(axis=1)([c, z_noise])
x = layers.Dense(128 * 8 * 4 * 4, use_bias=False)(gen_input)
x = layers.Reshape((4, 4, 128 * 8), input_shape=(128 * 8 * 4 * 4, ))(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# x = layers.Conv2DTranspose(512, kernel_size=4, strides=2, padding='same', use_bias=False)(x)
x = layers.UpSampling2D(size=(2, 2))(x)
x = layers.Conv2D(512,
kernel_size=3,
padding='same',
strides=1,
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# x = layers.Conv2DTranspose(256, kernel_size=4, strides=2, padding='same', use_bias=False)(x)
x = layers.UpSampling2D(size=(2, 2))(x)
x = layers.Conv2D(256,
kernel_size=3,
padding='same',
strides=1,
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# x = layers.Conv2DTranspose(128, kernel_size=4, strides=2, padding='same', use_bias=False)(x)
x = layers.UpSampling2D(size=(2, 2))(x)
x = layers.Conv2D(128,
kernel_size=3,
padding='same',
strides=1,
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# x = layers.Conv2DTranspose(64, kernel_size=3, strides=2, padding='same', use_bias=False)(x)
x = layers.UpSampling2D(size=(2, 2))(x)
x = layers.Conv2D(64,
kernel_size=3,
padding='same',
strides=1,
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.ReLU()(x)
# x = layers.Conv2DTranspose(3, kernel_size=4, strides=2, padding='same', use_bias=False)(x)
x = layers.Conv2D(3,
kernel_size=1,
padding='same',
strides=1,
use_bias=False)(x)
x = layers.Activation(activation='tanh')(x)
self.generator = Model(inputs=[embedding, z_noise],
outputs=[x, mean_logsigma])
x0 = fun.Inception(x, 64, name='x0')(x)
x1 = L.MaxPool2D(pool_size=(SIZE_SUB, SIZE_SUB),
strides=(SIZE_SUB, SIZE_SUB),
padding='valid')(x0)
x1 = fun.Inception(x1, 128, name='x1')(x1)
x2 = L.MaxPool2D(pool_size=(SIZE_TOP, SIZE_TOP),
strides=(SIZE_TOP, SIZE_TOP),
padding='valid')(x1)
xg = x2
xg = L.Dense(256, activation='relu', name='x2')(xg)
y2 = xg
y1 = L.UpSampling2D(size=(SIZE_TOP, SIZE_TOP))(y2)
y1 = L.Concatenate()([x1, y1])
y1 = fun.Inception(y1, 128, name='y1')(y1)
y0 = L.UpSampling2D(size=(SIZE_SUB, SIZE_SUB))(y1)
y0 = L.Concatenate()([x0, y0])
y0 = fun.Inception(y0, 64, name='y0')(y0)
y = L.Dense(50, activation='softmax')(y0)
ouputs = y
ouputs = L.Multiply()([ouputs, mask1])
not_mask = L.Lambda(lambda x: 1 - x)(mask)
ouputs = L.Concatenate(name="segment_out")([ouputs, not_mask])
model = keras.Model(inputs=inputs1, outputs=[ouputs])
def __init__(self,
color=False,
burst_length=8,
blind_est=False,
sep_conv=False,
kernel_size=[5],
channel_att=False,
spatial_att=False,
core_bias=False,
use_bias=True):
# 注意，输入参数 kerel_size是跟kernel prediction networks一样的filter size
# 注意，如果是blind_est，则输入端不加入noise 的先验知识，否则要将一个input channel留给noise
# 注意，burst_length是时间序列，如video放映那种
super(KPN, self).__init__()
self.burst_length = burst_length
self.core_bias = core_bias
self.use_bias = use_bias
self.color_channel = 3 if color else 1
out_channel = (3 if color else
1) * (2 * sum(kernel_size) if sep_conv else np.sum(
np.array(kernel_size)**2)) * burst_length
if core_bias:
out_channel += (3 if color else 1) * burst_length
# encoder，注意，maxpool和upsampling是没有模型参数的，也可以直接写在__call__里面当函数调用
self.conv1 = Basic(64,
channel_att=False,
spatial_att=False,
use_bias=self.use_bias)
self.avgpool1 = layers.AveragePooling2D(pool_size=(2, 2))
self.conv2 = Basic(128,
channel_att=False,
spatial_att=False,
use_bias=self.use_bias)
self.avgpool2 = layers.AveragePooling2D(pool_size=(2, 2))
self.conv3 = Basic(256,
channel_att=False,
spatial_att=False,
use_bias=self.use_bias)
self.avgpool3 = layers.AveragePooling2D(pool_size=(2, 2))
self.conv4 = Basic(256,
channel_att=False,
spatial_att=False,
use_bias=self.use_bias)
# decoder
self.up4 = layers.UpSampling2D(size=(2, 2), interpolation='bilinear')
self.conv5 = Basic(256,
channel_att=channel_att,
spatial_att=spatial_att,
use_bias=self.use_bias)
self.up5 = layers.UpSampling2D(size=(2, 2), interpolation='bilinear')
self.conv6 = Basic(128,
channel_att=channel_att,
spatial_att=spatial_att,
use_bias=self.use_bias)
self.up6 = layers.UpSampling2D(size=(2, 2), interpolation='bilinear')
self.conv7 = Basic(64,
channel_att=channel_att,
spatial_att=spatial_att,
use_bias=self.use_bias)
self.outc = Basic(out_channel,
channel_att=channel_att,
spatial_att=spatial_att,
use_bias=self.use_bias)
self.kernel_pred = KernelConv(kernel_size, sep_conv, self.core_bias)
in_resized[i] * 255, o * 255,
out_sample_images[i] * 255
],
axis=1)) for i, o in enumerate(preds)
]
},
commit=False)
model = Sequential()
model.add(
layers.Conv2D(3, (3, 3),
activation='relu',
padding='same',
input_shape=(config.input_width, config.input_height, 3)))
model.add(layers.UpSampling2D())
model.add(layers.Conv2D(3, (3, 3), activation='relu', padding='same'))
model.add(layers.UpSampling2D())
model.add(layers.Conv2D(3, (3, 3), activation='relu', padding='same'))
model.add(layers.UpSampling2D())
model.add(layers.Conv2D(3, (3, 3), activation='relu', padding='same'))
# DONT ALTER metrics=[perceptual_distance]
model.compile(optimizer='adam', loss='mse', metrics=[perceptual_distance])
model.fit_generator(image_generator(config.batch_size, train_dir),
steps_per_epoch=config.steps_per_epoch,
epochs=config.num_epochs,
callbacks=[ImageLogger(), WandbCallback()],
validation_steps=config.val_steps_per_epoch,
validation_data=val_generator)
# but also reusing its weights encoder_input = keras.Input(shape=(28, 28, 1), name='original_img') x = layers.Conv2D(16, 3, activation='relu')(encoder_input) x = layers.Conv2D(32, 3, activation='relu')(x) x = layers.MaxPooling2D(3)(x) x = layers.Conv2D(32, 3, activation='relu')(x) x = layers.Conv2D(16, 3, activation='relu')(x) encoder_output = layers.GlobalMaxPooling2D()(x) encoder = keras.Model(encoder_input, encoder_output, name='encoder') encoder.summary() decoder_input = keras.Input(shape=(16,), name='encoded_img') x = layers.Reshape((4, 4, 1))(decoder_input) x = layers.Conv2DTranspose(16, 3, activation='relu')(x) x = layers.Conv2DTranspose(32, 3, activation='relu')(x) x = layers.UpSampling2D(3)(x) x = layers.Conv2DTranspose(16, 3, activation='relu')(x) decoder_output = layers.Conv2DTranspose(1, 3, activation='relu')(x) decoder = keras.Model(decoder_input, decoder_output, name='decoder') decoder.summary() autoencoder_input = keras.Input(shape=(28, 28, 1), name='img') encoded_img = encoder(autoencoder_input) decoded_img = decoder(encoded_img) autoencoder = keras.Model(autoencoder_input, decoded_img, name='autoencoder') autoencoder.summary()
def call(self, x):
size = x.size()[2:]
pool = self.gap(x)
out = layers.UpSampling2D(size, interpolation='bilinear')(pool)
return out
def __init__(self, n_input_channels, n_output_channels, n_filters):
inputs = layers.Input((None, None, n_input_channels))
conv1 = layers.Conv2D(n_filters,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(inputs)
conv1 = layers.BatchNormalization()(conv1)
conv1 = layers.Conv2D(n_filters,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv1)
conv1 = layers.BatchNormalization()(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(n_filters * 2,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(pool1)
conv2 = layers.BatchNormalization()(conv2)
conv2 = layers.Conv2D(n_filters * 2,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv2)
conv2 = layers.BatchNormalization()(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(n_filters * 4,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(pool2)
conv3 = layers.BatchNormalization()(conv3)
conv3 = layers.Conv2D(n_filters * 4,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv3)
conv3 = layers.BatchNormalization()(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(n_filters * 8,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(pool3)
conv4 = layers.BatchNormalization()(conv4)
conv4 = layers.Conv2D(n_filters * 8,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv4)
conv4 = layers.BatchNormalization()(conv4)
drop4 = layers.Dropout(0.5)(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = layers.Conv2D(n_filters * 16,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(pool4)
conv5 = layers.BatchNormalization()(conv5)
conv5 = layers.Conv2D(n_filters * 16,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv5)
conv5 = layers.BatchNormalization()(conv5)
drop5 = layers.Dropout(0.5)(conv5)
up6 = layers.Conv2D(n_filters * 8,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(
layers.UpSampling2D(size=(2, 2))(drop5))
merge6 = layers.Concatenate(axis=-1)([conv4, up6])
conv6 = layers.Conv2D(n_filters * 8,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(merge6)
conv6 = layers.BatchNormalization()(conv6)
conv6 = layers.Conv2D(n_filters * 8,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv6)
conv6 = layers.BatchNormalization()(conv6)
up7 = layers.Conv2D(n_filters * 4,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(
layers.UpSampling2D(size=(2, 2))(conv6))
merge7 = layers.Concatenate(axis=-1)([conv3, up7])
conv7 = layers.Conv2D(n_filters * 4,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(merge7)
conv7 = layers.BatchNormalization()(conv7)
conv7 = layers.Conv2D(n_filters * 4,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv7)
conv7 = layers.BatchNormalization()(conv7)
up8 = layers.Conv2D(n_filters * 2,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(
layers.UpSampling2D(size=(2, 2))(conv7))
merge8 = layers.Concatenate(axis=-1)([conv2, up8])
conv8 = layers.Conv2D(n_filters * 2,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(merge8)
conv8 = layers.BatchNormalization()(conv8)
conv8 = layers.Conv2D(n_filters * 2,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv8)
conv8 = layers.BatchNormalization()(conv8)
up9 = layers.Conv2D(n_filters,
2,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(
layers.UpSampling2D(size=(2, 2))(conv8))
merge9 = layers.Concatenate(axis=-1)([conv1, up9])
conv9 = layers.Conv2D(n_filters,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(merge9)
conv9 = layers.BatchNormalization()(conv9)
conv9 = layers.Conv2D(n_filters,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv9)
conv9 = layers.BatchNormalization()(conv9)
conv9 = layers.Conv2D(2,
3,
activation='relu',
padding='same',
kernel_initializer=GlorotNormal())(conv9)
conv9 = layers.BatchNormalization()(conv9)
conv10 = layers.Conv2D(n_output_channels, 1,
activation='softmax')(conv9)
self.model = tf.keras.Model(inputs=inputs, outputs=conv10)
def _hourglass_module(input, stage_index, number_of_keypoints):
if stage_index == 0:
return _inverted_bottleneck(input,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3), []
else:
# down sample
x = layers.MaxPool2D(pool_size=(2, 2), strides=(2, 2),
padding='SAME')(input)
# block front
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
stage_index -= 1
# block middle
x, middle_layers = _hourglass_module(
x,
stage_index=stage_index,
number_of_keypoints=number_of_keypoints)
# block back
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=number_of_keypoints,
is_subsample=False,
kernel_size=3)
# up sample
upsampling_size = (2, 2) # (x.shape[1] * 2, x.shape[2] * 2)
x = layers.UpSampling2D(size=upsampling_size,
interpolation='bilinear')(x)
upsampling_layer = x
# jump layer
x = _inverted_bottleneck(input,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=24,
is_subsample=False,
kernel_size=3)
x = _inverted_bottleneck(x,
up_channel_rate=6,
channels=number_of_keypoints,
is_subsample=False,
kernel_size=3)
jump_branch_layer = x
# add
x = upsampling_layer + jump_branch_layer
middle_layers.append(x)
return x, middle_layers
def UNet(input_size=(224, 224, 3), num_classes=1):
inputs = layers.Input(input_size)
conv1 = layers.Conv2D(64,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(inputs)
conv1 = layers.Conv2D(64,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = layers.Conv2D(128,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(pool1)
conv2 = layers.Conv2D(128,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = layers.Conv2D(256,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(pool2)
conv3 = layers.Conv2D(256,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = layers.Conv2D(512,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(pool3)
conv4 = layers.Conv2D(512,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv4)
drop4 = layers.Dropout(0.5)(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = layers.Conv2D(1024,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(pool4)
conv5 = layers.Conv2D(1024,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv5)
drop5 = layers.Dropout(0.5)(conv5)
up6 = layers.Conv2D(512,
2,
activation="relu",
padding="same",
kernel_initializer="he_normal")(
layers.UpSampling2D(size=(2, 2))(drop5))
merge6 = layers.concatenate([drop4, up6], axis=3)
conv6 = layers.Conv2D(512,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(merge6)
conv6 = layers.Conv2D(512,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv6)
up7 = layers.Conv2D(256,
2,
activation="relu",
padding="same",
kernel_initializer="he_normal")(
layers.UpSampling2D(size=(2, 2))(conv6))
merge7 = layers.concatenate([conv3, up7], axis=3)
conv7 = layers.Conv2D(256,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(merge7)
conv7 = layers.Conv2D(256,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv7)
up8 = layers.Conv2D(128,
2,
activation="relu",
padding="same",
kernel_initializer="he_normal")(
layers.UpSampling2D(size=(2, 2))(conv7))
merge8 = layers.concatenate([conv2, up8], axis=3)
conv8 = layers.Conv2D(128,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(merge8)
conv8 = layers.Conv2D(128,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv8)
up9 = layers.Conv2D(64,
2,
activation="relu",
padding="same",
kernel_initializer="he_normal")(
layers.UpSampling2D(size=(2, 2))(conv8))
merge9 = layers.concatenate([conv1, up9], axis=3)
conv9 = layers.Conv2D(64,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(merge9)
conv9 = layers.Conv2D(64,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv9)
conv9 = layers.Conv2D(2,
3,
activation="relu",
padding="same",
kernel_initializer="he_normal")(conv9)
final_activation = "softmax" if num_classes > 1 else "sigmoid"
conv10 = layers.Conv2D(num_classes, 1, activation=final_activation)(conv9)
model = models.Model(inputs=inputs, outputs=conv10)
return model
def Unet():
concat_axis = 3
ref_input = layers.Input(shape = (1024, 1024, 2))
z_input = layers.Input(shape = (256, 256, 3))
feats = 16
bn0 = layers.BatchNormalization(axis=3)(ref_input)
conv1 = layers.Conv2D(feats, (3, 3), activation='relu', padding='same', name='conv1_1')(bn0)
bn1 = layers.BatchNormalization(axis=3)(conv1)
conv1 = layers.Conv2D(feats, (3, 3), activation='relu', padding='same')(bn1)
bn2 = layers.BatchNormalization(axis=3)(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(bn2)
conv2 = layers.Conv2D(2*feats, (3, 3), activation='relu', padding='same')(pool1)
bn3 = layers.BatchNormalization(axis=3)(conv2)
conv2 = layers.Conv2D(2*feats, (3, 3), activation='relu', padding='same')(bn3)
bn4 = layers.BatchNormalization(axis=3)(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(bn4)
zadd = layers.concatenate([z_input, pool2], axis=concat_axis)
nzadd = layers.BatchNormalization(axis=3)(zadd)
conv3 = layers.Conv2D(4*feats, (3, 3), activation='relu', padding='same')(nzadd)
bn5 = layers.BatchNormalization(axis=3)(conv3)
conv3 = layers.Conv2D(4*feats, (3, 3), activation='relu', padding='same')(bn5)
bn6 = layers.BatchNormalization(axis=3)(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(bn6)
conv4 = layers.Conv2D(8*feats, (3, 3), activation='relu', padding='same')(pool3)
bn7 = layers.BatchNormalization(axis=3)(conv4)
conv4 = layers.Conv2D(8*feats, (3, 3), activation='relu', padding='same')(bn7)
bn8 = layers.BatchNormalization(axis=3)(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(bn8)
conv5 = layers.Conv2D(16*feats, (3, 3), activation='relu', padding='same')(pool4)
bn9 = layers.BatchNormalization(axis=3)(conv5)
conv5 = layers.Conv2D(16*feats, (3, 3), activation='relu', padding='same')(bn9)
bn10 = layers.BatchNormalization(axis=3)(conv5)
pool5 = layers.MaxPooling2D(pool_size=(2, 2))(bn10)
conv6 = layers.Conv2D(32*feats, (3, 3), activation='relu', padding='same')(pool5)
bn11 = layers.BatchNormalization(axis=3)(conv6)
conv6 = layers.Conv2D(32*feats, (3, 3), activation='relu', padding='same')(bn11)
bn12 = layers.BatchNormalization(axis=3)(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(bn12)
up7 = layers.concatenate([up_conv6, conv5], axis=concat_axis)
conv7 = layers.Conv2D(16*feats, (3, 3), activation='relu', padding='same')(up7)
bn13 = layers.BatchNormalization(axis=3)(conv6)
conv7 = layers.Conv2D(16*feats, (3, 3), activation='relu', padding='same')(bn12)
bn14 = layers.BatchNormalization(axis=3)(conv6)
up_conv5 = layers.UpSampling2D(size=(2, 2))(bn10)
up6 = layers.concatenate([up_conv5, conv4], axis=concat_axis)
conv6 = layers.Conv2D(8*feats, (3, 3), activation='relu', padding='same')(up6)
bn15 = layers.BatchNormalization(axis=3)(conv6)
conv6 = layers.Conv2D(8*feats, (3, 3), activation='relu', padding='same')(bn15)
bn16 = layers.BatchNormalization(axis=3)(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(bn16)
up7 = layers.concatenate([up_conv6, conv3], axis=concat_axis)
conv7 = layers.Conv2D(4*feats, (3, 3), activation='relu', padding='same')(up7)
bn13 = layers.BatchNormalization(axis=3)(conv7)
conv7 = layers.Conv2D(4*feats, (3, 3), activation='relu', padding='same')(bn13)
bn14 = layers.BatchNormalization(axis=3)(conv7)
up_conv7 = layers.UpSampling2D(size=(2, 2))(bn14)
up8 = layers.concatenate([up_conv7, conv2], axis=concat_axis)
conv8 = layers.Conv2D(2*feats, (3, 3), activation='relu', padding='same')(up8)
bn15 = layers.BatchNormalization(axis=3)(conv8)
conv8 = layers.Conv2D(2*feats, (3, 3), activation='relu', padding='same')(bn15)
bn16 = layers.BatchNormalization(axis=3)(conv8)
conv10 = layers.Conv2D(1, (1, 1), activation='relu')(bn16)
#bn19 = BatchNormalization(axis=3)(conv10)
model = tf.keras.models.Model(inputs=[ref_input,z_input], outputs=conv10)
return model
route = '' route = '' maxpool = l.MaxPool2D(pool_size=(13, 13), strides=1, padding='same')(layer) layer = tf.concat([layer, maxpool, maxpool, maxpool], axis=-1) #route layer = conv(layer, 512, 1, 1) layer = conv(layer, 512, 3, 1) layer = tf.concat([layer, conv7], axis=-1) #route layer = conv(layer, 512, 1, 1) route1 = layer layer = conv(layer, 256, 1, 1) layer = l.UpSampling2D(size=(2, 2))(layer) layer = tf.concat([layer, conv5], axis=-1) #route layer = conv(layer, 256, 1, 1) conv8 = conv(layer, 256, 1, 1) route = '' layer = conv(layer, 256, 1, 1) layer = conv(layer, 256, 3, 1) layer = conv(layer, 256, 1, 1) layer = conv(layer, 256, 3, 1) layer = tf.concat([layer, conv8], axis=-1) #route layer = conv(layer, 256, 1, 1) route2 = layer layer = conv(layer, 128, 1, 1)
def VanillaUnet(num_class = 1, img_shape = (256,256,3)):
concat_axis = 3
# input
inputs = layers.Input(shape = img_shape)
# Unet convolution block 1
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same', name='conv1_1')(inputs)
conv1 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(conv1)
# Unet convolution block 2
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)
conv2 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(conv2)
# Unet convolution block 3
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)
conv3 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(conv3)
# Unet convolution block 4
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)
conv4 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(conv4)
# Unet convolution block 5
conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)
conv5 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)
# Unet up-sampling block 1; Concatenation with crop_conv4
up_conv5 = layers.UpSampling2D(size=(2, 2))(conv5)
ch, cw = get_crop_shape(conv4, up_conv5)
crop_conv4 = layers.Cropping2D(cropping=(ch,cw))(conv4)
up6 = layers.concatenate([up_conv5, crop_conv4], axis=concat_axis)
conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(up6)
conv6 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)
# Unet up-sampling block 2; Concatenation with crop_conv3
up_conv6 = layers.UpSampling2D(size=(2, 2))(conv6)
ch, cw = get_crop_shape(conv3, up_conv6)
crop_conv3 = layers.Cropping2D(cropping=(ch,cw))(conv3)
up7 = layers.concatenate([up_conv6, crop_conv3], axis=concat_axis)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(up7)
conv7 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)
# Unet up-sampling block 3; Concatenation with crop_conv2
up_conv7 = layers.UpSampling2D(size=(2, 2))(conv7)
ch, cw = get_crop_shape(conv2, up_conv7)
crop_conv2 = layers.Cropping2D(cropping=(ch,cw))(conv2)
up8 = layers.concatenate([up_conv7, crop_conv2], axis=concat_axis)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(up8)
conv8 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)
# Unet up-sampling block 4; Concatenation with crop_conv1
up_conv8 = layers.UpSampling2D(size=(2, 2))(conv8)
ch, cw = get_crop_shape(conv1, up_conv8)
crop_conv1 = layers.Cropping2D(cropping=(ch,cw))(conv1)
up9 = layers.concatenate([up_conv8, crop_conv1], axis=concat_axis)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(up9)
conv9 = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)
ch, cw = get_crop_shape(inputs, conv9)
conv9 = layers.ZeroPadding2D(padding=((ch[0], ch[1]), (cw[0], cw[1])))(conv9)
conv10 = layers.Conv2D(num_class, (1, 1))(conv9)
model = Model(inputs=inputs, outputs=conv10)
return model
def dbnet(input_size=640, k=50):
image_input = layers.Input(shape=(None, None, 3))
gt_input = layers.Input(shape=(input_size, input_size))
mask_input = layers.Input(shape=(input_size, input_size))
thresh_input = layers.Input(shape=(input_size, input_size))
thresh_mask_input = layers.Input(shape=(input_size, input_size))
#backbone = ResNet50(inputs=image_input, include_top=False, freeze_bn=True)
backbone = ResNet50V2(include_top=False, weights='imagenet', input_tensor = image_input)
#get output layers
output_names = ['conv2_block3_out','conv3_block4_out','conv4_block6_out','conv5_block3_out']
[C2, C3, C4, C5] = [x.output for x in backbone.layers if x.name in output_names]
in2 = layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in2')(C2)
in3 = layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in3')(C3)
in4 = layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in4')(C4)
in5 = layers.Conv2D(256, (1, 1), padding='same', kernel_initializer='he_normal', name='in5')(C5)
print("IN shapes")
print(in2.shape)
print(in3.shape)
print(in4.shape)
print(in5.shape)
# 1 / 32 * 8 = 1 / 4
P5 = layers.UpSampling2D(size=(8, 8))(
layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(in5))
# 1 / 16 * 4 = 1 / 4
out4 = layers.Add()([in4, layers.UpSampling2D(size=(2, 2))(in5)])
P4 = layers.UpSampling2D(size=(4, 4))(
layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(out4))
# 1 / 8 * 2 = 1 / 4
out3 = layers.Add()([in3, layers.UpSampling2D(size=(2, 2))(out4)])
P3 = layers.UpSampling2D(size=(2, 2))(
layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(out3))
# 1 / 4
P2 = layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal')(
layers.Add()([in2, layers.UpSampling2D(size=(2, 2))(out3)]))
# (b, /4, /4, 256)
print("P shapes")
print(P2.shape)
print(P3.shape)
print(P4.shape)
print(P5.shape)
fuse = layers.Concatenate()([P2, P3, P4, P5])
# probability map
p = layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal', use_bias=False)(fuse)
p = layers.BatchNormalization()(p)
p = layers.ReLU()(p)
p = layers.Conv2DTranspose(64, (2, 2), strides=(2, 2), kernel_initializer='he_normal', use_bias=False)(p)
p = layers.BatchNormalization()(p)
p = layers.ReLU()(p)
p = layers.Conv2DTranspose(1, (2, 2), strides=(2, 2), kernel_initializer='he_normal',
activation='sigmoid')(p)
# threshold map
t = layers.Conv2D(64, (3, 3), padding='same', kernel_initializer='he_normal', use_bias=False)(fuse)
t = layers.BatchNormalization()(t)
t = layers.ReLU()(t)
t = layers.Conv2DTranspose(64, (2, 2), strides=(2, 2), kernel_initializer='he_normal', use_bias=False)(t)
t = layers.BatchNormalization()(t)
t = layers.ReLU()(t)
t = layers.Conv2DTranspose(1, (2, 2), strides=(2, 2), kernel_initializer='he_normal',
activation='sigmoid')(t)
# approximate binary map
b_hat = layers.Lambda(lambda x: 1 / (1 + tf.compat.v1.exp(-k * (x[0] - x[1]))))([p, t])
print("SHAPES ")
print("C2 " )
print(C2.shape)
print(p.shape)
print(b_hat.shape)
print(gt_input.shape)
print(mask_input.shape)
print(t.shape)
print(thresh_input.shape)
print(thresh_mask_input.shape)
loss = tf.compat.v1.keras.layers.Lambda(db_loss, name='db_loss', output_shape = (None, None, None, 1))([p, b_hat, gt_input, mask_input, t, thresh_input, thresh_mask_input])
print(loss.shape)
training_model = models.Model(inputs=[image_input, gt_input, mask_input, thresh_input, thresh_mask_input],
outputs=loss)
print("CONV1")
print(training_model.get_layer("conv1_conv").input)
print(training_model.get_layer("conv1_conv").output)
prediction_model = models.Model(inputs=image_input, outputs=p)
print(training_model.summary())
return training_model, prediction_model
def get_unet():
concat_axis = 3
inputs = layers.Input(shape=(512, 512, 1))
#ss = layers.Lambda(lambda x: x[:,:,:,1:], output_shape=(None,512,512,2))(inputs)
feats = 8 #16
bn0 = BatchNormalization(axis=3)(inputs)
conv1 = layers.Conv2D(feats, (3, 3),
activation='relu',
padding='same',
name='conv1_1')(bn0)
bn2 = BatchNormalization(axis=3)(conv1)
pool1 = layers.MaxPooling2D(pool_size=(2, 2))(bn2) #256
conv2 = layers.Conv2D(2 * feats, (3, 3), activation='relu',
padding='same')(pool1)
bn4 = BatchNormalization(axis=3)(conv2)
pool2 = layers.MaxPooling2D(pool_size=(2, 2))(bn4) #128
conv3 = layers.Conv2D(4 * feats, (3, 3), activation='relu',
padding='same')(pool2)
bn6 = BatchNormalization(axis=3)(conv3)
pool3 = layers.MaxPooling2D(pool_size=(2, 2))(bn6) #64
conv4 = layers.Conv2D(8 * feats, (3, 3), activation='relu',
padding='same')(pool3)
bn8 = BatchNormalization(axis=3)(conv4)
pool4 = layers.MaxPooling2D(pool_size=(2, 2))(bn8) #32
conv5 = layers.Conv2D(16 * feats, (3, 3),
activation='relu',
padding='same')(pool4)
bn10 = BatchNormalization(axis=3)(conv5)
pool5 = layers.MaxPooling2D(pool_size=(2, 2))(bn10) #16
conv6 = layers.Conv2D(32 * feats, (3, 3),
activation='relu',
padding='same')(pool5)
bn11 = BatchNormalization(axis=3)(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(bn11) #32
up7 = layers.concatenate([up_conv6, conv5], axis=concat_axis)
conv7 = layers.Conv2D(16 * feats, (3, 3),
activation='relu',
padding='same')(up7)
bn13 = BatchNormalization(axis=3)(conv7)
up_conv5 = layers.UpSampling2D(size=(2, 2))(bn13) #64
up6 = layers.concatenate([up_conv5, conv4], axis=concat_axis)
conv6 = layers.Conv2D(8 * feats, (3, 3), activation='relu',
padding='same')(up6)
bn15 = BatchNormalization(axis=3)(conv6)
up_conv6 = layers.UpSampling2D(size=(2, 2))(bn15) #128
up7 = layers.concatenate([up_conv6, conv3], axis=concat_axis)
conv7 = layers.Conv2D(4 * feats, (3, 3), activation='relu',
padding='same')(up7)
bn13 = BatchNormalization(axis=3)(conv7)
# Rectify last convolution layer to constraint output to positive precipitation values.
conv8 = layers.Conv2D(1, (1, 1), activation='relu')(bn13)
model = models.Model(inputs=inputs, outputs=conv8)
return model
def dunet(height=560, width=400, nbr_mask=10, nbr=16, activation='softmax'):
#Inputimage
entree = layers.Input(shape=(height, width, 3), dtype='float32')
#Level 0
result = layers.Conv2D(nbr, 3, activation='relu', padding='same')(entree)
result = layers.BatchNormalization()(result)
result = layers.Conv2D(nbr, 3, activation='relu', padding='same')(result)
result1 = layers.BatchNormalization()(result)
result = layers.MaxPool2D()(result1)
#Level -1
result = layers.Conv2D(2 * nbr, 3, activation='relu',
padding='same')(result)
result = layers.BatchNormalization()(result)
result = layers.Conv2D(2 * nbr, 3, activation='relu',
padding='same')(result)
result2 = layers.BatchNormalization()(result)
result = layers.MaxPool2D()(result2)
#Level -2
result = layers.Conv2D(4 * nbr, 3, activation='relu',
padding='same')(result)
result = layers.BatchNormalization()(result)
result = layers.Conv2D(4 * nbr, 3, activation='relu',
padding='same')(result)
result3 = layers.BatchNormalization()(result)
result = layers.MaxPool2D()(result3)
# Level -3
result = layers.Conv2D(8 * nbr, 3, activation='relu',
padding='same')(result)
result = layers.BatchNormalization()(result)
# ASPP
b0 = layers.DepthwiseConv2D(3, activation='relu', padding='same')(result)
b0 = layers.BatchNormalization()(b0)
b0 = layers.Conv2D(8 * nbr, 1, activation='relu', padding='same')(b0)
b0 = layers.BatchNormalization()(b0)
b1 = layers.DepthwiseConv2D(3,
dilation_rate=(6, 6),
activation='relu',
padding='same')(result)
b1 = layers.BatchNormalization()(b1)
b1 = layers.Conv2D(8 * nbr, 1, activation='relu', padding='same')(b1)
b1 = layers.BatchNormalization()(b1)
b2 = layers.DepthwiseConv2D(3,
dilation_rate=(12, 12),
activation='relu',
padding='same')(result)
b2 = layers.BatchNormalization()(b2)
b2 = layers.Conv2D(8 * nbr, 1, activation='relu', padding='same')(b2)
b2 = layers.BatchNormalization()(b2)
b3 = layers.DepthwiseConv2D(3,
dilation_rate=(18, 18),
activation='relu',
padding='same')(result)
b3 = layers.BatchNormalization()(b3)
b3 = layers.Conv2D(8 * nbr, 1, activation='relu', padding='same')(b3)
b3 = layers.BatchNormalization()(b3)
b4 = layers.AveragePooling2D()(result)
b4 = layers.Conv2D(8 * nbr, 1, activation='relu', padding='same')(b4)
b4 = layers.BatchNormalization()(b4)
b4 = layers.UpSampling2D(interpolation='bilinear')(b4)
result = layers.Concatenate()([b4, b0, b1, b2, b3])
result = layers.Conv2D(8 * nbr, 1, activation='relu',
padding='same')(result)
result = layers.Conv2DTranspose(4 * nbr,
2,
strides=(2, 2),
activation='relu',
padding='same')(result)
# Level -2
result = tf.concat([result, result3], axis=3)
result = layers.Conv2D(4 * nbr, 3, activation='relu',
padding='same')(result)
result = layers.BatchNormalization()(result)
result = layers.Conv2D(4 * nbr, 3, activation='relu',
padding='same')(result)
result = layers.BatchNormalization()(result)
result = layers.Conv2DTranspose(2 * nbr,
2,
strides=(2, 2),
activation='relu',
padding='same')(result)
# Level -1
result = tf.concat([result, result2], axis=3)
result = layers.Conv2D(2 * nbr, 3, activation='relu',
padding='same')(result)
result = layers.BatchNormalization()(result)
result = layers.Conv2D(2 * nbr, 3, activation='relu',
padding='same')(result)
result = layers.BatchNormalization()(result)
result = layers.Conv2DTranspose(nbr,
2,
strides=(2, 2),
activation='relu',
padding='same')(result)
# Level 0
result = tf.concat([result, result1], axis=3)
result = layers.Conv2D(nbr, 3, activation='relu', padding='same')(result)
result = layers.BatchNormalization()(result)
result = layers.Conv2D(nbr, 3, activation='relu', padding='same')(result)
result = layers.BatchNormalization()(result)
# Output
sortie = layers.Conv2D(nbr_mask, 1, activation=activation,
padding='same')(result)
model = models.Model(inputs=entree, outputs=sortie)
return model
def build_BiFPN(features, num_channels, id, freeze_bn=False):
if id == 0:
_, _, C3, C4, C5 = features
P3_in = C3
P4_in = C4
P5_in = C5
P6_in = layers.Conv2D(num_channels,
kernel_size=1,
padding='same',
name='resample_p6/conv2d')(C5)
P6_in = layers.BatchNormalization(momentum=MOMENTUM,
epsilon=EPSILON,
name='resample_p6/bn')(P6_in)
# P6_in = BatchNormalization(freeze=freeze_bn, name='resample_p6/bn')(P6_in)
P6_in = layers.MaxPooling2D(pool_size=3,
strides=2,
padding='same',
name='resample_p6/maxpool')(P6_in)
P7_in = layers.MaxPooling2D(pool_size=3,
strides=2,
padding='same',
name='resample_p7/maxpool')(P6_in)
P7_U = layers.UpSampling2D()(P7_in)
P6_td = layers.Add(name=f'fpn_cells/cell_{id}/fnode0/add')(
[P6_in, P7_U])
P6_td = layers.Activation(lambda x: tf.nn.swish(x))(P6_td)
P6_td = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode0/op_after_combine5')(P6_td)
P5_in_1 = layers.Conv2D(
num_channels,
kernel_size=1,
padding='same',
name=f'fpn_cells/cell_{id}/fnode1/resample_0_2_6/conv2d')(P5_in)
P5_in_1 = layers.BatchNormalization(
momentum=MOMENTUM,
epsilon=EPSILON,
name=f'fpn_cells/cell_{id}/fnode1/resample_0_2_6/bn')(P5_in_1)
# P5_in_1 = BatchNormalization(freeze=freeze_bn, name=f'fpn_cells/cell_{id}/fnode1/resample_0_2_6/bn')(P5_in_1)
P6_U = layers.UpSampling2D()(P6_td)
P5_td = layers.Add(name=f'fpn_cells/cell_{id}/fnode1/add')(
[P5_in_1, P6_U])
P5_td = layers.Activation(lambda x: tf.nn.swish(x))(P5_td)
P5_td = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode1/op_after_combine6')(P5_td)
P4_in_1 = layers.Conv2D(
num_channels,
kernel_size=1,
padding='same',
name=f'fpn_cells/cell_{id}/fnode2/resample_0_1_7/conv2d')(P4_in)
P4_in_1 = layers.BatchNormalization(
momentum=MOMENTUM,
epsilon=EPSILON,
name=f'fpn_cells/cell_{id}/fnode2/resample_0_1_7/bn')(P4_in_1)
# P4_in_1 = BatchNormalization(freeze=freeze_bn, name=f'fpn_cells/cell_{id}/fnode2/resample_0_1_7/bn')(P4_in_1)
P5_U = layers.UpSampling2D()(P5_td)
P4_td = layers.Add(name=f'fpn_cells/cell_{id}/fnode2/add')(
[P4_in_1, P5_U])
P4_td = layers.Activation(lambda x: tf.nn.swish(x))(P4_td)
P4_td = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode2/op_after_combine7')(P4_td)
P3_in = layers.Conv2D(
num_channels,
kernel_size=1,
padding='same',
name=f'fpn_cells/cell_{id}/fnode3/resample_0_0_8/conv2d')(P3_in)
P3_in = layers.BatchNormalization(
momentum=MOMENTUM,
epsilon=EPSILON,
name=f'fpn_cells/cell_{id}/fnode3/resample_0_0_8/bn')(P3_in)
# P3_in = BatchNormalization(freeze=freeze_bn, name=f'fpn_cells/cell_{id}/fnode3/resample_0_0_8/bn')(P3_in)
P4_U = layers.UpSampling2D()(P4_td)
P3_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode3/add')(
[P3_in, P4_U])
P3_out = layers.Activation(lambda x: tf.nn.swish(x))(P3_out)
P3_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode3/op_after_combine8')(P3_out)
P4_in_2 = layers.Conv2D(
num_channels,
kernel_size=1,
padding='same',
name=f'fpn_cells/cell_{id}/fnode4/resample_0_1_9/conv2d')(P4_in)
P4_in_2 = layers.BatchNormalization(
momentum=MOMENTUM,
epsilon=EPSILON,
name=f'fpn_cells/cell_{id}/fnode4/resample_0_1_9/bn')(P4_in_2)
# P4_in_2 = BatchNormalization(freeze=freeze_bn, name=f'fpn_cells/cell_{id}/fnode4/resample_0_1_9/bn')(P4_in_2)
P3_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P3_out)
P4_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode4/add')(
[P4_in_2, P4_td, P3_D])
P4_out = layers.Activation(lambda x: tf.nn.swish(x))(P4_out)
P4_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode4/op_after_combine9')(P4_out)
P5_in_2 = layers.Conv2D(
num_channels,
kernel_size=1,
padding='same',
name=f'fpn_cells/cell_{id}/fnode5/resample_0_2_10/conv2d')(P5_in)
P5_in_2 = layers.BatchNormalization(
momentum=MOMENTUM,
epsilon=EPSILON,
name=f'fpn_cells/cell_{id}/fnode5/resample_0_2_10/bn')(P5_in_2)
# P5_in_2 = BatchNormalization(freeze=freeze_bn, name=f'fpn_cells/cell_{id}/fnode5/resample_0_2_10/bn')(P5_in_2)
P4_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P4_out)
P5_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode5/add')(
[P5_in_2, P5_td, P4_D])
P5_out = layers.Activation(lambda x: tf.nn.swish(x))(P5_out)
P5_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode5/op_after_combine10')(P5_out)
P5_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P5_out)
P6_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode6/add')(
[P6_in, P6_td, P5_D])
P6_out = layers.Activation(lambda x: tf.nn.swish(x))(P6_out)
P6_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode6/op_after_combine11')(P6_out)
P6_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P6_out)
P7_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode7/add')(
[P7_in, P6_D])
P7_out = layers.Activation(lambda x: tf.nn.swish(x))(P7_out)
P7_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode7/op_after_combine12')(P7_out)
else:
P3_in, P4_in, P5_in, P6_in, P7_in = features
P7_U = layers.UpSampling2D()(P7_in)
P6_td = layers.Add(name=f'fpn_cells/cell_{id}/fnode0/add')(
[P6_in, P7_U])
P6_td = layers.Activation(lambda x: tf.nn.swish(x))(P6_td)
P6_td = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode0/op_after_combine5')(P6_td)
P6_U = layers.UpSampling2D()(P6_td)
P5_td = layers.Add(name=f'fpn_cells/cell_{id}/fnode1/add')(
[P5_in, P6_U])
P5_td = layers.Activation(lambda x: tf.nn.swish(x))(P5_td)
P5_td = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode1/op_after_combine6')(P5_td)
P5_U = layers.UpSampling2D()(P5_td)
P4_td = layers.Add(name=f'fpn_cells/cell_{id}/fnode2/add')(
[P4_in, P5_U])
P4_td = layers.Activation(lambda x: tf.nn.swish(x))(P4_td)
P4_td = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode2/op_after_combine7')(P4_td)
P4_U = layers.UpSampling2D()(P4_td)
P3_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode3/add')(
[P3_in, P4_U])
P3_out = layers.Activation(lambda x: tf.nn.swish(x))(P3_out)
P3_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode3/op_after_combine8')(P3_out)
P3_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P3_out)
P4_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode4/add')(
[P4_in, P4_td, P3_D])
P4_out = layers.Activation(lambda x: tf.nn.swish(x))(P4_out)
P4_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode4/op_after_combine9')(P4_out)
P4_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P4_out)
P5_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode5/add')(
[P5_in, P5_td, P4_D])
P5_out = layers.Activation(lambda x: tf.nn.swish(x))(P5_out)
P5_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode5/op_after_combine10')(P5_out)
P5_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P5_out)
P6_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode6/add')(
[P6_in, P6_td, P5_D])
P6_out = layers.Activation(lambda x: tf.nn.swish(x))(P6_out)
P6_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode6/op_after_combine11')(P6_out)
P6_D = layers.MaxPooling2D(pool_size=3, strides=2,
padding='same')(P6_out)
P7_out = layers.Add(name=f'fpn_cells/cell_{id}/fnode7/add')(
[P7_in, P6_D])
P7_out = layers.Activation(lambda x: tf.nn.swish(x))(P7_out)
P7_out = SeparableConvBlock(
num_channels=num_channels,
kernel_size=3,
strides=1,
name=f'fpn_cells/cell_{id}/fnode7/op_after_combine12')(P7_out)
return P3_out, P4_td, P5_td, P6_td, P7_out
def upconv_concat(net, tensor_concat):
net = layers.UpSampling2D(size=(2, 2))(net)
return layers.Concatenate(axis=-1)([net, tensor_concat])
